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

[interpreter] Move interrupt budget from BytecodeArray to FeedbackCell

Browse Source 
Interrupt budget was store in bytecode array and used to be shared
across all contexts. With lazy feedback allocation, using context
independent interrupt budget might lead to performance cliffs when
we have closures that do not share the same feedback (for ex: across
contexts). This would be a problem even earlier but it could be
more pronounced with feedback vector allocation, since the budgets
for optimization is much higher (144x) than the budget for feedback
allocation.

Bug: chromium:948835, v8:8394
Change-Id: Ie3ac389e1c082d1671efd4d74abc076ce943301b
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1558088
Commit-Queue: Mythri Alle <mythria@chromium.org>
Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#60734}
This commit is contained in:
Mythri A 2019-04-09 17:43:59 +01:00 committed by Commit Bot
parent f8d1169622
commit f39944853f
16 changed files with 146 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/feedback-vector-inl.h
View File

@ -96,11 +96,8 @@ int FeedbackMetadata::GetSlotSize(FeedbackSlotKind kind) {
return 1;
}
SMI_ACCESSORS(ClosureFeedbackCellArray, interrupt_budget,
FixedArray::OffsetOfElementAt(kInterruptBudgetIndex))
Handle<FeedbackCell> ClosureFeedbackCellArray::GetFeedbackCell(int index) {
return handle(FeedbackCell::cast(get(index + kFeedbackCellStartIndex)),
GetIsolate());
return handle(FeedbackCell::cast(get(index)), GetIsolate());
}
ACCESSORS(FeedbackVector, shared_function_info, SharedFunctionInfo,

2
src/feedback-vector.cc
View File

@ -220,7 +220,7 @@ Handle<ClosureFeedbackCellArray> ClosureFeedbackCellArray::New(
for (int i = 0; i < num_feedback_cells; i++) {
Handle<FeedbackCell> cell =
factory->NewNoClosuresCell(factory->undefined_value());
feedback_cell_array->set(i + kFeedbackCellStartIndex, *cell);
feedback_cell_array->set(i, *cell);
}
return feedback_cell_array;
}

4
src/feedback-vector.h
View File

@ -161,13 +161,9 @@ class ClosureFeedbackCellArray : public FixedArray {
Isolate* isolate, Handle<SharedFunctionInfo> shared);
inline Handle<FeedbackCell> GetFeedbackCell(int index);
DECL_INT_ACCESSORS(interrupt_budget)
DECL_VERIFIER(ClosureFeedbackCellArray)
DECL_PRINTER(ClosureFeedbackCellArray)
enum { kInterruptBudgetIndex, kFeedbackCellStartIndex };
private:
OBJECT_CONSTRUCTORS(ClosureFeedbackCellArray, FixedArray);
};

15
src/heap/factory.cc
View File

