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

[in-place weak refs] Remove WeakCell

Browse Source 
BUG=v8:7308

Change-Id: I310d9453be8b90a82856c0d394442aad5527a3ae
Reviewed-on: https://chromium-review.googlesource.com/1169167
Commit-Queue: Marja Hölttä <marja@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Hannes Payer <hpayer@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#55105}
This commit is contained in:
Marja Hölttä 2018-08-14 09:18:05 +02:00 committed by Commit Bot
parent 6c7c81e07c
commit 8b63f353e6
35 changed files with 155 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -5487,11 +5487,6 @@ TNode<BoolT> CodeStubAssembler::IsFixedArrayWithKind(
}
}
TNode<BoolT> CodeStubAssembler::IsWeakCell(SloppyTNode<HeapObject> object) {
CSA_ASSERT(this, IsStrongHeapObject(object));
return IsWeakCellMap(LoadMap(object));
}
TNode<BoolT> CodeStubAssembler::IsBoolean(SloppyTNode<HeapObject> object) {
return IsBooleanMap(LoadMap(object));
}

3
src/code-stub-assembler.h
View File

@ -47,7 +47,6 @@ enum class PrimitiveType { kBoolean, kNumber, kString, kSymbol };
V(EmptySlowElementDictionary, empty_slow_element_dictionary, \
EmptySlowElementDictionary) \
V(empty_string, empty_string, EmptyString) \
V(EmptyWeakCell, empty_weak_cell, EmptyWeakCell) \
V(FalseValue, false_value, False) \
V(FeedbackVectorMap, feedback_vector_map, FeedbackVectorMap) \
V(FixedArrayMap, fixed_array_map, FixedArrayMap) \
@ -86,7 +85,6 @@ enum class PrimitiveType { kBoolean, kNumber, kString, kSymbol };
uncompiled_data_with_pre_parsed_scope_map, \
UncompiledDataWithPreParsedScopeMap) \
V(UndefinedValue, undefined_value, Undefined) \
V(WeakCellMap, weak_cell_map, WeakCellMap) \
V(WeakFixedArrayMap, weak_fixed_array_map, WeakFixedArrayMap)
#define HEAP_IMMOVABLE_OBJECT_LIST(V) \
@ -1807,7 +1805,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
TNode<BoolT> IsSymbolInstanceType(SloppyTNode<Int32T> instance_type);
TNode<BoolT> IsSymbol(SloppyTNode<HeapObject> object);
TNode<BoolT> IsUndetectableMap(SloppyTNode<Map> map);
TNode<BoolT> IsWeakCell(SloppyTNode<HeapObject> object);
TNode<BoolT> IsNotWeakFixedArraySubclass(SloppyTNode<HeapObject> object);
TNode<BoolT> IsZeroOrContext(SloppyTNode<Object> object);

1
src/compiler/types.cc
View File

@ -324,7 +324,6 @@ Type::bitset BitsetType::Lub(HeapObjectType const& type) {
case PROMISE_REACTION_TYPE:
case DEBUG_INFO_TYPE:
case STACK_FRAME_INFO_TYPE:
case WEAK_CELL_TYPE:
case SMALL_ORDERED_HASH_MAP_TYPE:
case SMALL_ORDERED_HASH_SET_TYPE:
case PROTOTYPE_INFO_TYPE:

1
src/feedback-vector.cc
View File

@ -377,7 +377,6 @@ void FeedbackVector::AssertNoLegacyTypes(MaybeObject* object) {
// Instead of FixedArray, the Feedback and the Extra should contain
// WeakFixedArrays. The only allowed FixedArray subtype is HashTable.
DCHECK_IMPLIES(heap_object->IsFixedArray(), heap_object->IsHashTable());
DCHECK(!heap_object->IsWeakCell());
}
#endif
}

8
src/feedback-vector.h
View File

@ -501,14 +501,6 @@ class FeedbackMetadata : public HeapObject {
DISALLOW_IMPLICIT_CONSTRUCTORS(FeedbackMetadata);
};
// The following asserts protect an optimization in type feedback vector
// code that looks into the contents of a slot assuming to find a String,
// a Symbol, an AllocationSite, a WeakCell, or a FixedArray.
STATIC_ASSERT(WeakCell::kSize >= 2 * kPointerSize);
STATIC_ASSERT(WeakCell::kValueOffset ==
AllocationSite::kTransitionInfoOrBoilerplateOffset);
STATIC_ASSERT(WeakCell::kValueOffset == FixedArray::kLengthOffset);
STATIC_ASSERT(WeakCell::kValueOffset == Name::kHashFieldSlot);
// Verify that an empty hash field looks like a tagged object, but can't
// possibly be confused with a pointer.
STATIC_ASSERT((Name::kEmptyHashField & kHeapObjectTag) == kHeapObjectTag);

1
src/heap-symbols.h
View File

@ -332,7 +332,6 @@
F(MC_CLEAR_SLOTS_BUFFER) \
F(MC_CLEAR_STORE_BUFFER) \
F(MC_CLEAR_STRING_TABLE) \
F(MC_CLEAR_WEAK_CELLS) \
F(MC_CLEAR_WEAK_COLLECTIONS) \
F(MC_CLEAR_WEAK_LISTS) \
F(MC_CLEAR_WEAK_REFERENCES) \

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

