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

Reland "[interpreter] Move interrupt budget from BytecodeArray to FeedbackCell"

Browse Source 
This is a reland of Ie3ac389e1c082d1671efd4d74abc076ce943301b with a fix
for MSAN failures.

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: I74f998c30e27caf3bd34510f4d7f57b65e6c7f0d
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1561072
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Commit-Queue: Mythri Alle <mythria@chromium.org>
Cr-Commit-Position: refs/heads/master@{#60750}
This commit is contained in:
Mythri A 2019-04-10 12:50:17 +01:00 committed by Commit Bot
parent 1f482f75f3
commit f78f43b1b9
16 changed files with 158 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);
};

18
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,8 @@ 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());
cell->clear_padding();
return cell;
}
@ -1900,6 +1897,8 @@ 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());
cell->clear_padding();
return cell;
}
@ -1909,6 +1908,8 @@ 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());
cell->clear_padding();
return cell;
}
@ -2949,7 +2950,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

@ -669,15 +669,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. */ \

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

@ -22,6 +22,14 @@ OBJECT_CONSTRUCTORS_IMPL(FeedbackCell, Struct)
CAST_ACCESSOR(FeedbackCell)
ACCESSORS(FeedbackCell, value, HeapObject, kValueOffset)
INT32_ACCESSORS(FeedbackCell, interrupt_budget, kInterruptBudgetOffset)
void FeedbackCell::clear_padding() {
if (FeedbackCell::kSize == FeedbackCell::kUnalignedSize) return;
DCHECK_GE(FeedbackCell::kSize, FeedbackCell::kUnalignedSize);
memset(reinterpret_cast<byte*>(address() + FeedbackCell::kUnalignedSize), 0,
FeedbackCell::kSize - FeedbackCell::kUnalignedSize);
}
} // namespace internal
} // namespace v8

25
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,22 @@ 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});
inline void clear_padding();
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.