@ -419,17 +419,13 @@ Handle<FixedArray> Factory::NewUninitializedFixedArray(
}
Handle<ClosureFeedbackCellArray> Factory::NewClosureFeedbackCellArray(
int num_slots, AllocationType allocation) {
int length = ClosureFeedbackCellArray::kFeedbackCellStartIndex + num_slots;
int length, AllocationType allocation) {
if (length == 0) return empty_closure_feedback_cell_array();
Handle<ClosureFeedbackCellArray> feedback_cell_array =
NewFixedArrayWithMap<ClosureFeedbackCellArray>(
RootIndex::kClosureFeedbackCellArrayMap, length, allocation);
// Initialize header fields
feedback_cell_array->set_interrupt_budget(
FLAG_budget_for_feedback_vector_allocation);
DCHECK_EQ(ClosureFeedbackCellArray::kFeedbackCellStartIndex, 1);
return feedback_cell_array;
}
@ -1823,7 +1819,6 @@ Handle<BytecodeArray> Factory::NewBytecodeArray(
instance->set_parameter_count(parameter_count);
instance->set_incoming_new_target_or_generator_register(
interpreter::Register::invalid_value());
instance->set_interrupt_budget(interpreter::Interpreter::InterruptBudget());
instance->set_osr_loop_nesting_level(0);
instance->set_bytecode_age(BytecodeArray::kNoAgeBytecodeAge);
instance->set_constant_pool(*constant_pool);
@ -1891,6 +1886,7 @@ Handle<FeedbackCell> Factory::NewNoClosuresCell(Handle<HeapObject> value) {
FeedbackCell::kSize, AllocationType::kOld, *no_closures_cell_map());
Handle<FeedbackCell> cell(FeedbackCell::cast(result), isolate());
cell->set_value(*value);
cell->set_interrupt_budget(FeedbackCell::GetInitialInterruptBudget());
return cell;
}
@ -1900,6 +1896,7 @@ Handle<FeedbackCell> Factory::NewOneClosureCell(Handle<HeapObject> value) {
FeedbackCell::kSize, AllocationType::kOld, *one_closure_cell_map());
Handle<FeedbackCell> cell(FeedbackCell::cast(result), isolate());
cell->set_value(*value);
cell->set_interrupt_budget(FeedbackCell::GetInitialInterruptBudget());
return cell;
}
@ -1909,6 +1906,7 @@ Handle<FeedbackCell> Factory::NewManyClosuresCell(Handle<HeapObject> value) {
FeedbackCell::kSize, AllocationType::kOld, *many_closures_cell_map());
Handle<FeedbackCell> cell(FeedbackCell::cast(result), isolate());
cell->set_value(*value);
cell->set_interrupt_budget(FeedbackCell::GetInitialInterruptBudget());
return cell;
}
@ -2949,7 +2947,6 @@ Handle<BytecodeArray> Factory::CopyBytecodeArray(
copy->set_constant_pool(bytecode_array->constant_pool());
copy->set_handler_table(bytecode_array->handler_table());
copy->set_source_position_table(bytecode_array->source_position_table());
copy->set_interrupt_budget(bytecode_array->interrupt_budget());
copy->set_osr_loop_nesting_level(bytecode_array->osr_loop_nesting_level());
copy->set_bytecode_age(bytecode_array->bytecode_age());
bytecode_array->CopyBytecodesTo(*copy);

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

@ -602,6 +602,17 @@ bool Heap::CreateInitialMaps() {
set_empty_property_array(PropertyArray::cast(obj));
}
{
if (!AllocateRaw(FixedArray::SizeFor(0), AllocationType::kReadOnly)
.To(&obj)) {
return false;
}
obj->set_map_after_allocation(roots.closure_feedback_cell_array_map(),
SKIP_WRITE_BARRIER);
FixedArray::cast(obj)->set_length(0);
set_empty_closure_feedback_cell_array(ClosureFeedbackCellArray::cast(obj));
}
#define ALLOCATE_EMPTY_FIXED_TYPED_ARRAY(Type, type, TYPE, ctype) \
{ \
FixedTypedArrayBase obj; \

48
src/interpreter/interpreter-assembler.cc
View File

@ -1259,30 +1259,14 @@ void InterpreterAssembler::UpdateInterruptBudget(Node* weight, bool backward) {
Label load_budget_from_bytecode(this), load_budget_done(this);
TNode<JSFunction> function = CAST(LoadRegister(Register::function_closure()));
TNode<HeapObject> feedback_cell_value = LoadFeedbackCellValue(function);
Node* budget_offset =
IntPtrConstant(BytecodeArray::kInterruptBudgetOffset - kHeapObjectTag);
TVARIABLE(Int32T, old_budget);
// TODO(mythria): We should use the interrupt budget on the feedback vector
// for updating runtime profiler ticks as well. That would avoid having two
// different places where we track interrupt budget.
GotoIf(IsFeedbackVector(feedback_cell_value), &load_budget_from_bytecode);
TNode<FixedArray> closure_feedback_cell_array = CAST(feedback_cell_value);
TNode<Smi> old_budget_smi = CAST(UnsafeLoadFixedArrayElement(
closure_feedback_cell_array,
ClosureFeedbackCellArray::kInterruptBudgetIndex));
old_budget = SmiToInt32(old_budget_smi);
Goto(&load_budget_done);
TNode<FeedbackCell> feedback_cell =
CAST(LoadObjectField(function, JSFunction::kFeedbackCellOffset));
TNode<Int32T> old_budget = LoadObjectField<Int32T>(
feedback_cell, FeedbackCell::kInterruptBudgetOffset);
BIND(&load_budget_from_bytecode);
old_budget = UncheckedCast<Int32T>(
Load(MachineType::Int32(), BytecodeArrayTaggedPointer(), budget_offset));
Goto(&load_budget_done);
BIND(&load_budget_done);
// Make sure we include the current bytecode in the budget calculation.
TNode<Int32T> budget_after_bytecode = Signed(
Int32Sub(old_budget.value(), Int32Constant(CurrentBytecodeSize())));
TNode<Int32T> budget_after_bytecode =
Signed(Int32Sub(old_budget, Int32Constant(CurrentBytecodeSize())));
TVARIABLE(Int32T, new_budget);
if (backward) {
@ -1290,7 +1274,7 @@ void InterpreterAssembler::UpdateInterruptBudget(Node* weight, bool backward) {
new_budget = Signed(Int32Sub(budget_after_bytecode, weight));
Node* condition =
Int32GreaterThanOrEqual(new_budget.value(), Int32Constant(0));
Label ok(this), interrupt_check(this);
Label ok(this), interrupt_check(this, Label::kDeferred);
Branch(condition, &ok, &interrupt_check);
BIND(&interrupt_check);
@ -1306,21 +1290,9 @@ void InterpreterAssembler::UpdateInterruptBudget(Node* weight, bool backward) {
}
// Update budget.
Label update_budget_in_bytecode(this), end(this);
GotoIf(IsFeedbackVector(feedback_cell_value), &update_budget_in_bytecode);
UnsafeStoreFixedArrayElement(closure_feedback_cell_array,
ClosureFeedbackCellArray::kInterruptBudgetIndex,
SmiFromInt32(new_budget.value()),
SKIP_WRITE_BARRIER);
Goto(&end);
BIND(&update_budget_in_bytecode);
StoreNoWriteBarrier(MachineRepresentation::kWord32,
BytecodeArrayTaggedPointer(), budget_offset,
new_budget.value());
Goto(&end);
BIND(&end);
StoreObjectFieldNoWriteBarrier(
feedback_cell, FeedbackCell::kInterruptBudgetOffset, new_budget.value(),
MachineRepresentation::kWord32);
Comment("] UpdateInterruptBudget");
}

5
src/interpreter/interpreter-generator.cc
View File

@ -2632,9 +2632,8 @@ IGNITION_HANDLER(CreateClosure, InterpreterAssembler) {
Label if_undefined(this);
TNode<FixedArray> feedback_cell_array =
LoadClosureFeedbackArray(LoadRegister(Register::function_closure()));
TNode<FeedbackCell> feedback_cell = CAST(LoadFixedArrayElement(
feedback_cell_array, slot,
ClosureFeedbackCellArray::kFeedbackCellStartIndex * kTaggedSize));
TNode<FeedbackCell> feedback_cell =
CAST(LoadFixedArrayElement(feedback_cell_array, slot));
Label if_fast(this), if_slow(this, Label::kDeferred);
Branch(IsSetWord32<CreateClosureFlags::FastNewClosureBit>(flags), &if_fast,

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

@ -670,15 +670,6 @@ void BytecodeArray::set_incoming_new_target_or_generator_register(
}
}
int BytecodeArray::interrupt_budget() const {
return READ_INT_FIELD(*this, kInterruptBudgetOffset);
}
void BytecodeArray::set_interrupt_budget(int interrupt_budget) {
DCHECK_GE(interrupt_budget, 0);
WRITE_INT_FIELD(*this, kInterruptBudgetOffset, interrupt_budget);
}
int BytecodeArray::osr_loop_nesting_level() const {
return READ_INT8_FIELD(*this, kOSRNestingLevelOffset);
}

5
src/objects/code.h
View File

@ -758,10 +758,6 @@ class BytecodeArray : public FixedArrayBase {
inline void set_incoming_new_target_or_generator_register(
interpreter::Register incoming_new_target_or_generator_register);
// Accessors for profiling count.
inline int interrupt_budget() const;
inline void set_interrupt_budget(int interrupt_budget);
// Accessors for OSR loop nesting level.
inline int osr_loop_nesting_level() const;
inline void set_osr_loop_nesting_level(int depth);
@ -841,7 +837,6 @@ class BytecodeArray : public FixedArrayBase {
V(kFrameSizeOffset, kIntSize) \
V(kParameterSizeOffset, kIntSize) \
V(kIncomingNewTargetOrGeneratorRegisterOffset, kIntSize) \
V(kInterruptBudgetOffset, kIntSize) \
V(kOSRNestingLevelOffset, kCharSize) \
V(kBytecodeAgeOffset, kCharSize) \
/* Total size. */ \

1
src/objects/feedback-cell-inl.h
View File

@ -22,6 +22,7 @@ OBJECT_CONSTRUCTORS_IMPL(FeedbackCell, Struct)
CAST_ACCESSOR(FeedbackCell)
ACCESSORS(FeedbackCell, value, HeapObject, kValueOffset)
INT32_ACCESSORS(FeedbackCell, interrupt_budget, kInterruptBudgetOffset)
} // namespace internal
} // namespace v8

23
src/objects/feedback-cell.h
View File

@ -20,8 +20,16 @@ namespace internal {
// a native context.
class FeedbackCell : public Struct {
public:
static int GetInitialInterruptBudget() {
if (FLAG_lazy_feedback_allocation) {
return FLAG_budget_for_feedback_vector_allocation;
}
return FLAG_interrupt_budget;
}
// [value]: value of the cell.
DECL_ACCESSORS(value, HeapObject)
DECL_INT32_ACCESSORS(interrupt_budget)
DECL_CAST(FeedbackCell)
@ -30,15 +38,20 @@ class FeedbackCell : public Struct {
DECL_VERIFIER(FeedbackCell)
// Layout description.
#define FEEDBACK_CELL_FIELDS(V) \
V(kValueOffset, kTaggedSize) \
/* Total size. */ \
V(kSize, 0)
#define FEEDBACK_CELL_FIELDS(V) \
V(kValueOffset, kTaggedSize) \
/* Non-pointer fields */ \
V(kInterruptBudgetOffset, kInt32Size) \
/* Total size. */ \
V(kUnalignedSize, 0)
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, FEEDBACK_CELL_FIELDS)
#undef FEEDBACK_CELL_FIELDS
using BodyDescriptor = FixedBodyDescriptor<kValueOffset, kSize, kSize>;
static const int kSize = RoundUp<kObjectAlignment>(int{kUnalignedSize});
using BodyDescriptor =
FixedBodyDescriptor<kValueOffset, kInterruptBudgetOffset, kSize>;
OBJECT_CONSTRUCTORS(FeedbackCell, Struct);
};

2
src/roots.h
View File

@ -182,6 +182,8 @@ class RootVisitor;
EmptyObjectBoilerplateDescription) \
V(ArrayBoilerplateDescription, empty_array_boilerplate_description, \
EmptyArrayBoilerplateDescription) \
V(ClosureFeedbackCellArray, empty_closure_feedback_cell_array, \
EmptyClosureFeedbackCellArray) \
V(FixedTypedArrayBase, empty_fixed_uint8_array, EmptyFixedUint8Array) \
V(FixedTypedArrayBase, empty_fixed_int8_array, EmptyFixedInt8Array) \
V(FixedTypedArrayBase, empty_fixed_uint16_array, EmptyFixedUint16Array) \

2
src/snapshot/deserializer.cc
View File

@ -306,8 +306,6 @@ HeapObject Deserializer::PostProcessNewObject(HeapObject obj, int space) {
// TODO(mythria): Remove these once we store the default values for these
// fields in the serializer.
BytecodeArray bytecode_array = BytecodeArray::cast(obj);
bytecode_array->set_interrupt_budget(
interpreter::Interpreter::InterruptBudget());
bytecode_array->set_osr_loop_nesting_level(0);
}
#ifdef DEBUG

6
src/snapshot/partial-serializer.cc
View File

@ -101,6 +101,12 @@ void PartialSerializer::SerializeObject(HeapObject obj) {
// Clear literal boilerplates and feedback.
if (obj->IsFeedbackVector()) FeedbackVector::cast(obj)->ClearSlots(isolate());
// Clear InterruptBudget when serializing FeedbackCell.
if (obj->IsFeedbackCell()) {
FeedbackCell::cast(obj)->set_interrupt_budget(
FeedbackCell::GetInitialInterruptBudget());
}
if (SerializeJSObjectWithEmbedderFields(obj)) {
return;
}

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

@ -2442,8 +2442,6 @@ TEST(CodeSerializerAfterExecute) {
Handle<SharedFunctionInfo> sfi = v8::Utils::OpenHandle(*script);
CHECK(sfi->HasBytecodeArray());
BytecodeArray bytecode = sfi->GetBytecodeArray();
CHECK_EQ(bytecode->interrupt_budget(),
interpreter::Interpreter::InterruptBudget());
CHECK_EQ(bytecode->osr_loop_nesting_level(), 0);
{

175
tools/v8heapconst.py
View File

@ -304,47 +304,47 @@ KNOWN_MAPS = {
("RO_SPACE", 0x026c9): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x02731): (175, "Tuple2Map"),
("RO_SPACE", 0x027d1): (177, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x02b11): (164, "InterceptorInfoMap"),
("RO_SPACE", 0x050f9): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x05149): (154, "AccessorInfoMap"),
("RO_SPACE", 0x05199): (155, "AccessorPairMap"),
("RO_SPACE", 0x051e9): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x05239): (157, "AllocationMementoMap"),
("RO_SPACE", 0x05289): (158, "AsmWasmDataMap"),
("RO_SPACE", 0x052d9): (159, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x05329): (160, "ClassPositionsMap"),
("RO_SPACE", 0x05379): (161, "DebugInfoMap"),
("RO_SPACE", 0x053c9): (162, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x05419): (163, "FunctionTemplateRareDataMap"),
("RO_SPACE", 0x05469): (165, "InterpreterDataMap"),
("RO_SPACE", 0x054b9): (166, "ModuleInfoEntryMap"),
("RO_SPACE", 0x05509): (167, "ModuleMap"),
("RO_SPACE", 0x05559): (168, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x055a9): (169, "PromiseCapabilityMap"),
("RO_SPACE", 0x055f9): (170, "PromiseReactionMap"),
("RO_SPACE", 0x05649): (171, "PrototypeInfoMap"),
("RO_SPACE", 0x05699): (172, "ScriptMap"),
("RO_SPACE", 0x056e9): (173, "StackFrameInfoMap"),
("RO_SPACE", 0x05739): (174, "StackTraceFrameMap"),
("RO_SPACE", 0x05789): (176, "Tuple3Map"),
("RO_SPACE", 0x057d9): (178, "WasmDebugInfoMap"),
("RO_SPACE", 0x05829): (179, "WasmExceptionTagMap"),
("RO_SPACE", 0x05879): (180, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x058c9): (181, "CallableTaskMap"),
("RO_SPACE", 0x05919): (182, "CallbackTaskMap"),
("RO_SPACE", 0x05969): (183, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x059b9): (184, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x05a09): (185, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x05a59): (186, "FinalizationGroupCleanupJobTaskMap"),
("RO_SPACE", 0x05aa9): (187, "AllocationSiteWithWeakNextMap"),
("RO_SPACE", 0x05af9): (187, "AllocationSiteWithoutWeakNextMap"),
("RO_SPACE", 0x05b49): (222, "LoadHandler1Map"),
("RO_SPACE", 0x05b99): (222, "LoadHandler2Map"),
("RO_SPACE", 0x05be9): (222, "LoadHandler3Map"),
("RO_SPACE", 0x05c39): (230, "StoreHandler0Map"),
("RO_SPACE", 0x05c89): (230, "StoreHandler1Map"),
("RO_SPACE", 0x05cd9): (230, "StoreHandler2Map"),
("RO_SPACE", 0x05d29): (230, "StoreHandler3Map"),
("RO_SPACE", 0x02b21): (164, "InterceptorInfoMap"),
("RO_SPACE", 0x05109): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x05159): (154, "AccessorInfoMap"),
("RO_SPACE", 0x051a9): (155, "AccessorPairMap"),
("RO_SPACE", 0x051f9): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x05249): (157, "AllocationMementoMap"),
("RO_SPACE", 0x05299): (158, "AsmWasmDataMap"),
("RO_SPACE", 0x052e9): (159, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x05339): (160, "ClassPositionsMap"),
("RO_SPACE", 0x05389): (161, "DebugInfoMap"),
("RO_SPACE", 0x053d9): (162, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x05429): (163, "FunctionTemplateRareDataMap"),
("RO_SPACE", 0x05479): (165, "InterpreterDataMap"),
("RO_SPACE", 0x054c9): (166, "ModuleInfoEntryMap"),
("RO_SPACE", 0x05519): (167, "ModuleMap"),
("RO_SPACE", 0x05569): (168, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x055b9): (169, "PromiseCapabilityMap"),
("RO_SPACE", 0x05609): (170, "PromiseReactionMap"),
("RO_SPACE", 0x05659): (171, "PrototypeInfoMap"),
("RO_SPACE", 0x056a9): (172, "ScriptMap"),
("RO_SPACE", 0x056f9): (173, "StackFrameInfoMap"),
("RO_SPACE", 0x05749): (174, "StackTraceFrameMap"),
("RO_SPACE", 0x05799): (176, "Tuple3Map"),
("RO_SPACE", 0x057e9): (178, "WasmDebugInfoMap"),
("RO_SPACE", 0x05839): (179, "WasmExceptionTagMap"),
("RO_SPACE", 0x05889): (180, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x058d9): (181, "CallableTaskMap"),
("RO_SPACE", 0x05929): (182, "CallbackTaskMap"),
("RO_SPACE", 0x05979): (183, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x059c9): (184, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x05a19): (185, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x05a69): (186, "FinalizationGroupCleanupJobTaskMap"),
("RO_SPACE", 0x05ab9): (187, "AllocationSiteWithWeakNextMap"),
("RO_SPACE", 0x05b09): (187, "AllocationSiteWithoutWeakNextMap"),
("RO_SPACE", 0x05b59): (222, "LoadHandler1Map"),
("RO_SPACE", 0x05ba9): (222, "LoadHandler2Map"),
("RO_SPACE", 0x05bf9): (222, "LoadHandler3Map"),
("RO_SPACE", 0x05c49): (230, "StoreHandler0Map"),
("RO_SPACE", 0x05c99): (230, "StoreHandler1Map"),
("RO_SPACE", 0x05ce9): (230, "StoreHandler2Map"),
("RO_SPACE", 0x05d39): (230, "StoreHandler3Map"),
("MAP_SPACE", 0x00139): (1057, "ExternalMap"),
("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"),
}
@ -374,32 +374,33 @@ KNOWN_OBJECTS = {
("RO_SPACE", 0x02791): "EmptyByteArray",
("RO_SPACE", 0x027a1): "EmptyObjectBoilerplateDescription",
("RO_SPACE", 0x027b9): "EmptyArrayBoilerplateDescription",
("RO_SPACE", 0x02821): "EmptyFixedUint8Array",
("RO_SPACE", 0x02841): "EmptyFixedInt8Array",
("RO_SPACE", 0x02861): "EmptyFixedUint16Array",
("RO_SPACE", 0x02881): "EmptyFixedInt16Array",
("RO_SPACE", 0x028a1): "EmptyFixedUint32Array",
("RO_SPACE", 0x028c1): "EmptyFixedInt32Array",
("RO_SPACE", 0x028e1): "EmptyFixedFloat32Array",
("RO_SPACE", 0x02901): "EmptyFixedFloat64Array",
("RO_SPACE", 0x02921): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x02941): "EmptyFixedBigUint64Array",
("RO_SPACE", 0x02961): "EmptyFixedBigInt64Array",
("RO_SPACE", 0x02981): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x029a1): "EmptySlowElementDictionary",
("RO_SPACE", 0x029e9): "EmptyOrderedHashMap",
("RO_SPACE", 0x02a11): "EmptyOrderedHashSet",
("RO_SPACE", 0x02a39): "EmptyFeedbackMetadata",
("RO_SPACE", 0x02a49): "EmptyPropertyCell",
("RO_SPACE", 0x02a71): "EmptyPropertyDictionary",
("RO_SPACE", 0x02ac1): "NoOpInterceptorInfo",
("RO_SPACE", 0x02b61): "EmptyWeakArrayList",
("RO_SPACE", 0x02b79): "InfinityValue",
("RO_SPACE", 0x02b89): "MinusZeroValue",
("RO_SPACE", 0x02b99): "MinusInfinityValue",
("RO_SPACE", 0x02ba9): "SelfReferenceMarker",
("RO_SPACE", 0x02c01): "OffHeapTrampolineRelocationInfo",
("RO_SPACE", 0x02c19): "HashSeed",
("RO_SPACE", 0x02821): "EmptyClosureFeedbackCellArray",
("RO_SPACE", 0x02831): "EmptyFixedUint8Array",
("RO_SPACE", 0x02851): "EmptyFixedInt8Array",
("RO_SPACE", 0x02871): "EmptyFixedUint16Array",
("RO_SPACE", 0x02891): "EmptyFixedInt16Array",
("RO_SPACE", 0x028b1): "EmptyFixedUint32Array",
("RO_SPACE", 0x028d1): "EmptyFixedInt32Array",
("RO_SPACE", 0x028f1): "EmptyFixedFloat32Array",
("RO_SPACE", 0x02911): "EmptyFixedFloat64Array",
("RO_SPACE", 0x02931): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x02951): "EmptyFixedBigUint64Array",
("RO_SPACE", 0x02971): "EmptyFixedBigInt64Array",
("RO_SPACE", 0x02991): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x029b1): "EmptySlowElementDictionary",
("RO_SPACE", 0x029f9): "EmptyOrderedHashMap",
("RO_SPACE", 0x02a21): "EmptyOrderedHashSet",
("RO_SPACE", 0x02a49): "EmptyFeedbackMetadata",
("RO_SPACE", 0x02a59): "EmptyPropertyCell",
("RO_SPACE", 0x02a81): "EmptyPropertyDictionary",
("RO_SPACE", 0x02ad1): "NoOpInterceptorInfo",
("RO_SPACE", 0x02b71): "EmptyWeakArrayList",
("RO_SPACE", 0x02b89): "InfinityValue",
("RO_SPACE", 0x02b99): "MinusZeroValue",
("RO_SPACE", 0x02ba9): "MinusInfinityValue",
("RO_SPACE", 0x02bb9): "SelfReferenceMarker",
("RO_SPACE", 0x02c11): "OffHeapTrampolineRelocationInfo",
("RO_SPACE", 0x02c29): "HashSeed",
("OLD_SPACE", 0x00139): "ArgumentsIteratorAccessor",
("OLD_SPACE", 0x001a9): "ArrayLengthAccessor",
("OLD_SPACE", 0x00219): "BoundFunctionLengthAccessor",
@ -414,26 +415,26 @@ KNOWN_OBJECTS = {
("OLD_SPACE", 0x00609): "InvalidPrototypeValidityCell",
("OLD_SPACE", 0x00619): "EmptyScript",
("OLD_SPACE", 0x00699): "ManyClosuresCell",
("OLD_SPACE", 0x006a9): "ArrayConstructorProtector",
("OLD_SPACE", 0x006b9): "NoElementsProtector",
("OLD_SPACE", 0x006e1): "IsConcatSpreadableProtector",
("OLD_SPACE", 0x006f1): "ArraySpeciesProtector",
("OLD_SPACE", 0x00719): "TypedArraySpeciesProtector",
("OLD_SPACE", 0x00741): "RegExpSpeciesProtector",
("OLD_SPACE", 0x00769): "PromiseSpeciesProtector",
("OLD_SPACE", 0x00791): "StringLengthProtector",
("OLD_SPACE", 0x007a1): "ArrayIteratorProtector",
("OLD_SPACE", 0x007c9): "ArrayBufferDetachingProtector",
("OLD_SPACE", 0x007f1): "PromiseHookProtector",
("OLD_SPACE", 0x00819): "PromiseResolveProtector",
("OLD_SPACE", 0x00829): "MapIteratorProtector",
("OLD_SPACE", 0x00851): "PromiseThenProtector",
("OLD_SPACE", 0x00879): "SetIteratorProtector",
("OLD_SPACE", 0x008a1): "StringIteratorProtector",
("OLD_SPACE", 0x008c9): "SingleCharacterStringCache",
("OLD_SPACE", 0x010d9): "StringSplitCache",
("OLD_SPACE", 0x018e9): "RegExpMultipleCache",
("OLD_SPACE", 0x020f9): "BuiltinsConstantsTable",
("OLD_SPACE", 0x006b1): "ArrayConstructorProtector",
("OLD_SPACE", 0x006c1): "NoElementsProtector",
("OLD_SPACE", 0x006e9): "IsConcatSpreadableProtector",
("OLD_SPACE", 0x006f9): "ArraySpeciesProtector",
("OLD_SPACE", 0x00721): "TypedArraySpeciesProtector",
("OLD_SPACE", 0x00749): "RegExpSpeciesProtector",
("OLD_SPACE", 0x00771): "PromiseSpeciesProtector",
("OLD_SPACE", 0x00799): "StringLengthProtector",
("OLD_SPACE", 0x007a9): "ArrayIteratorProtector",
("OLD_SPACE", 0x007d1): "ArrayBufferDetachingProtector",
("OLD_SPACE", 0x007f9): "PromiseHookProtector",
("OLD_SPACE", 0x00821): "PromiseResolveProtector",
("OLD_SPACE", 0x00831): "MapIteratorProtector",
("OLD_SPACE", 0x00859): "PromiseThenProtector",
("OLD_SPACE", 0x00881): "SetIteratorProtector",
("OLD_SPACE", 0x008a9): "StringIteratorProtector",
("OLD_SPACE", 0x008d1): "SingleCharacterStringCache",
("OLD_SPACE", 0x010e1): "StringSplitCache",
("OLD_SPACE", 0x018f1): "RegExpMultipleCache",
("OLD_SPACE", 0x02101): "BuiltinsConstantsTable",
}
# List of known V8 Frame Markers.