@ -332,26 +332,6 @@ class ConcurrentMarkingVisitor final
return size;
}
int VisitWeakCell(Map* map, WeakCell* object) {
if (!ShouldVisit(object)) return 0;
VisitMapPointer(object, object->map_slot());
if (!object->cleared()) {
HeapObject* value = HeapObject::cast(object->value());
if (marking_state_.IsBlackOrGrey(value)) {
// Weak cells with live values are directly processed here to reduce
// the processing time of weak cells during the main GC pause.
Object** slot = HeapObject::RawField(object, WeakCell::kValueOffset);
MarkCompactCollector::RecordSlot(object, slot, value);
} else {
// If we do not know about liveness of values of weak cells, we have to
// process them when we know the liveness of the whole transitive
// closure.
weak_objects_->weak_cells.Push(task_id_, object);
}
}
return WeakCell::BodyDescriptor::SizeOf(map, object);
}
int VisitJSWeakCollection(Map* map, JSWeakCollection* object) {
return VisitJSObjectSubclass(map, object);
}
@ -647,7 +627,6 @@ void ConcurrentMarking::Run(int task_id, TaskState* task_state) {
bailout_->FlushToGlobal(task_id);
on_hold_->FlushToGlobal(task_id);
weak_objects_->weak_cells.FlushToGlobal(task_id);
weak_objects_->transition_arrays.FlushToGlobal(task_id);
weak_objects_->ephemeron_hash_tables.FlushToGlobal(task_id);
weak_objects_->current_ephemerons.FlushToGlobal(task_id);

13
src/heap/factory.cc
View File

@ -1775,19 +1775,6 @@ Handle<PropertyCell> Factory::NewPropertyCell(Handle<Name> name,
return cell;
}
Handle<WeakCell> Factory::NewWeakCell(Handle<HeapObject> value,
PretenureFlag pretenure) {
// It is safe to dereference the value because we are embedding it
// in cell and not inspecting its fields.
AllowDeferredHandleDereference convert_to_cell;
STATIC_ASSERT(WeakCell::kSize <= kMaxRegularHeapObjectSize);
HeapObject* result =
AllocateRawWithImmortalMap(WeakCell::kSize, pretenure, *weak_cell_map());
Handle<WeakCell> cell(WeakCell::cast(result), isolate());
cell->initialize(*value);
return cell;
}
Handle<TransitionArray> Factory::NewTransitionArray(int number_of_transitions,
int slack) {
int capacity = TransitionArray::LengthFor(number_of_transitions + slack);

3
src/heap/factory.h
View File

@ -457,9 +457,6 @@ class V8_EXPORT_PRIVATE Factory {
Handle<PropertyCell> NewPropertyCell(Handle<Name> name,
PretenureFlag pretenure = TENURED);
Handle<WeakCell> NewWeakCell(Handle<HeapObject> value,
PretenureFlag pretenure = TENURED);
Handle<FeedbackCell> NewNoClosuresCell(Handle<HeapObject> value);
Handle<FeedbackCell> NewOneClosureCell(Handle<HeapObject> value);
Handle<FeedbackCell> NewManyClosuresCell(Handle<HeapObject> value);

2
src/heap/gc-tracer.cc
View File

@ -665,7 +665,6 @@ void GCTracer::PrintNVP() const {
"clear.slots_buffer=%.1f "
"clear.store_buffer=%.1f "
"clear.string_table=%.1f "
"clear.weak_cells=%.1f "
"clear.weak_collections=%.1f "
"clear.weak_lists=%.1f "
"clear.weak_references=%.1f "
@ -762,7 +761,6 @@ void GCTracer::PrintNVP() const {
current_.scopes[Scope::MC_CLEAR_SLOTS_BUFFER],
current_.scopes[Scope::MC_CLEAR_STORE_BUFFER],
current_.scopes[Scope::MC_CLEAR_STRING_TABLE],
current_.scopes[Scope::MC_CLEAR_WEAK_CELLS],
current_.scopes[Scope::MC_CLEAR_WEAK_COLLECTIONS],
current_.scopes[Scope::MC_CLEAR_WEAK_LISTS],
current_.scopes[Scope::MC_CLEAR_WEAK_REFERENCES],

2
src/heap/heap.h
View File

@ -88,7 +88,6 @@ using v8::MemoryPressureLevel;
V(EmptyScript) \
V(EmptySloppyArgumentsElements) \
V(EmptySlowElementDictionary) \
V(EmptyWeakCell) \
V(EvalContextMap) \
V(Exception) \
V(FalseValue) \
@ -159,7 +158,6 @@ using v8::MemoryPressureLevel;
V(UninitializedValue) \
V(UncompiledDataWithoutPreParsedScopeMap) \
V(UncompiledDataWithPreParsedScopeMap) \
V(WeakCellMap) \
V(WeakFixedArrayMap) \
V(WeakArrayListMap) \
V(WithContextMap) \

24
src/heap/mark-compact-inl.h
View File

@ -159,30 +159,6 @@ int MarkingVisitor<fixed_array_mode, retaining_path_mode,
return size;
}
template <FixedArrayVisitationMode fixed_array_mode,
TraceRetainingPathMode retaining_path_mode, typename MarkingState>
int MarkingVisitor<fixed_array_mode, retaining_path_mode,
MarkingState>::VisitWeakCell(Map* map, WeakCell* weak_cell) {
// Enqueue weak cell in linked list of encountered weak collections.
// We can ignore weak cells with cleared values because they will always
// contain smi zero.
if (!weak_cell->cleared()) {
HeapObject* value = HeapObject::cast(weak_cell->value());
if (marking_state()->IsBlackOrGrey(value)) {
// Weak cells with live values are directly processed here to reduce
// the processing time of weak cells during the main GC pause.
Object** slot = HeapObject::RawField(weak_cell, WeakCell::kValueOffset);
collector_->RecordSlot(weak_cell, slot, HeapObject::cast(*slot));
} else {
// If we do not know about liveness of values of weak cells, we have to
// process them when we know the liveness of the whole transitive
// closure.
collector_->AddWeakCell(weak_cell);
}
}
return WeakCell::BodyDescriptor::SizeOf(map, weak_cell);
}
template <FixedArrayVisitationMode fixed_array_mode,
TraceRetainingPathMode retaining_path_mode, typename MarkingState>
void MarkingVisitor<fixed_array_mode, retaining_path_mode,

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

@ -1886,13 +1886,11 @@ void MarkCompactCollector::ClearNonLiveReferences() {
// cleared.
ClearFullMapTransitions();
}
ClearWeakCells();
ClearWeakReferences();
MarkDependentCodeForDeoptimization();
ClearWeakCollections();
DCHECK(weak_objects_.weak_cells.IsEmpty());
DCHECK(weak_objects_.transition_arrays.IsEmpty());
DCHECK(weak_objects_.weak_references.IsEmpty());
DCHECK(weak_objects_.weak_objects_in_code.IsEmpty());
@ -1951,7 +1949,7 @@ void MarkCompactCollector::ClearFullMapTransitions() {
// The array might contain "undefined" elements because it's not yet
// filled. Allow it.
if (array->GetTargetIfExists(0, isolate(), &map)) {
DCHECK_NOT_NULL(map); // WeakCells aren't cleared yet.
DCHECK_NOT_NULL(map); // Weak pointers aren't cleared yet.
Map* parent = Map::cast(map->constructor_or_backpointer());
bool parent_is_alive =
non_atomic_marking_state()->IsBlackOrGrey(parent);
@ -2089,46 +2087,6 @@ void MarkCompactCollector::ClearWeakCollections() {
}
}
void MarkCompactCollector::ClearWeakCells() {
Heap* heap = this->heap();
TRACE_GC(heap->tracer(), GCTracer::Scope::MC_CLEAR_WEAK_CELLS);
WeakCell* weak_cell;
while (weak_objects_.weak_cells.Pop(kMainThread, &weak_cell)) {
// We do not insert cleared weak cells into the list, so the value
// cannot be a Smi here.
HeapObject* value = HeapObject::cast(weak_cell->value());
if (!non_atomic_marking_state()->IsBlackOrGrey(value)) {
// Cells for new-space objects embedded in optimized code are wrapped in
// WeakCell and put into Heap::weak_object_to_code_table.
// Such cells do not have any strong references but we want to keep them
// alive as long as the cell value is alive.
// TODO(ulan): remove this once we remove Heap::weak_object_to_code_table.
if (value->IsCell()) {
Object* cell_value = Cell::cast(value)->value();
if (cell_value->IsHeapObject() &&
non_atomic_marking_state()->IsBlackOrGrey(
HeapObject::cast(cell_value))) {
// Resurrect the cell.
non_atomic_marking_state()->WhiteToBlack(value);
Object** slot = HeapObject::RawField(value, Cell::kValueOffset);
RecordSlot(value, slot, HeapObject::cast(*slot));
slot = HeapObject::RawField(weak_cell, WeakCell::kValueOffset);
RecordSlot(weak_cell, slot, HeapObject::cast(*slot));
} else {
weak_cell->clear();
}
} else {
// All other objects.
weak_cell->clear();
}
} else {
// The value of the weak cell is alive.
Object** slot = HeapObject::RawField(weak_cell, WeakCell::kValueOffset);
RecordSlot(weak_cell, slot, HeapObject::cast(*slot));
}
}
}
void MarkCompactCollector::ClearWeakReferences() {
TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_CLEAR_WEAK_REFERENCES);
std::pair<HeapObject*, HeapObjectReference**> slot;
@ -2152,7 +2110,6 @@ void MarkCompactCollector::ClearWeakReferences() {
}
void MarkCompactCollector::AbortWeakObjects() {
weak_objects_.weak_cells.Clear();
weak_objects_.transition_arrays.Clear();
weak_objects_.ephemeron_hash_tables.Clear();
weak_objects_.current_ephemerons.Clear();

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

@ -420,7 +420,6 @@ typedef Worklist<Ephemeron, 64> EphemeronWorklist;
// Weak objects encountered during marking.
struct WeakObjects {
Worklist<WeakCell*, 64> weak_cells;
Worklist<TransitionArray*, 64> transition_arrays;
// Keep track of all EphemeronHashTables in the heap to process
@ -647,10 +646,6 @@ class MarkCompactCollector final : public MarkCompactCollectorBase {
WeakObjects* weak_objects() { return &weak_objects_; }
void AddWeakCell(WeakCell* weak_cell) {
weak_objects_.weak_cells.Push(kMainThread, weak_cell);
}
void AddTransitionArray(TransitionArray* array) {
weak_objects_.transition_arrays.Push(kMainThread, array);
}
@ -810,11 +805,10 @@ class MarkCompactCollector final : public MarkCompactCollectorBase {
// The linked list of all encountered weak maps is destroyed.
void ClearWeakCollections();
// Goes through the list of encountered weak cells and clears those with
// Goes through the list of encountered weak references and clears those with
// dead values. If the value is a dead map and the parent map transitions to
// the dead map via weak cell, then this function also clears the map
// transition.
void ClearWeakCells();
void ClearWeakReferences();
void AbortWeakObjects();
@ -926,7 +920,6 @@ class MarkingVisitor final
V8_INLINE int VisitMap(Map* map, Map* object);
V8_INLINE int VisitNativeContext(Map* map, Context* object);
V8_INLINE int VisitTransitionArray(Map* map, TransitionArray* object);
V8_INLINE int VisitWeakCell(Map* map, WeakCell* object);
// ObjectVisitor implementation.
V8_INLINE void VisitPointer(HeapObject* host, Object** p) final;

3
src/heap/objects-visiting.h
View File

@ -64,8 +64,7 @@ class UncompiledDataWithPreParsedScope;
V(TransitionArray) \
V(UncompiledDataWithoutPreParsedScope) \
V(UncompiledDataWithPreParsedScope) \
V(WasmInstanceObject) \
V(WeakCell)
V(WasmInstanceObject)
// The base class for visitors that need to dispatch on object type. The default
// behavior of all visit functions is to iterate body of the given object using

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

@ -225,7 +225,6 @@ bool Heap::CreateInitialMaps() {
ALLOCATE_PARTIAL_MAP(ODDBALL_TYPE, Oddball::kSize, undefined);
ALLOCATE_PARTIAL_MAP(ODDBALL_TYPE, Oddball::kSize, null);
ALLOCATE_PARTIAL_MAP(ODDBALL_TYPE, Oddball::kSize, the_hole);
ALLOCATE_PARTIAL_MAP(WEAK_CELL_TYPE, WeakCell::kSize, weak_cell);
#undef ALLOCATE_PARTIAL_MAP
}
@ -318,7 +317,6 @@ bool Heap::CreateInitialMaps() {
// Fix the instance_descriptors for the existing maps.
FinalizePartialMap(roots.meta_map());
FinalizePartialMap(roots.weak_cell_map());
FinalizePartialMap(roots.fixed_array_map());
FinalizePartialMap(roots.weak_fixed_array_map());
FinalizePartialMap(roots.weak_array_list_map());
@ -753,13 +751,6 @@ void Heap::CreateInitialObjects() {
set_empty_sloppy_arguments_elements(*empty_sloppy_arguments_elements);
}
{
Handle<WeakCell> cell =
factory->NewWeakCell(factory->undefined_value(), TENURED_READ_ONLY);
set_empty_weak_cell(*cell);
cell->clear();
}
set_detached_contexts(roots.empty_weak_array_list());
set_retained_maps(roots.empty_weak_array_list());
set_retaining_path_targets(roots.empty_weak_array_list());

2
src/objects-body-descriptors-inl.h
View File

@ -762,8 +762,6 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
return Op::template apply<Cell::BodyDescriptor>(p1, p2, p3, p4);
case PROPERTY_CELL_TYPE:
return Op::template apply<PropertyCell::BodyDescriptor>(p1, p2, p3, p4);
case WEAK_CELL_TYPE:
return Op::template apply<WeakCell::BodyDescriptor>(p1, p2, p3, p4);
case SYMBOL_TYPE:
return Op::template apply<Symbol::BodyDescriptor>(p1, p2, p3, p4);
case BYTECODE_ARRAY_TYPE:

23
src/objects-debug.cc
View File

@ -265,9 +265,6 @@ void HeapObject::HeapObjectVerify(Isolate* isolate) {
case PROPERTY_CELL_TYPE:
PropertyCell::cast(this)->PropertyCellVerify(isolate);
break;
case WEAK_CELL_TYPE:
WeakCell::cast(this)->WeakCellVerify(isolate);
break;
case JS_ARRAY_TYPE:
JSArray::cast(this)->JSArrayVerify(isolate);
break;
@ -1098,11 +1095,6 @@ void PropertyCell::PropertyCellVerify(Isolate* isolate) {
VerifyObjectField(isolate, kValueOffset);
}
void WeakCell::WeakCellVerify(Isolate* isolate) {
CHECK(IsWeakCell());
VerifyObjectField(isolate, kValueOffset);
}
void CodeDataContainer::CodeDataContainerVerify(Isolate* isolate) {
CHECK(IsCodeDataContainer());
VerifyObjectField(isolate, kNextCodeLinkOffset);
@ -2115,17 +2107,13 @@ bool TransitionsAccessor::IsConsistentWithBackPointers() {
// Estimates if there is a path from the object to a context.
// This function is not precise, and can return false even if
// there is a path to a context.
bool CanLeak(Object* obj, Heap* heap, bool skip_weak_cell) {
bool CanLeak(Object* obj, Heap* heap) {
if (!obj->IsHeapObject()) return false;
if (obj->IsWeakCell()) {
if (skip_weak_cell) return false;
return CanLeak(WeakCell::cast(obj)->value(), heap, skip_weak_cell);
}
if (obj->IsCell()) {
return CanLeak(Cell::cast(obj)->value(), heap, skip_weak_cell);
return CanLeak(Cell::cast(obj)->value(), heap);
}
if (obj->IsPropertyCell()) {
return CanLeak(PropertyCell::cast(obj)->value(), heap, skip_weak_cell);
return CanLeak(PropertyCell::cast(obj)->value(), heap);
}
if (obj->IsContext()) return true;
if (obj->IsMap()) {
@ -2136,17 +2124,16 @@ bool CanLeak(Object* obj, Heap* heap, bool skip_weak_cell) {
}
return true;
}
return CanLeak(HeapObject::cast(obj)->map(), heap, skip_weak_cell);
return CanLeak(HeapObject::cast(obj)->map(), heap);
}
void Code::VerifyEmbeddedObjects(Isolate* isolate, VerifyMode mode) {
if (kind() == OPTIMIZED_FUNCTION) return;
Heap* heap = isolate->heap();
int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
bool skip_weak_cell = (mode == kNoContextSpecificPointers) ? false : true;
for (RelocIterator it(this, mask); !it.done(); it.next()) {
Object* target = it.rinfo()->target_object();
DCHECK(!CanLeak(target, heap, skip_weak_cell));
DCHECK(!CanLeak(target, heap));
}
}

1
src/objects-definitions.h
View File

@ -166,7 +166,6 @@ namespace internal {
V(STORE_HANDLER_TYPE) \
V(UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE) \
V(UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE) \
V(WEAK_CELL_TYPE) \
V(WEAK_ARRAY_LIST_TYPE) \
\
V(JS_PROXY_TYPE) \

29
src/objects-inl.h
View File

@ -527,7 +527,6 @@ CAST_ACCESSOR(Struct)
CAST_ACCESSOR(TemplateObjectDescription)
CAST_ACCESSOR(Tuple2)
CAST_ACCESSOR(Tuple3)
CAST_ACCESSOR(WeakCell)
bool Object::HasValidElements() {
// Dictionary is covered under FixedArray.
@ -1317,34 +1316,6 @@ void PropertyCell::set_property_details(PropertyDetails details) {
set_property_details_raw(details.AsSmi());
}
Object* WeakCell::value() const { return READ_FIELD(this, kValueOffset); }
void WeakCell::clear() {
// Either the garbage collector is clearing the cell or we are simply
// initializing the root empty weak cell.
DCHECK(Heap::FromWritableHeapObject(this)->gc_state() == Heap::MARK_COMPACT ||
this == GetReadOnlyRoots().empty_weak_cell());
WRITE_FIELD(this, kValueOffset, Smi::kZero);
}
void WeakCell::initialize(HeapObject* val) {
WRITE_FIELD(this, kValueOffset, val);
// We just have to execute the generational barrier here because we never
// mark through a weak cell and collect evacuation candidates when we process
// all weak cells.
Heap* heap = Heap::FromWritableHeapObject(this);
WriteBarrierMode mode =
heap->incremental_marking()->marking_state()->IsBlack(this)
? UPDATE_WRITE_BARRIER
: UPDATE_WEAK_WRITE_BARRIER;
CONDITIONAL_WRITE_BARRIER(this, kValueOffset, val, mode);
}
bool WeakCell::cleared() const { return value() == Smi::kZero; }
int JSObject::GetHeaderSize() const { return GetHeaderSize(map()); }
int JSObject::GetHeaderSize(const Map* map) {

15
src/objects-printer.cc
View File

@ -292,9 +292,6 @@ void HeapObject::HeapObjectPrint(std::ostream& os) { // NOLINT
case PROPERTY_CELL_TYPE:
PropertyCell::cast(this)->PropertyCellPrint(os);
break;
case WEAK_CELL_TYPE:
WeakCell::cast(this)->WeakCellPrint(os);
break;
case JS_ARRAY_BUFFER_TYPE:
JSArrayBuffer::cast(this)->JSArrayBufferPrint(os);
break;
@ -1523,18 +1520,6 @@ void PropertyCell::PropertyCellPrint(std::ostream& os) { // NOLINT
os << "\n";
}
void WeakCell::WeakCellPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "WeakCell");
if (cleared()) {
os << "\n - cleared";
} else {
os << "\n - value: " << Brief(value());
}
os << "\n";
}
void Code::CodePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Code");
os << "\n";

13
src/objects.cc
View File

@ -3101,9 +3101,6 @@ VisitorId Map::GetVisitorId(Map* map) {
case PROPERTY_CELL_TYPE:
return kVisitPropertyCell;
case WEAK_CELL_TYPE:
return kVisitWeakCell;
case TRANSITION_ARRAY_TYPE:
return kVisitTransitionArray;
@ -3613,15 +3610,6 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) { // NOLINT
os << '>';
break;
}
case WEAK_CELL_TYPE: {
os << "<WeakCell value= ";
HeapStringAllocator allocator;
StringStream accumulator(&allocator);
WeakCell::cast(this)->value()->ShortPrint(&accumulator);
os << accumulator.ToCString().get();
os << '>';
break;
}
case CALL_HANDLER_INFO_TYPE: {
CallHandlerInfo* info = CallHandlerInfo::cast(this);
os << "<CallHandlerInfo ";
@ -13152,7 +13140,6 @@ bool CanSubclassHaveInobjectProperties(InstanceType instance_type) {
case PROPERTY_CELL_TYPE:
case SHARED_FUNCTION_INFO_TYPE:
case SYMBOL_TYPE:
case WEAK_CELL_TYPE:
case ALLOCATION_SITE_TYPE:
#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \

36
src/objects.h
View File

@ -172,7 +172,6 @@
// - PromiseResolveThenableJobTask
// - Module
// - ModuleInfoEntry
// - WeakCell
// - FeedbackCell
// - FeedbackVector
// - PreParsedScopeData
@ -534,7 +533,6 @@ enum InstanceType : uint16_t {
STORE_HANDLER_TYPE,
UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE,
UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE,
WEAK_CELL_TYPE,
WEAK_ARRAY_LIST_TYPE,
// All the following types are subtypes of JSReceiver, which corresponds to
@ -729,7 +727,6 @@ class FeedbackCell;
class FeedbackMetadata;
class FeedbackVector;
class UncompiledData;
class WeakCell;
class TemplateInfo;
class TransitionArray;
class TemplateList;
@ -908,7 +905,6 @@ class ZoneForwardList;
V(WasmMemoryObject) \
V(WasmModuleObject) \
V(WasmTableObject) \
V(WeakCell) \
V(WeakFixedArray) \
V(WeakArrayList)
@ -1030,9 +1026,7 @@ class ZoneForwardList;
V(WasmMemoryObject, WASM_MEMORY_TYPE) \
V(WasmModuleObject, WASM_MODULE_TYPE) \
V(WasmTableObject, WASM_TABLE_TYPE) \
V(WeakArrayList, WEAK_ARRAY_LIST_TYPE) \
V(WeakCell, WEAK_CELL_TYPE)
V(WeakArrayList, WEAK_ARRAY_LIST_TYPE)
#ifdef V8_INTL_SUPPORT
#define INSTANCE_TYPE_CHECKERS_SINGLE(V) \
@ -4036,34 +4030,6 @@ class PropertyCell : public HeapObject {
DISALLOW_IMPLICIT_CONSTRUCTORS(PropertyCell);
};
class WeakCell : public HeapObject {
public:
inline Object* value() const;
// This should not be called by anyone except GC.
inline void clear();
// This should not be called by anyone except allocator.
inline void initialize(HeapObject* value);
inline bool cleared() const;
DECL_CAST(WeakCell)
DECL_PRINTER(WeakCell)
DECL_VERIFIER(WeakCell)
// Layout description.
static const int kValueOffset = HeapObject::kHeaderSize;
static const int kSize = kValueOffset + kPointerSize;
typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
};
// The [Async-from-Sync Iterator] object
// (proposal-async-iteration/#sec-async-from-sync-iterator-objects)
// An object which wraps an ordinary Iterator and converts it to behave

1
src/objects/map.h
View File

@ -62,7 +62,6 @@ namespace internal {
V(UncompiledDataWithoutPreParsedScope) \
V(UncompiledDataWithPreParsedScope) \
V(WasmInstanceObject) \
V(WeakCell) \
V(WeakArray)
// For data objects, JS objects and structs along with generic visitor which

10
src/profiler/heap-snapshot-generator.cc
View File

@ -880,8 +880,6 @@ void V8HeapExplorer::ExtractReferences(int entry, HeapObject* obj) {
ExtractCellReferences(entry, Cell::cast(obj));
} else if (obj->IsFeedbackCell()) {
ExtractFeedbackCellReferences(entry, FeedbackCell::cast(obj));
} else if (obj->IsWeakCell()) {
ExtractWeakCellReferences(entry, WeakCell::cast(obj));
} else if (obj->IsPropertyCell()) {
ExtractPropertyCellReferences(entry, PropertyCell::cast(obj));
} else if (obj->IsAllocationSite()) {
@ -1123,8 +1121,6 @@ void V8HeapExplorer::ExtractMapReferences(int entry, Map* map) {
Map::kTransitionsOrPrototypeInfoOffset);
} else if (maybe_raw_transitions_or_prototype_info->ToStrongHeapObject(
&raw_transitions_or_prototype_info)) {
DCHECK(!raw_transitions_or_prototype_info->IsWeakCell());
if (raw_transitions_or_prototype_info->IsTransitionArray()) {
TransitionArray* transitions =
TransitionArray::cast(raw_transitions_or_prototype_info);
@ -1291,12 +1287,6 @@ void V8HeapExplorer::ExtractFeedbackCellReferences(
FeedbackCell::kValueOffset);
}
void V8HeapExplorer::ExtractWeakCellReferences(int entry, WeakCell* weak_cell) {
TagObject(weak_cell, "(weak cell)");
SetWeakReference(weak_cell, entry, "value", weak_cell->value(),
WeakCell::kValueOffset);
}
void V8HeapExplorer::ExtractPropertyCellReferences(int entry,
PropertyCell* cell) {
SetInternalReference(cell, entry, "value", cell->value(),

1
src/profiler/heap-snapshot-generator.h
View File

@ -383,7 +383,6 @@ class V8HeapExplorer : public HeapEntriesAllocator {
void ExtractCodeReferences(int entry, Code* code);
void ExtractCellReferences(int entry, Cell* cell);
void ExtractFeedbackCellReferences(int entry, FeedbackCell* feedback_cell);
void ExtractWeakCellReferences(int entry, WeakCell* weak_cell);
void ExtractPropertyCellReferences(int entry, PropertyCell* cell);
void ExtractAllocationSiteReferences(int entry, AllocationSite* site);
void ExtractArrayBoilerplateDescriptionReferences(

2
src/roots.h
View File

@ -41,7 +41,6 @@ namespace internal {
V(Map, code_map, CodeMap) \
V(Map, function_context_map, FunctionContextMap) \
V(Map, cell_map, CellMap) \
V(Map, weak_cell_map, WeakCellMap) \
V(Map, global_property_cell_map, GlobalPropertyCellMap) \
V(Map, foreign_map, ForeignMap) \
V(Map, heap_number_map, HeapNumberMap) \
@ -187,7 +186,6 @@ namespace internal {
V(FixedArray, empty_ordered_hash_set, EmptyOrderedHashSet) \
V(FeedbackMetadata, empty_feedback_metadata, EmptyFeedbackMetadata) \
V(PropertyCell, empty_property_cell, EmptyPropertyCell) \
V(WeakCell, empty_weak_cell, EmptyWeakCell) \
V(InterceptorInfo, noop_interceptor_info, NoOpInterceptorInfo) \
V(WeakFixedArray, empty_weak_fixed_array, EmptyWeakFixedArray) \
V(WeakArrayList, empty_weak_array_list, EmptyWeakArrayList) \

2
src/snapshot/serializer.cc
View File

@ -261,7 +261,7 @@ void Serializer<AllocatorT>::PutRoot(
// Assert that the first 32 root array items are a conscious choice. They are
// chosen so that the most common ones can be encoded more efficiently.
STATIC_ASSERT(Heap::kEmptyDescriptorArrayRootIndex ==
STATIC_ASSERT(Heap::kArgumentsMarkerRootIndex ==
kNumberOfRootArrayConstants - 1);
if (how_to_code == kPlain && where_to_point == kStartOfObject &&

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

@ -4377,82 +4377,6 @@ TEST(PolymorphicStaysPolymorphicAfterGC) {
CheckIC(loadIC, 0, POLYMORPHIC);
}
TEST(WeakCell) {
ManualGCScope manual_gc_scope;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
v8::internal::Factory* factory = isolate->factory();
HandleScope outer_scope(isolate);
Handle<WeakCell> weak_cell1;
{
HandleScope inner_scope(isolate);
Handle<HeapObject> value = factory->NewFixedArray(1, NOT_TENURED);
weak_cell1 = inner_scope.CloseAndEscape(factory->NewWeakCell(value));
}
Handle<FixedArray> survivor = factory->NewFixedArray(1, NOT_TENURED);
Handle<WeakCell> weak_cell2;
{
HandleScope inner_scope(isolate);
weak_cell2 = inner_scope.CloseAndEscape(factory->NewWeakCell(survivor));
}
CHECK(weak_cell1->value()->IsFixedArray());
CHECK_EQ(*survivor, weak_cell2->value());
CcTest::CollectGarbage(NEW_SPACE);
CHECK(weak_cell1->value()->IsFixedArray());
CHECK_EQ(*survivor, weak_cell2->value());
CcTest::CollectGarbage(NEW_SPACE);
CHECK(weak_cell1->value()->IsFixedArray());
CHECK_EQ(*survivor, weak_cell2->value());
CcTest::CollectAllAvailableGarbage();
CHECK(weak_cell1->cleared());
CHECK_EQ(*survivor, weak_cell2->value());
}
TEST(WeakCellsWithIncrementalMarking) {
if (!FLAG_incremental_marking) return;
ManualGCScope manual_gc_scope;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
v8::internal::Heap* heap = CcTest::heap();
v8::internal::Factory* factory = isolate->factory();
const int N = 16;
HandleScope outer_scope(isolate);
Handle<FixedArray> survivor = factory->NewFixedArray(1, NOT_TENURED);
Handle<WeakCell> weak_cells[N];
for (int i = 0; i < N; i++) {
HandleScope inner_scope(isolate);
Handle<HeapObject> value =
i == 0 ? survivor : factory->NewFixedArray(1, NOT_TENURED);
Handle<WeakCell> weak_cell = factory->NewWeakCell(value);
CHECK(weak_cell->value()->IsFixedArray());
IncrementalMarking* marking = heap->incremental_marking();
if (marking->IsStopped()) {
heap->StartIncrementalMarking(i::Heap::kNoGCFlags,
i::GarbageCollectionReason::kTesting);
}
marking->Step(128, IncrementalMarking::NO_GC_VIA_STACK_GUARD,
StepOrigin::kV8);
CcTest::CollectGarbage(NEW_SPACE);
CHECK(weak_cell->value()->IsFixedArray());
weak_cells[i] = inner_scope.CloseAndEscape(weak_cell);
}
// Call collect all twice to make sure that we also cleared
// weak cells that were allocated on black pages.
CcTest::CollectAllGarbage();
CcTest::CollectAllGarbage();
CHECK_EQ(*survivor, weak_cells[0]->value());
for (int i = 1; i < N; i++) {
CHECK(weak_cells[i]->cleared());
}
}
#ifdef DEBUG
TEST(AddInstructionChangesNewSpacePromotion) {
FLAG_allow_natives_syntax = true;
@ -4741,15 +4665,15 @@ TEST(Regress3877) {
Factory* factory = isolate->factory();
HandleScope scope(isolate);
CompileRun("function cls() { this.x = 10; }");
Handle<WeakCell> weak_prototype;
Handle<WeakFixedArray> weak_prototype_holder = factory->NewWeakFixedArray(1);
{
HandleScope inner_scope(isolate);
v8::Local<v8::Value> result = CompileRun("cls.prototype");
Handle<JSReceiver> proto =
v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(result));
weak_prototype = inner_scope.CloseAndEscape(factory->NewWeakCell(proto));
weak_prototype_holder->Set(0, HeapObjectReference::Weak(*proto));
}
CHECK(!weak_prototype->cleared());
CHECK(!weak_prototype_holder->Get(0)->IsClearedWeakHeapObject());
CompileRun(
"var a = { };"
"a.x = new cls();"
@ -4758,13 +4682,13 @@ TEST(Regress3877) {
CcTest::CollectAllGarbage();
}
// The map of a.x keeps prototype alive
CHECK(!weak_prototype->cleared());
CHECK(!weak_prototype_holder->Get(0)->IsClearedWeakHeapObject());
// Change the map of a.x and make the previous map garbage collectable.
CompileRun("a.x.__proto__ = {};");
for (int i = 0; i < 4; i++) {
CcTest::CollectAllGarbage();
}
CHECK(weak_prototype->cleared());
CHECK(weak_prototype_holder->Get(0)->IsClearedWeakHeapObject());
}
Handle<WeakFixedArray> AddRetainedMap(Isolate* isolate, Heap* heap) {

1
test/cctest/test-serialize.cc
View File

@ -373,7 +373,6 @@ UNINITIALIZED_TEST(StartupSerializerRootMapDependencies) {
// - NullValue
// - Internalized one byte string
// - Map for Internalized one byte string
// - WeakCell
// - TheHoleValue
// - HeapNumber
// HeapNumber objects require kDoubleUnaligned on 32-bit

2
test/mjsunit/regress/regress-4325.js
View File

@ -23,7 +23,7 @@ i1.p1 = 0.5;
// Let Inner.map1 die by migrating i2 to Inner.map2:
print(i2.p1);
gc();
// o1.map's descriptor for "inner" is now a cleared WeakCell;
// o1.map's descriptor for "inner" is now a cleared weak reference;
// o1.inner's actual map is Inner.map2.
// Prepare Inner.map3, deprecating Inner.map2.
i2.p2 = 0.5;

1
tools/eval_gc_time.sh
View File

@ -94,7 +94,6 @@ INTERESTING_OLD_GEN_KEYS="\
clear.slots_buffer \
clear.store_buffer \
clear.string_table \
clear.weak_cells \
clear.weak_collections \
clear.weak_lists \
evacuate.candidates \

3
tools/grokdump.py
View File

@ -1231,9 +1231,6 @@ class Map(HeapObject):
def DependentCodeOffset(self):
return self.CodeCacheOffset() + self.heap.PointerSize()
def WeakCellCacheOffset(self):
return self.DependentCodeOffset() + self.heap.PointerSize()
def ReadByte(self, offset):
return self.heap.reader.ReadU8(self.address + offset)

1
tools/heap-stats/categories.js
View File

@ -134,7 +134,6 @@ const CATEGORIES = new Map([
'STRING_SPLIT_CACHE_TYPE',
'STRING_TABLE_TYPE',
'TRANSITION_ARRAY_TYPE',
'WEAK_CELL_TYPE',
'WEAK_NEW_SPACE_OBJECT_TO_CODE_TYPE',
])
],

281
tools/v8heapconst.py
View File

@ -123,8 +123,7 @@ INSTANCE_TYPES = {
219: "STORE_HANDLER_TYPE",
220: "UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE",
221: "UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE",
222: "WEAK_CELL_TYPE",
223: "WEAK_ARRAY_LIST_TYPE",
222: "WEAK_ARRAY_LIST_TYPE",
1024: "JS_PROXY_TYPE",
1025: "JS_GLOBAL_OBJECT_TYPE",
1026: "JS_GLOBAL_PROXY_TYPE",
@ -199,119 +198,118 @@ KNOWN_MAPS = {
("RO_SPACE", 0x02ae9): (133, "CodeMap"),
("RO_SPACE", 0x02b39): (199, "FunctionContextMap"),
("RO_SPACE", 0x02b89): (208, "CellMap"),
("RO_SPACE", 0x02bd9): (222, "WeakCellMap"),
("RO_SPACE", 0x02c29): (215, "GlobalPropertyCellMap"),
("RO_SPACE", 0x02c79): (135, "ForeignMap"),
("RO_SPACE", 0x02cc9): (206, "TransitionArrayMap"),
("RO_SPACE", 0x02d19): (211, "FeedbackVectorMap"),
("RO_SPACE", 0x02db9): (131, "ArgumentsMarkerMap"),
("RO_SPACE", 0x02e61): (131, "ExceptionMap"),
("RO_SPACE", 0x02f09): (131, "TerminationExceptionMap"),
("RO_SPACE", 0x02fb9): (131, "OptimizedOutMap"),
("RO_SPACE", 0x03061): (131, "StaleRegisterMap"),
("RO_SPACE", 0x030d9): (201, "NativeContextMap"),
("RO_SPACE", 0x03129): (200, "ModuleContextMap"),
("RO_SPACE", 0x03179): (198, "EvalContextMap"),
("RO_SPACE", 0x031c9): (202, "ScriptContextMap"),
("RO_SPACE", 0x03219): (195, "BlockContextMap"),
("RO_SPACE", 0x03269): (196, "CatchContextMap"),
("RO_SPACE", 0x032b9): (203, "WithContextMap"),
("RO_SPACE", 0x03309): (197, "DebugEvaluateContextMap"),
("RO_SPACE", 0x03359): (194, "ScriptContextTableMap"),
("RO_SPACE", 0x033a9): (151, "FeedbackMetadataArrayMap"),
("RO_SPACE", 0x033f9): (182, "ArrayListMap"),
("RO_SPACE", 0x03449): (130, "BigIntMap"),
("RO_SPACE", 0x03499): (183, "ObjectBoilerplateDescriptionMap"),
("RO_SPACE", 0x034e9): (137, "BytecodeArrayMap"),
("RO_SPACE", 0x03539): (209, "CodeDataContainerMap"),
("RO_SPACE", 0x03589): (150, "FixedDoubleArrayMap"),
("RO_SPACE", 0x035d9): (188, "GlobalDictionaryMap"),
("RO_SPACE", 0x03629): (210, "ManyClosuresCellMap"),
("RO_SPACE", 0x03679): (182, "ModuleInfoMap"),
("RO_SPACE", 0x036c9): (134, "MutableHeapNumberMap"),
("RO_SPACE", 0x03719): (187, "NameDictionaryMap"),
("RO_SPACE", 0x03769): (210, "NoClosuresCellMap"),
("RO_SPACE", 0x037b9): (189, "NumberDictionaryMap"),
("RO_SPACE", 0x03809): (210, "OneClosureCellMap"),
("RO_SPACE", 0x03859): (185, "OrderedHashMapMap"),
("RO_SPACE", 0x038a9): (186, "OrderedHashSetMap"),
("RO_SPACE", 0x038f9): (213, "PreParsedScopeDataMap"),
("RO_SPACE", 0x03949): (214, "PropertyArrayMap"),
("RO_SPACE", 0x03999): (207, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x039e9): (207, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x03a39): (207, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x03a89): (190, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x03ad9): (182, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x03b29): (217, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x03b79): (218, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x03bc9): (191, "StringTableMap"),
("RO_SPACE", 0x03c19): (220, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x03c69): (221, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x03cb9): (223, "WeakArrayListMap"),
("RO_SPACE", 0x03d09): (192, "EphemeronHashTableMap"),
("RO_SPACE", 0x03d59): (106, "NativeSourceStringMap"),
("RO_SPACE", 0x03da9): (64, "StringMap"),
("RO_SPACE", 0x03df9): (73, "ConsOneByteStringMap"),
("RO_SPACE", 0x03e49): (65, "ConsStringMap"),
("RO_SPACE", 0x03e99): (77, "ThinOneByteStringMap"),
("RO_SPACE", 0x03ee9): (69, "ThinStringMap"),
("RO_SPACE", 0x03f39): (67, "SlicedStringMap"),
("RO_SPACE", 0x03f89): (75, "SlicedOneByteStringMap"),
("RO_SPACE", 0x03fd9): (66, "ExternalStringMap"),
("RO_SPACE", 0x04029): (82, "ExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x04079): (74, "ExternalOneByteStringMap"),
("RO_SPACE", 0x040c9): (98, "ShortExternalStringMap"),
("RO_SPACE", 0x04119): (114, "ShortExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x04169): (0, "InternalizedStringMap"),
("RO_SPACE", 0x041b9): (2, "ExternalInternalizedStringMap"),
("RO_SPACE", 0x04209): (18, "ExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x04259): (10, "ExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x042a9): (34, "ShortExternalInternalizedStringMap"),
("RO_SPACE", 0x042f9): (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x04349): (42, "ShortExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x04399): (106, "ShortExternalOneByteStringMap"),
("RO_SPACE", 0x043e9): (140, "FixedUint8ArrayMap"),
("RO_SPACE", 0x04439): (139, "FixedInt8ArrayMap"),
("RO_SPACE", 0x04489): (142, "FixedUint16ArrayMap"),
("RO_SPACE", 0x044d9): (141, "FixedInt16ArrayMap"),
("RO_SPACE", 0x04529): (144, "FixedUint32ArrayMap"),
("RO_SPACE", 0x04579): (143, "FixedInt32ArrayMap"),
("RO_SPACE", 0x045c9): (145, "FixedFloat32ArrayMap"),
("RO_SPACE", 0x04619): (146, "FixedFloat64ArrayMap"),
("RO_SPACE", 0x04669): (147, "FixedUint8ClampedArrayMap"),
("RO_SPACE", 0x046b9): (149, "FixedBigUint64ArrayMap"),
("RO_SPACE", 0x04709): (148, "FixedBigInt64ArrayMap"),
("RO_SPACE", 0x04759): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x047c1): (171, "Tuple2Map"),
("RO_SPACE", 0x04af9): (161, "InterceptorInfoMap"),
("RO_SPACE", 0x04bf1): (169, "ScriptMap"),
("RO_SPACE", 0x09a71): (154, "AccessorInfoMap"),
("RO_SPACE", 0x09ac1): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x09b11): (155, "AccessorPairMap"),
("RO_SPACE", 0x09b61): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x09bb1): (157, "AllocationMementoMap"),
("RO_SPACE", 0x09c01): (158, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x09c51): (159, "DebugInfoMap"),
("RO_SPACE", 0x09ca1): (160, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x09cf1): (162, "InterpreterDataMap"),
("RO_SPACE", 0x09d41): (163, "ModuleInfoEntryMap"),
("RO_SPACE", 0x09d91): (164, "ModuleMap"),
("RO_SPACE", 0x09de1): (165, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x09e31): (166, "PromiseCapabilityMap"),
("RO_SPACE", 0x09e81): (167, "PromiseReactionMap"),
("RO_SPACE", 0x09ed1): (168, "PrototypeInfoMap"),
("RO_SPACE", 0x09f21): (170, "StackFrameInfoMap"),
("RO_SPACE", 0x09f71): (172, "Tuple3Map"),
("RO_SPACE", 0x09fc1): (173, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x0a011): (174, "WasmDebugInfoMap"),
("RO_SPACE", 0x0a061): (175, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x0a0b1): (176, "CallableTaskMap"),
("RO_SPACE", 0x0a101): (177, "CallbackTaskMap"),
("RO_SPACE", 0x0a151): (178, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x0a1a1): (179, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x0a1f1): (180, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x0a241): (181, "AllocationSiteMap"),
("RO_SPACE", 0x0a291): (181, "AllocationSiteMap"),
("RO_SPACE", 0x02bd9): (215, "GlobalPropertyCellMap"),
("RO_SPACE", 0x02c29): (135, "ForeignMap"),
("RO_SPACE", 0x02c79): (206, "TransitionArrayMap"),
("RO_SPACE", 0x02cc9): (211, "FeedbackVectorMap"),
("RO_SPACE", 0x02d69): (131, "ArgumentsMarkerMap"),
("RO_SPACE", 0x02e11): (131, "ExceptionMap"),
("RO_SPACE", 0x02eb9): (131, "TerminationExceptionMap"),
("RO_SPACE", 0x02f69): (131, "OptimizedOutMap"),
("RO_SPACE", 0x03011): (131, "StaleRegisterMap"),
("RO_SPACE", 0x03089): (201, "NativeContextMap"),
("RO_SPACE", 0x030d9): (200, "ModuleContextMap"),
("RO_SPACE", 0x03129): (198, "EvalContextMap"),
("RO_SPACE", 0x03179): (202, "ScriptContextMap"),
("RO_SPACE", 0x031c9): (195, "BlockContextMap"),
("RO_SPACE", 0x03219): (196, "CatchContextMap"),
("RO_SPACE", 0x03269): (203, "WithContextMap"),
("RO_SPACE", 0x032b9): (197, "DebugEvaluateContextMap"),
("RO_SPACE", 0x03309): (194, "ScriptContextTableMap"),
("RO_SPACE", 0x03359): (151, "FeedbackMetadataArrayMap"),
("RO_SPACE", 0x033a9): (182, "ArrayListMap"),
("RO_SPACE", 0x033f9): (130, "BigIntMap"),
("RO_SPACE", 0x03449): (183, "ObjectBoilerplateDescriptionMap"),
("RO_SPACE", 0x03499): (137, "BytecodeArrayMap"),
("RO_SPACE", 0x034e9): (209, "CodeDataContainerMap"),
("RO_SPACE", 0x03539): (150, "FixedDoubleArrayMap"),
("RO_SPACE", 0x03589): (188, "GlobalDictionaryMap"),
("RO_SPACE", 0x035d9): (210, "ManyClosuresCellMap"),
("RO_SPACE", 0x03629): (182, "ModuleInfoMap"),
("RO_SPACE", 0x03679): (134, "MutableHeapNumberMap"),
("RO_SPACE", 0x036c9): (187, "NameDictionaryMap"),
("RO_SPACE", 0x03719): (210, "NoClosuresCellMap"),
("RO_SPACE", 0x03769): (189, "NumberDictionaryMap"),
("RO_SPACE", 0x037b9): (210, "OneClosureCellMap"),
("RO_SPACE", 0x03809): (185, "OrderedHashMapMap"),
("RO_SPACE", 0x03859): (186, "OrderedHashSetMap"),
("RO_SPACE", 0x038a9): (213, "PreParsedScopeDataMap"),
("RO_SPACE", 0x038f9): (214, "PropertyArrayMap"),
("RO_SPACE", 0x03949): (207, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x03999): (207, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x039e9): (207, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x03a39): (190, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x03a89): (182, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x03ad9): (217, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x03b29): (218, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x03b79): (191, "StringTableMap"),
("RO_SPACE", 0x03bc9): (220, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x03c19): (221, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x03c69): (222, "WeakArrayListMap"),
("RO_SPACE", 0x03cb9): (192, "EphemeronHashTableMap"),
("RO_SPACE", 0x03d09): (106, "NativeSourceStringMap"),
("RO_SPACE", 0x03d59): (64, "StringMap"),
("RO_SPACE", 0x03da9): (73, "ConsOneByteStringMap"),
("RO_SPACE", 0x03df9): (65, "ConsStringMap"),
("RO_SPACE", 0x03e49): (77, "ThinOneByteStringMap"),
("RO_SPACE", 0x03e99): (69, "ThinStringMap"),
("RO_SPACE", 0x03ee9): (67, "SlicedStringMap"),
("RO_SPACE", 0x03f39): (75, "SlicedOneByteStringMap"),
("RO_SPACE", 0x03f89): (66, "ExternalStringMap"),
("RO_SPACE", 0x03fd9): (82, "ExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x04029): (74, "ExternalOneByteStringMap"),
("RO_SPACE", 0x04079): (98, "ShortExternalStringMap"),
("RO_SPACE", 0x040c9): (114, "ShortExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x04119): (0, "InternalizedStringMap"),
("RO_SPACE", 0x04169): (2, "ExternalInternalizedStringMap"),
("RO_SPACE", 0x041b9): (18, "ExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x04209): (10, "ExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x04259): (34, "ShortExternalInternalizedStringMap"),
("RO_SPACE", 0x042a9): (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x042f9): (42, "ShortExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x04349): (106, "ShortExternalOneByteStringMap"),
("RO_SPACE", 0x04399): (140, "FixedUint8ArrayMap"),
("RO_SPACE", 0x043e9): (139, "FixedInt8ArrayMap"),
("RO_SPACE", 0x04439): (142, "FixedUint16ArrayMap"),
("RO_SPACE", 0x04489): (141, "FixedInt16ArrayMap"),
("RO_SPACE", 0x044d9): (144, "FixedUint32ArrayMap"),
("RO_SPACE", 0x04529): (143, "FixedInt32ArrayMap"),
("RO_SPACE", 0x04579): (145, "FixedFloat32ArrayMap"),
("RO_SPACE", 0x045c9): (146, "FixedFloat64ArrayMap"),
("RO_SPACE", 0x04619): (147, "FixedUint8ClampedArrayMap"),
("RO_SPACE", 0x04669): (149, "FixedBigUint64ArrayMap"),
("RO_SPACE", 0x046b9): (148, "FixedBigInt64ArrayMap"),
("RO_SPACE", 0x04709): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x04771): (171, "Tuple2Map"),
("RO_SPACE", 0x04a99): (161, "InterceptorInfoMap"),
("RO_SPACE", 0x04b91): (169, "ScriptMap"),
("RO_SPACE", 0x09a11): (154, "AccessorInfoMap"),
("RO_SPACE", 0x09a61): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x09ab1): (155, "AccessorPairMap"),
("RO_SPACE", 0x09b01): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x09b51): (157, "AllocationMementoMap"),
("RO_SPACE", 0x09ba1): (158, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x09bf1): (159, "DebugInfoMap"),
("RO_SPACE", 0x09c41): (160, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x09c91): (162, "InterpreterDataMap"),
("RO_SPACE", 0x09ce1): (163, "ModuleInfoEntryMap"),
("RO_SPACE", 0x09d31): (164, "ModuleMap"),
("RO_SPACE", 0x09d81): (165, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x09dd1): (166, "PromiseCapabilityMap"),
("RO_SPACE", 0x09e21): (167, "PromiseReactionMap"),
("RO_SPACE", 0x09e71): (168, "PrototypeInfoMap"),
("RO_SPACE", 0x09ec1): (170, "StackFrameInfoMap"),
("RO_SPACE", 0x09f11): (172, "Tuple3Map"),
("RO_SPACE", 0x09f61): (173, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x09fb1): (174, "WasmDebugInfoMap"),
("RO_SPACE", 0x0a001): (175, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x0a051): (176, "CallableTaskMap"),
("RO_SPACE", 0x0a0a1): (177, "CallbackTaskMap"),
("RO_SPACE", 0x0a0f1): (178, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x0a141): (179, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x0a191): (180, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x0a1e1): (181, "AllocationSiteMap"),
("RO_SPACE", 0x0a231): (181, "AllocationSiteMap"),
("MAP_SPACE", 0x02201): (1057, "ExternalMap"),
("MAP_SPACE", 0x02251): (1072, "JSMessageObjectMap"),
}
@ -328,33 +326,32 @@ KNOWN_OBJECTS = {
("RO_SPACE", 0x02741): "TrueValue",
("RO_SPACE", 0x02801): "FalseValue",
("RO_SPACE", 0x02851): "empty_string",
("RO_SPACE", 0x02d69): "EmptyScopeInfo",
("RO_SPACE", 0x02d79): "EmptyFixedArray",
("RO_SPACE", 0x02d89): "ArgumentsMarker",
("RO_SPACE", 0x02e31): "Exception",
("RO_SPACE", 0x02ed9): "TerminationException",
("RO_SPACE", 0x02f89): "OptimizedOut",
("RO_SPACE", 0x03031): "StaleRegister",
("RO_SPACE", 0x04821): "EmptyByteArray",
("RO_SPACE", 0x04849): "EmptyFixedUint8Array",
("RO_SPACE", 0x04869): "EmptyFixedInt8Array",
("RO_SPACE", 0x04889): "EmptyFixedUint16Array",
("RO_SPACE", 0x048a9): "EmptyFixedInt16Array",
("RO_SPACE", 0x048c9): "EmptyFixedUint32Array",
("RO_SPACE", 0x048e9): "EmptyFixedInt32Array",
("RO_SPACE", 0x04909): "EmptyFixedFloat32Array",
("RO_SPACE", 0x04929): "EmptyFixedFloat64Array",
("RO_SPACE", 0x04949): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x049a9): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x049c9): "EmptySlowElementDictionary",
("RO_SPACE", 0x04a11): "EmptyOrderedHashMap",
("RO_SPACE", 0x04a39): "EmptyOrderedHashSet",
("RO_SPACE", 0x04a71): "EmptyPropertyCell",
("RO_SPACE", 0x04a99): "EmptyWeakCell",
("RO_SPACE", 0x04b61): "InfinityValue",
("RO_SPACE", 0x04b71): "MinusZeroValue",
("RO_SPACE", 0x04b81): "MinusInfinityValue",
("RO_SPACE", 0x04b91): "SelfReferenceMarker",
("RO_SPACE", 0x02d19): "EmptyScopeInfo",
("RO_SPACE", 0x02d29): "EmptyFixedArray",
("RO_SPACE", 0x02d39): "ArgumentsMarker",
("RO_SPACE", 0x02de1): "Exception",
("RO_SPACE", 0x02e89): "TerminationException",
("RO_SPACE", 0x02f39): "OptimizedOut",
("RO_SPACE", 0x02fe1): "StaleRegister",
("RO_SPACE", 0x047d1): "EmptyByteArray",
("RO_SPACE", 0x047f9): "EmptyFixedUint8Array",
("RO_SPACE", 0x04819): "EmptyFixedInt8Array",
("RO_SPACE", 0x04839): "EmptyFixedUint16Array",
("RO_SPACE", 0x04859): "EmptyFixedInt16Array",
("RO_SPACE", 0x04879): "EmptyFixedUint32Array",
("RO_SPACE", 0x04899): "EmptyFixedInt32Array",
("RO_SPACE", 0x048b9): "EmptyFixedFloat32Array",
("RO_SPACE", 0x048d9): "EmptyFixedFloat64Array",
("RO_SPACE", 0x048f9): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x04959): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x04979): "EmptySlowElementDictionary",
("RO_SPACE", 0x049c1): "EmptyOrderedHashMap",
("RO_SPACE", 0x049e9): "EmptyOrderedHashSet",
("RO_SPACE", 0x04a21): "EmptyPropertyCell",
("RO_SPACE", 0x04b01): "InfinityValue",
("RO_SPACE", 0x04b11): "MinusZeroValue",
("RO_SPACE", 0x04b21): "MinusInfinityValue",
("RO_SPACE", 0x04b31): "SelfReferenceMarker",
("OLD_SPACE", 0x02211): "EmptyScript",
("OLD_SPACE", 0x02291): "ManyClosuresCell",
("OLD_SPACE", 0x022b1): "NoElementsProtector",