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

Preparation for feedback-free V8: Use feedback vector only when valid

Browse Source 
This cl updates:
1. Adds a new feedback cell map to specify that no feedback is
collected
2. Checks if feedback vectors are valid before using then when
creating closures
3. Runtime profiler to only tier up functions with feedback
4. Interpreter entry trampoline to check for feedback vector before
using it.

Bug: v8:8394
Change-Id: I0248c8cd35d841c2744b22f4c672fa2e82033f6e
Reviewed-on: https://chromium-review.googlesource.com/c/1339866
Commit-Queue: Mythri Alle <mythria@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57648}
This commit is contained in:
Mythri 2018-11-20 13:55:10 +00:00 committed by Commit Bot
parent 0d2dcb0c4a
commit 4237fc378c
16 changed files with 284 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/builtins/arm/builtins-arm.cc
View File

@ -690,6 +690,9 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
Operand(Smi::FromEnum(OptimizationMarker::kNone)));
__ b(eq, &fallthrough);
// TODO(v8:8394): The logging of first execution will break if
// feedback vectors are not allocated. We need to find a different way of
// logging these events if required.
TailCallRuntimeIfMarkerEquals(masm, optimized_code_entry,
OptimizationMarker::kLogFirstExecution,
Runtime::kFunctionFirstExecution);
@ -833,13 +836,28 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
__ ldr(feedback_vector,
FieldMemOperand(closure, JSFunction::kFeedbackCellOffset));
__ ldr(feedback_vector, FieldMemOperand(feedback_vector, Cell::kValueOffset));
Label push_stack_frame;
// Check if feedback vector is valid. If valid, check for optimized code
// and update invocation count. Otherwise, setup the stack frame.
__ CompareRoot(feedback_vector, RootIndex::kUndefinedValue);
__ b(eq, &push_stack_frame);
// Read off the optimized code slot in the feedback vector, and if there
// is optimized code or an optimization marker, call that instead.
MaybeTailCallOptimizedCodeSlot(masm, feedback_vector, r4, r6, r5);
// Increment invocation count for the function.
__ ldr(r9, FieldMemOperand(feedback_vector,
FeedbackVector::kInvocationCountOffset));
__ add(r9, r9, Operand(1));
__ str(r9, FieldMemOperand(feedback_vector,
FeedbackVector::kInvocationCountOffset));
// Open a frame scope to indicate that there is a frame on the stack. The
// MANUAL indicates that the scope shouldn't actually generate code to set up
// the frame (that is done below).
__ bind(&push_stack_frame);
FrameScope frame_scope(masm, StackFrame::MANUAL);
__ PushStandardFrame(closure);
@ -850,13 +868,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
FieldMemOperand(r0, SharedFunctionInfo::kFunctionDataOffset));
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister, r4);
// Increment invocation count for the function.
__ ldr(r9, FieldMemOperand(feedback_vector,
FeedbackVector::kInvocationCountOffset));
__ add(r9, r9, Operand(1));
__ str(r9, FieldMemOperand(feedback_vector,
FeedbackVector::kInvocationCountOffset));
// Check function data field is actually a BytecodeArray object.
if (FLAG_debug_code) {
__ SmiTst(kInterpreterBytecodeArrayRegister);

26
src/builtins/arm64/builtins-arm64.cc
View File

@ -786,6 +786,9 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
Operand(Smi::FromEnum(OptimizationMarker::kNone)), eq,
&fallthrough);
// TODO(v8:8394): The logging of first execution will break if
// feedback vectors are not allocated. We need to find a different way of
// logging these events if required.
TailCallRuntimeIfMarkerEquals(masm, optimized_code_entry,
OptimizationMarker::kLogFirstExecution,
Runtime::kFunctionFirstExecution);
@ -927,13 +930,29 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
__ Ldr(feedback_vector,
FieldMemOperand(closure, JSFunction::kFeedbackCellOffset));
__ Ldr(feedback_vector, FieldMemOperand(feedback_vector, Cell::kValueOffset));
Label push_stack_frame;
// Check if feedback vector is valid. If valid, check for optimized code
// and update invocation count. Otherwise, setup the stack frame.
__ CompareRoot(feedback_vector, RootIndex::kUndefinedValue);
__ B(eq, &push_stack_frame);
// Read off the optimized code slot in the feedback vector, and if there
// is optimized code or an optimization marker, call that instead.
MaybeTailCallOptimizedCodeSlot(masm, feedback_vector, x7, x4, x5);
// Increment invocation count for the function.
// MaybeTailCallOptimizedCodeSlot preserves feedback_vector, so safe to reuse
__ Ldr(w10, FieldMemOperand(feedback_vector,
FeedbackVector::kInvocationCountOffset));
__ Add(w10, w10, Operand(1));
__ Str(w10, FieldMemOperand(feedback_vector,
FeedbackVector::kInvocationCountOffset));
// Open a frame scope to indicate that there is a frame on the stack. The
// MANUAL indicates that the scope shouldn't actually generate code to set up
// the frame (that is done below).
__ Bind(&push_stack_frame);
FrameScope frame_scope(masm, StackFrame::MANUAL);
__ Push(lr, fp, cp, closure);
__ Add(fp, sp, StandardFrameConstants::kFixedFrameSizeFromFp);
@ -952,13 +971,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
InterpreterData::kBytecodeArrayOffset));
__ Bind(&has_bytecode_array);
// Increment invocation count for the function.
__ Ldr(x11, FieldMemOperand(closure, JSFunction::kFeedbackCellOffset));
__ Ldr(x11, FieldMemOperand(x11, Cell::kValueOffset));
__ Ldr(w10, FieldMemOperand(x11, FeedbackVector::kInvocationCountOffset));
__ Add(w10, w10, Operand(1));
__ Str(w10, FieldMemOperand(x11, FeedbackVector::kInvocationCountOffset));
// Check function data field is actually a BytecodeArray object.
if (FLAG_debug_code) {
__ AssertNotSmi(

1
src/builtins/builtins-constructor-gen.cc
View File

@ -71,6 +71,7 @@ TF_BUILTIN(FastNewClosure, ConstructorBuiltinsAssembler) {
Node* const feedback_cell_map = LoadMap(feedback_cell);
Label no_closures(this), one_closure(this), cell_done(this);
GotoIf(IsNoFeedbackCellMap(feedback_cell_map), &cell_done);
GotoIf(IsNoClosuresCellMap(feedback_cell_map), &no_closures);
GotoIf(IsOneClosureCellMap(feedback_cell_map), &one_closure);
CSA_ASSERT(this, IsManyClosuresCellMap(feedback_cell_map),

21
src/builtins/ia32/builtins-ia32.cc
View File

@ -647,17 +647,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
// -- eax : argument count (preserved for callee if needed, and caller)
// -- edx : new target (preserved for callee if needed, and caller)
// -- edi : target function (preserved for callee if needed, and caller)
// -- ecx : feedback vector (also used as scratch, value is not preserved)
// -----------------------------------
DCHECK(!AreAliased(eax, edx, edi, scratch));
Label optimized_code_slot_is_weak_ref, fallthrough;
Register closure = edi;
// Load the feedback vector from the closure.
// Scratch contains feedback_vector.
Register feedback_vector = scratch;
__ mov(feedback_vector,
FieldOperand(closure, JSFunction::kFeedbackCellOffset));
__ mov(feedback_vector, FieldOperand(feedback_vector, Cell::kValueOffset));
// Load the optimized code from the feedback vector and re-use the register.
Register optimized_code_entry = scratch;
@ -677,6 +675,9 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
Immediate(Smi::FromEnum(OptimizationMarker::kNone)));
__ j(equal, &fallthrough);
// TODO(v8:8394): The logging of first execution will break if
// feedback vectors are not allocated. We need to find a different way of
// logging these events if required.
TailCallRuntimeIfMarkerEquals(masm, optimized_code_entry,
OptimizationMarker::kLogFirstExecution,
Runtime::kFunctionFirstExecution);
@ -823,12 +824,21 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
Register closure = edi;
Register feedback_vector = ecx;
Label push_stack_frame;
// Load feedback vector and check if it is valid. If valid, check for
// optimized code and update invocation count. Otherwise, setup the stack
// frame.
__ mov(feedback_vector,
FieldOperand(closure, JSFunction::kFeedbackCellOffset));
__ mov(feedback_vector, FieldOperand(feedback_vector, Cell::kValueOffset));
__ JumpIfRoot(feedback_vector, RootIndex::kUndefinedValue, &push_stack_frame);
// Read off the optimized code slot in the closure's feedback vector, and if
// there is optimized code or an optimization marker, call that instead.
MaybeTailCallOptimizedCodeSlot(masm, ecx);
// Load the feedback vector and increment the invocation count.
Register feedback_vector = ecx;
__ mov(feedback_vector,
FieldOperand(closure, JSFunction::kFeedbackCellOffset));
__ mov(feedback_vector, FieldOperand(feedback_vector, Cell::kValueOffset));
@ -837,6 +847,7 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// Open a frame scope to indicate that there is a frame on the stack. The
// MANUAL indicates that the scope shouldn't actually generate code to set
// up the frame (that is done below).
__ bind(&push_stack_frame);
FrameScope frame_scope(masm, StackFrame::MANUAL);
__ push(ebp); // Caller's frame pointer.
__ mov(ebp, esp);

18
src/builtins/x64/builtins-x64.cc
View File

@ -723,6 +723,9 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
Smi::FromEnum(OptimizationMarker::kNone));
__ j(equal, &fallthrough);
// TODO(v8:8394): The logging of first execution will break if
// feedback vectors are not allocated. We need to find a different way of
// logging these events if required.
TailCallRuntimeIfMarkerEquals(masm, optimized_code_entry,
OptimizationMarker::kLogFirstExecution,
Runtime::kFunctionFirstExecution);
@ -863,13 +866,24 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
__ movp(feedback_vector,
FieldOperand(closure, JSFunction::kFeedbackCellOffset));
__ movp(feedback_vector, FieldOperand(feedback_vector, Cell::kValueOffset));
Label push_stack_frame;
// Check if feedback vector is valid. If valid, check for optimized code
// and update invocation count. Otherwise, setup the stack frame.
__ JumpIfRoot(feedback_vector, RootIndex::kUndefinedValue, &push_stack_frame);
// Read off the optimized code slot in the feedback vector, and if there
// is optimized code or an optimization marker, call that instead.
MaybeTailCallOptimizedCodeSlot(masm, feedback_vector, rcx, r14, r15);
// Increment invocation count for the function.
__ incl(
FieldOperand(feedback_vector, FeedbackVector::kInvocationCountOffset));
// Open a frame scope to indicate that there is a frame on the stack. The
// MANUAL indicates that the scope shouldn't actually generate code to set up
// the frame (that is done below).
__ bind(&push_stack_frame);
FrameScope frame_scope(masm, StackFrame::MANUAL);
__ pushq(rbp); // Caller's frame pointer.
__ movp(rbp, rsp);
@ -884,10 +898,6 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
GetSharedFunctionInfoBytecode(masm, kInterpreterBytecodeArrayRegister,
kScratchRegister);
// Increment invocation count for the function.
__ incl(
FieldOperand(feedback_vector, FeedbackVector::kInvocationCountOffset));
// Check function data field is actually a BytecodeArray object.
if (FLAG_debug_code) {
__ AssertNotSmi(kInterpreterBytecodeArrayRegister);

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

@ -71,6 +71,7 @@ enum class PrimitiveType { kBoolean, kNumber, kString, kSymbol };
V(MutableHeapNumberMap, mutable_heap_number_map, MutableHeapNumberMap) \
V(NanValue, nan_value, Nan) \
V(NoClosuresCellMap, no_closures_cell_map, NoClosuresCellMap) \
V(NoFeedbackCellMap, no_feedback_cell_map, NoFeedbackCellMap) \
V(NullValue, null_value, Null) \
V(OneClosureCellMap, one_closure_cell_map, OneClosureCellMap) \
V(PreParsedScopeDataMap, pre_parsed_scope_data_map, PreParsedScopeDataMap) \

4
src/compiler.cc
View File

@ -2019,7 +2019,9 @@ void Compiler::PostInstantiation(Handle<JSFunction> function,
if (shared->is_compiled() && !shared->HasAsmWasmData()) {
JSFunction::EnsureFeedbackVector(function);
Code code = function->feedback_vector()->optimized_code();
Code code = function->has_feedback_vector()
? function->feedback_vector()->optimized_code()
: Code();
if (!code.is_null()) {
// Caching of optimized code enabled and optimized code found.
DCHECK(!code->marked_for_deoptimization());

14
src/heap/factory.cc
View File

@ -1802,6 +1802,17 @@ Handle<FeedbackCell> Factory::NewManyClosuresCell(Handle<HeapObject> value) {
return cell;
}
Handle<FeedbackCell> Factory::NewNoFeedbackCell() {
AllowDeferredHandleDereference convert_to_cell;
HeapObject* result = AllocateRawWithImmortalMap(FeedbackCell::kSize, TENURED,
*no_feedback_cell_map());
Handle<FeedbackCell> cell(FeedbackCell::cast(result), isolate());
// Set the value to undefined. We wouldn't allocate feedback vectors with
// NoFeedbackCell map type.
cell->set_value(*undefined_value());
return cell;
}
Handle<PropertyCell> Factory::NewPropertyCell(Handle<Name> name,
PretenureFlag pretenure) {
DCHECK(name->IsUniqueName());
@ -2501,7 +2512,8 @@ Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
} else if (feedback_cell->map() == *one_closure_cell_map()) {
feedback_cell->set_map(*many_closures_cell_map());
} else {
DCHECK_EQ(feedback_cell->map(), *many_closures_cell_map());
DCHECK(feedback_cell->map() == *no_feedback_cell_map() ||
feedback_cell->map() == *many_closures_cell_map());
}
// Check that the optimized code in the feedback cell wasn't marked for

1
src/heap/factory.h
View File

@ -481,6 +481,7 @@ class V8_EXPORT_PRIVATE Factory {
Handle<FeedbackCell> NewNoClosuresCell(Handle<HeapObject> value);
Handle<FeedbackCell> NewOneClosureCell(Handle<HeapObject> value);
Handle<FeedbackCell> NewManyClosuresCell(Handle<HeapObject> value);
Handle<FeedbackCell> NewNoFeedbackCell();
Handle<TransitionArray> NewTransitionArray(int number_of_transitions,
int slack = 0);

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

@ -444,6 +444,8 @@ bool Heap::CreateInitialMaps() {
ALLOCATE_MAP(FEEDBACK_CELL_TYPE, FeedbackCell::kSize, one_closure_cell)
roots.one_closure_cell_map()->mark_unstable();
ALLOCATE_MAP(FEEDBACK_CELL_TYPE, FeedbackCell::kSize, many_closures_cell)
ALLOCATE_MAP(FEEDBACK_CELL_TYPE, FeedbackCell::kSize, no_feedback_cell)
roots.no_feedback_cell_map()->mark_unstable();
ALLOCATE_VARSIZE_MAP(TRANSITION_ARRAY_TYPE, transition_array)
@ -769,6 +771,10 @@ void Heap::CreateInitialObjects() {
factory->NewManyClosuresCell(factory->undefined_value());
set_many_closures_cell(*many_closures_cell);
// Allocate FeedbackCell for cases where we don't collect feedback.
Handle<FeedbackCell> no_feedback_cell = factory->NewNoFeedbackCell();
set_no_feedback_cell(*no_feedback_cell);
set_default_microtask_queue(*factory->NewMicrotaskQueue());
{

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

@ -2559,18 +2559,30 @@ IGNITION_HANDLER(CreateClosure, InterpreterAssembler) {
Node* flags = BytecodeOperandFlag(2);
Node* context = GetContext();
Node* slot = BytecodeOperandIdx(1);
Node* feedback_vector = LoadFeedbackVector();
TNode<Object> feedback_cell =
CAST(LoadFeedbackVectorSlot(feedback_vector, slot));
Label if_undefined(this), load_feedback_done(this);
Variable feedback_cell(this, MachineRepresentation::kTagged);
Node* feedback_vector = LoadFeedbackVectorUnchecked();
GotoIf(IsUndefined(feedback_vector), &if_undefined);
feedback_cell.Bind(LoadFeedbackVectorSlot(feedback_vector, slot));
Goto(&load_feedback_done);
BIND(&if_undefined);
{
feedback_cell.Bind(LoadRoot(RootIndex::kNoFeedbackCell));
Goto(&load_feedback_done);
}
BIND(&load_feedback_done);
Label if_fast(this), if_slow(this, Label::kDeferred);
Branch(IsSetWord32<CreateClosureFlags::FastNewClosureBit>(flags), &if_fast,
&if_slow);
BIND(&if_fast);
{
Node* result =
CallBuiltin(Builtins::kFastNewClosure, context, shared, feedback_cell);
Node* result = CallBuiltin(Builtins::kFastNewClosure, context, shared,
feedback_cell.value());
SetAccumulator(result);
Dispatch();
}
@ -2583,8 +2595,8 @@ IGNITION_HANDLER(CreateClosure, InterpreterAssembler) {
BIND(&if_newspace);
{
Node* result =
CallRuntime(Runtime::kNewClosure, context, shared, feedback_cell);
Node* result = CallRuntime(Runtime::kNewClosure, context, shared,
feedback_cell.value());
SetAccumulator(result);
Dispatch();
}
@ -2592,7 +2604,7 @@ IGNITION_HANDLER(CreateClosure, InterpreterAssembler) {
BIND(&if_oldspace);
{
Node* result = CallRuntime(Runtime::kNewClosure_Tenured, context, shared,
feedback_cell);
feedback_cell.value());
SetAccumulator(result);
Dispatch();
}

2
src/objects.cc
View File

@ -3536,6 +3536,8 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) { // NOLINT
ReadOnlyRoots roots = GetReadOnlyRoots();
os << "<FeedbackCell[";
if (map() == roots.no_closures_cell_map()) {
os << "no feedback";
} else if (map() == roots.no_closures_cell_map()) {
os << "no closures";
} else if (map() == roots.one_closure_cell_map()) {
os << "one closure";

2
src/roots.h
View File

@ -95,6 +95,7 @@ class RootVisitor;
V(Map, mutable_heap_number_map, MutableHeapNumberMap) \
V(Map, name_dictionary_map, NameDictionaryMap) \
V(Map, no_closures_cell_map, NoClosuresCellMap) \
V(Map, no_feedback_cell_map, NoFeedbackCellMap) \
V(Map, number_dictionary_map, NumberDictionaryMap) \
V(Map, one_closure_cell_map, OneClosureCellMap) \
V(Map, ordered_hash_map_map, OrderedHashMapMap) \
@ -232,6 +233,7 @@ class RootVisitor;
/* Canonical empty values */ \
V(Script*, empty_script, EmptyScript) \
V(FeedbackCell*, many_closures_cell, ManyClosuresCell) \
V(FeedbackCell*, no_feedback_cell, NoFeedbackCell) \
V(Cell*, invalid_prototype_validity_cell, InvalidPrototypeValidityCell) \
/* Protectors */ \
V(Cell*, array_constructor_protector, ArrayConstructorProtector) \

2
src/runtime-profiler.cc
View File

@ -241,6 +241,8 @@ void RuntimeProfiler::MarkCandidatesForOptimization() {
DCHECK(function->shared()->is_compiled());
if (!function->shared()->IsInterpreted()) continue;
if (!function->has_feedback_vector()) continue;
MaybeOptimize(function, InterpretedFrame::cast(frame));
// TODO(leszeks): Move this increment to before the maybe optimize checks,

27
src/runtime/runtime-scopes.cc
View File

@ -154,16 +154,23 @@ Object* DeclareGlobals(Isolate* isolate, Handle<FixedArray> declarations,
Handle<Object> value;
if (is_function) {
DCHECK(possibly_feedback_cell_slot->IsSmi());
// If feedback vector was not allocated for this function, then we don't
// have any information about number of closures. Use NoFeedbackCell to
// indicate that.
Handle<FeedbackCell> feedback_cell =
isolate->factory()->no_feedback_cell();
if (!feedback_vector.is_null()) {
DCHECK(possibly_feedback_cell_slot->IsSmi());
FeedbackSlot feedback_cells_slot(
Smi::ToInt(*possibly_feedback_cell_slot));
feedback_cell = Handle<FeedbackCell>(
FeedbackCell::cast(feedback_vector->Get(feedback_cells_slot)
->GetHeapObjectAssumeStrong()),
isolate);
}
// Copy the function and update its context. Use it as value.
Handle<SharedFunctionInfo> shared =
Handle<SharedFunctionInfo>::cast(initial_value);
FeedbackSlot feedback_cells_slot(
Smi::ToInt(*possibly_feedback_cell_slot));
Handle<FeedbackCell> feedback_cell(
FeedbackCell::cast(feedback_vector->Get(feedback_cells_slot)
->GetHeapObjectAssumeStrong()),
isolate);
Handle<JSFunction> function =
isolate->factory()->NewFunctionFromSharedFunctionInfo(
shared, context, feedback_cell, TENURED);
@ -202,7 +209,11 @@ RUNTIME_FUNCTION(Runtime_DeclareGlobals) {
CONVERT_SMI_ARG_CHECKED(flags, 1);
CONVERT_ARG_HANDLE_CHECKED(JSFunction, closure, 2);
Handle<FeedbackVector> feedback_vector(closure->feedback_vector(), isolate);
Handle<FeedbackVector> feedback_vector = Handle<FeedbackVector>();
if (closure->has_feedback_vector()) {
feedback_vector =
Handle<FeedbackVector>(closure->feedback_vector(), isolate);
}
return DeclareGlobals(isolate, declarations, flags, feedback_vector);
}

292
tools/v8heapconst.py
View File

@ -247,99 +247,100 @@ KNOWN_MAPS = {
("RO_SPACE", 0x015a1): (134, "MutableHeapNumberMap"),
("RO_SPACE", 0x015f1): (191, "NameDictionaryMap"),
("RO_SPACE", 0x01641): (215, "NoClosuresCellMap"),
("RO_SPACE", 0x01691): (193, "NumberDictionaryMap"),
("RO_SPACE", 0x016e1): (215, "OneClosureCellMap"),
("RO_SPACE", 0x01731): (188, "OrderedHashMapMap"),
("RO_SPACE", 0x01781): (189, "OrderedHashSetMap"),
("RO_SPACE", 0x017d1): (190, "OrderedNameDictionaryMap"),
("RO_SPACE", 0x01821): (218, "PreParsedScopeDataMap"),
("RO_SPACE", 0x01871): (219, "PropertyArrayMap"),
("RO_SPACE", 0x018c1): (212, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x01911): (212, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x01961): (212, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x019b1): (194, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x01a01): (185, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x01a51): (222, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x01aa1): (223, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x01af1): (224, "SmallOrderedNameDictionaryMap"),
("RO_SPACE", 0x01b41): (195, "StringTableMap"),
("RO_SPACE", 0x01b91): (226, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x01be1): (227, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x01c31): (228, "WeakArrayListMap"),
("RO_SPACE", 0x01c81): (196, "EphemeronHashTableMap"),
("RO_SPACE", 0x01cd1): (184, "EmbedderDataArrayMap"),
("RO_SPACE", 0x01d21): (106, "NativeSourceStringMap"),
("RO_SPACE", 0x01d71): (64, "StringMap"),
("RO_SPACE", 0x01dc1): (73, "ConsOneByteStringMap"),
("RO_SPACE", 0x01e11): (65, "ConsStringMap"),
("RO_SPACE", 0x01e61): (77, "ThinOneByteStringMap"),
("RO_SPACE", 0x01eb1): (69, "ThinStringMap"),
("RO_SPACE", 0x01f01): (67, "SlicedStringMap"),
("RO_SPACE", 0x01f51): (75, "SlicedOneByteStringMap"),
("RO_SPACE", 0x01fa1): (66, "ExternalStringMap"),
("RO_SPACE", 0x01ff1): (82, "ExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x02041): (74, "ExternalOneByteStringMap"),
("RO_SPACE", 0x02091): (98, "UncachedExternalStringMap"),
("RO_SPACE", 0x020e1): (114, "UncachedExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x02131): (0, "InternalizedStringMap"),
("RO_SPACE", 0x02181): (2, "ExternalInternalizedStringMap"),
("RO_SPACE", 0x021d1): (18, "ExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x02221): (10, "ExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x02271): (34, "UncachedExternalInternalizedStringMap"),
("RO_SPACE", 0x022c1): (50, "UncachedExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x02311): (42, "UncachedExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x02361): (106, "UncachedExternalOneByteStringMap"),
("RO_SPACE", 0x023b1): (140, "FixedUint8ArrayMap"),
("RO_SPACE", 0x02401): (139, "FixedInt8ArrayMap"),
("RO_SPACE", 0x02451): (142, "FixedUint16ArrayMap"),
("RO_SPACE", 0x024a1): (141, "FixedInt16ArrayMap"),
("RO_SPACE", 0x024f1): (144, "FixedUint32ArrayMap"),
("RO_SPACE", 0x02541): (143, "FixedInt32ArrayMap"),
("RO_SPACE", 0x02591): (145, "FixedFloat32ArrayMap"),
("RO_SPACE", 0x025e1): (146, "FixedFloat64ArrayMap"),
("RO_SPACE", 0x02631): (147, "FixedUint8ClampedArrayMap"),
("RO_SPACE", 0x02681): (149, "FixedBigUint64ArrayMap"),
("RO_SPACE", 0x026d1): (148, "FixedBigInt64ArrayMap"),
("RO_SPACE", 0x02721): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x02789): (171, "Tuple2Map"),
("RO_SPACE", 0x02829): (173, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x02b69): (161, "InterceptorInfoMap"),
("RO_SPACE", 0x05089): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x050d9): (154, "AccessorInfoMap"),
("RO_SPACE", 0x05129): (155, "AccessorPairMap"),
("RO_SPACE", 0x05179): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x051c9): (157, "AllocationMementoMap"),
("RO_SPACE", 0x05219): (158, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x05269): (159, "DebugInfoMap"),
("RO_SPACE", 0x052b9): (160, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x05309): (162, "InterpreterDataMap"),
("RO_SPACE", 0x05359): (163, "ModuleInfoEntryMap"),
("RO_SPACE", 0x053a9): (164, "ModuleMap"),
("RO_SPACE", 0x053f9): (165, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x05449): (166, "PromiseCapabilityMap"),
("RO_SPACE", 0x05499): (167, "PromiseReactionMap"),
("RO_SPACE", 0x054e9): (168, "PrototypeInfoMap"),
("RO_SPACE", 0x05539): (169, "ScriptMap"),
("RO_SPACE", 0x05589): (170, "StackFrameInfoMap"),
("RO_SPACE", 0x055d9): (172, "Tuple3Map"),
("RO_SPACE", 0x05629): (174, "WasmDebugInfoMap"),
("RO_SPACE", 0x05679): (175, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x056c9): (176, "CallableTaskMap"),
("RO_SPACE", 0x05719): (177, "CallbackTaskMap"),
("RO_SPACE", 0x05769): (178, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x057b9): (179, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x05809): (180, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x05859): (181, "WeakFactoryCleanupJobTaskMap"),
("RO_SPACE", 0x058a9): (182, "MicrotaskQueueMap"),
("RO_SPACE", 0x058f9): (183, "AllocationSiteWithWeakNextMap"),
("RO_SPACE", 0x05949): (183, "AllocationSiteWithoutWeakNextMap"),
("RO_SPACE", 0x05999): (217, "LoadHandler1Map"),
("RO_SPACE", 0x059e9): (217, "LoadHandler2Map"),
("RO_SPACE", 0x05a39): (217, "LoadHandler3Map"),
("RO_SPACE", 0x05a89): (225, "StoreHandler0Map"),
("RO_SPACE", 0x05ad9): (225, "StoreHandler1Map"),
("RO_SPACE", 0x05b29): (225, "StoreHandler2Map"),
("RO_SPACE", 0x05b79): (225, "StoreHandler3Map"),
("RO_SPACE", 0x01691): (215, "NoFeedbackCellMap"),
("RO_SPACE", 0x016e1): (193, "NumberDictionaryMap"),
("RO_SPACE", 0x01731): (215, "OneClosureCellMap"),
("RO_SPACE", 0x01781): (188, "OrderedHashMapMap"),
("RO_SPACE", 0x017d1): (189, "OrderedHashSetMap"),
("RO_SPACE", 0x01821): (190, "OrderedNameDictionaryMap"),
("RO_SPACE", 0x01871): (218, "PreParsedScopeDataMap"),
("RO_SPACE", 0x018c1): (219, "PropertyArrayMap"),
("RO_SPACE", 0x01911): (212, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x01961): (212, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x019b1): (212, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x01a01): (194, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x01a51): (185, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x01aa1): (222, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x01af1): (223, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x01b41): (224, "SmallOrderedNameDictionaryMap"),
("RO_SPACE", 0x01b91): (195, "StringTableMap"),
("RO_SPACE", 0x01be1): (226, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x01c31): (227, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x01c81): (228, "WeakArrayListMap"),
("RO_SPACE", 0x01cd1): (196, "EphemeronHashTableMap"),
("RO_SPACE", 0x01d21): (184, "EmbedderDataArrayMap"),
("RO_SPACE", 0x01d71): (106, "NativeSourceStringMap"),
("RO_SPACE", 0x01dc1): (64, "StringMap"),
("RO_SPACE", 0x01e11): (73, "ConsOneByteStringMap"),
("RO_SPACE", 0x01e61): (65, "ConsStringMap"),
("RO_SPACE", 0x01eb1): (77, "ThinOneByteStringMap"),
("RO_SPACE", 0x01f01): (69, "ThinStringMap"),
("RO_SPACE", 0x01f51): (67, "SlicedStringMap"),
("RO_SPACE", 0x01fa1): (75, "SlicedOneByteStringMap"),
("RO_SPACE", 0x01ff1): (66, "ExternalStringMap"),
("RO_SPACE", 0x02041): (82, "ExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x02091): (74, "ExternalOneByteStringMap"),
("RO_SPACE", 0x020e1): (98, "UncachedExternalStringMap"),
("RO_SPACE", 0x02131): (114, "UncachedExternalStringWithOneByteDataMap"),
("RO_SPACE", 0x02181): (0, "InternalizedStringMap"),
("RO_SPACE", 0x021d1): (2, "ExternalInternalizedStringMap"),
("RO_SPACE", 0x02221): (18, "ExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x02271): (10, "ExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x022c1): (34, "UncachedExternalInternalizedStringMap"),
("RO_SPACE", 0x02311): (50, "UncachedExternalInternalizedStringWithOneByteDataMap"),
("RO_SPACE", 0x02361): (42, "UncachedExternalOneByteInternalizedStringMap"),
("RO_SPACE", 0x023b1): (106, "UncachedExternalOneByteStringMap"),
("RO_SPACE", 0x02401): (140, "FixedUint8ArrayMap"),
("RO_SPACE", 0x02451): (139, "FixedInt8ArrayMap"),
("RO_SPACE", 0x024a1): (142, "FixedUint16ArrayMap"),
("RO_SPACE", 0x024f1): (141, "FixedInt16ArrayMap"),
("RO_SPACE", 0x02541): (144, "FixedUint32ArrayMap"),
("RO_SPACE", 0x02591): (143, "FixedInt32ArrayMap"),
("RO_SPACE", 0x025e1): (145, "FixedFloat32ArrayMap"),
("RO_SPACE", 0x02631): (146, "FixedFloat64ArrayMap"),
("RO_SPACE", 0x02681): (147, "FixedUint8ClampedArrayMap"),
("RO_SPACE", 0x026d1): (149, "FixedBigUint64ArrayMap"),
("RO_SPACE", 0x02721): (148, "FixedBigInt64ArrayMap"),
("RO_SPACE", 0x02771): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x027d9): (171, "Tuple2Map"),
("RO_SPACE", 0x02879): (173, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x02bb9): (161, "InterceptorInfoMap"),
("RO_SPACE", 0x050d9): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x05129): (154, "AccessorInfoMap"),
("RO_SPACE", 0x05179): (155, "AccessorPairMap"),
("RO_SPACE", 0x051c9): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x05219): (157, "AllocationMementoMap"),
("RO_SPACE", 0x05269): (158, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x052b9): (159, "DebugInfoMap"),
("RO_SPACE", 0x05309): (160, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x05359): (162, "InterpreterDataMap"),
("RO_SPACE", 0x053a9): (163, "ModuleInfoEntryMap"),
("RO_SPACE", 0x053f9): (164, "ModuleMap"),
("RO_SPACE", 0x05449): (165, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x05499): (166, "PromiseCapabilityMap"),
("RO_SPACE", 0x054e9): (167, "PromiseReactionMap"),
("RO_SPACE", 0x05539): (168, "PrototypeInfoMap"),
("RO_SPACE", 0x05589): (169, "ScriptMap"),
("RO_SPACE", 0x055d9): (170, "StackFrameInfoMap"),
("RO_SPACE", 0x05629): (172, "Tuple3Map"),
("RO_SPACE", 0x05679): (174, "WasmDebugInfoMap"),
("RO_SPACE", 0x056c9): (175, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x05719): (176, "CallableTaskMap"),
("RO_SPACE", 0x05769): (177, "CallbackTaskMap"),
("RO_SPACE", 0x057b9): (178, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x05809): (179, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x05859): (180, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x058a9): (181, "WeakFactoryCleanupJobTaskMap"),
("RO_SPACE", 0x058f9): (182, "MicrotaskQueueMap"),
("RO_SPACE", 0x05949): (183, "AllocationSiteWithWeakNextMap"),
("RO_SPACE", 0x05999): (183, "AllocationSiteWithoutWeakNextMap"),
("RO_SPACE", 0x059e9): (217, "LoadHandler1Map"),
("RO_SPACE", 0x05a39): (217, "LoadHandler2Map"),
("RO_SPACE", 0x05a89): (217, "LoadHandler3Map"),
("RO_SPACE", 0x05ad9): (225, "StoreHandler0Map"),
("RO_SPACE", 0x05b29): (225, "StoreHandler1Map"),
("RO_SPACE", 0x05b79): (225, "StoreHandler2Map"),
("RO_SPACE", 0x05bc9): (225, "StoreHandler3Map"),
("MAP_SPACE", 0x00139): (1057, "ExternalMap"),
("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"),
}
@ -364,37 +365,37 @@ KNOWN_OBJECTS = {
("RO_SPACE", 0x00d79): "TerminationException",
("RO_SPACE", 0x00e21): "OptimizedOut",
("RO_SPACE", 0x00ec1): "StaleRegister",
("RO_SPACE", 0x02771): "EmptyEnumCache",
("RO_SPACE", 0x027d9): "EmptyPropertyArray",
("RO_SPACE", 0x027e9): "EmptyByteArray",
("RO_SPACE", 0x027f9): "EmptyObjectBoilerplateDescription",
("RO_SPACE", 0x02811): "EmptyArrayBoilerplateDescription",
("RO_SPACE", 0x02879): "EmptyFixedUint8Array",
("RO_SPACE", 0x02899): "EmptyFixedInt8Array",
("RO_SPACE", 0x028b9): "EmptyFixedUint16Array",
("RO_SPACE", 0x028d9): "EmptyFixedInt16Array",
("RO_SPACE", 0x028f9): "EmptyFixedUint32Array",
("RO_SPACE", 0x02919): "EmptyFixedInt32Array",
("RO_SPACE", 0x02939): "EmptyFixedFloat32Array",
("RO_SPACE", 0x02959): "EmptyFixedFloat64Array",
("RO_SPACE", 0x02979): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x02999): "EmptyFixedBigUint64Array",
("RO_SPACE", 0x029b9): "EmptyFixedBigInt64Array",
("RO_SPACE", 0x029d9): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x029f9): "EmptySlowElementDictionary",
("RO_SPACE", 0x02a41): "EmptyOrderedHashMap",
("RO_SPACE", 0x02a69): "EmptyOrderedHashSet",
("RO_SPACE", 0x02a91): "EmptyFeedbackMetadata",
("RO_SPACE", 0x02aa1): "EmptyPropertyCell",
("RO_SPACE", 0x02ac9): "EmptyPropertyDictionary",
("RO_SPACE", 0x02b19): "NoOpInterceptorInfo",
("RO_SPACE", 0x02bb9): "EmptyWeakArrayList",
("RO_SPACE", 0x02bd1): "InfinityValue",
("RO_SPACE", 0x02be1): "MinusZeroValue",
("RO_SPACE", 0x02bf1): "MinusInfinityValue",
("RO_SPACE", 0x02c01): "SelfReferenceMarker",
("RO_SPACE", 0x02c59): "OffHeapTrampolineRelocationInfo",
("RO_SPACE", 0x02c71): "HashSeed",
("RO_SPACE", 0x027c1): "EmptyEnumCache",
("RO_SPACE", 0x02829): "EmptyPropertyArray",
("RO_SPACE", 0x02839): "EmptyByteArray",
("RO_SPACE", 0x02849): "EmptyObjectBoilerplateDescription",
("RO_SPACE", 0x02861): "EmptyArrayBoilerplateDescription",
("RO_SPACE", 0x028c9): "EmptyFixedUint8Array",
("RO_SPACE", 0x028e9): "EmptyFixedInt8Array",
("RO_SPACE", 0x02909): "EmptyFixedUint16Array",
("RO_SPACE", 0x02929): "EmptyFixedInt16Array",
("RO_SPACE", 0x02949): "EmptyFixedUint32Array",
("RO_SPACE", 0x02969): "EmptyFixedInt32Array",
("RO_SPACE", 0x02989): "EmptyFixedFloat32Array",
("RO_SPACE", 0x029a9): "EmptyFixedFloat64Array",
("RO_SPACE", 0x029c9): "EmptyFixedUint8ClampedArray",
("RO_SPACE", 0x029e9): "EmptyFixedBigUint64Array",
("RO_SPACE", 0x02a09): "EmptyFixedBigInt64Array",
("RO_SPACE", 0x02a29): "EmptySloppyArgumentsElements",
("RO_SPACE", 0x02a49): "EmptySlowElementDictionary",
("RO_SPACE", 0x02a91): "EmptyOrderedHashMap",
("RO_SPACE", 0x02ab9): "EmptyOrderedHashSet",
("RO_SPACE", 0x02ae1): "EmptyFeedbackMetadata",
("RO_SPACE", 0x02af1): "EmptyPropertyCell",
("RO_SPACE", 0x02b19): "EmptyPropertyDictionary",
("RO_SPACE", 0x02b69): "NoOpInterceptorInfo",
("RO_SPACE", 0x02c09): "EmptyWeakArrayList",
("RO_SPACE", 0x02c21): "InfinityValue",
("RO_SPACE", 0x02c31): "MinusZeroValue",
("RO_SPACE", 0x02c41): "MinusInfinityValue",
("RO_SPACE", 0x02c51): "SelfReferenceMarker",
("RO_SPACE", 0x02ca9): "OffHeapTrampolineRelocationInfo",
("RO_SPACE", 0x02cc1): "HashSeed",
("OLD_SPACE", 0x00139): "ArgumentsIteratorAccessor",
("OLD_SPACE", 0x001a9): "ArrayLengthAccessor",
("OLD_SPACE", 0x00219): "BoundFunctionLengthAccessor",
@ -409,27 +410,28 @@ 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): "ArrayBufferNeuteringProtector",
("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): "DefaultMicrotaskQueue",
("OLD_SPACE", 0x02111): "BuiltinsConstantsTable",
("OLD_SPACE", 0x006a9): "NoFeedbackCell",
("OLD_SPACE", 0x006b9): "ArrayConstructorProtector",
("OLD_SPACE", 0x006c9): "NoElementsProtector",
("OLD_SPACE", 0x006f1): "IsConcatSpreadableProtector",
("OLD_SPACE", 0x00701): "ArraySpeciesProtector",
("OLD_SPACE", 0x00729): "TypedArraySpeciesProtector",
("OLD_SPACE", 0x00751): "RegExpSpeciesProtector",
("OLD_SPACE", 0x00779): "PromiseSpeciesProtector",
("OLD_SPACE", 0x007a1): "StringLengthProtector",
("OLD_SPACE", 0x007b1): "ArrayIteratorProtector",
("OLD_SPACE", 0x007d9): "ArrayBufferNeuteringProtector",
("OLD_SPACE", 0x00801): "PromiseHookProtector",
("OLD_SPACE", 0x00829): "PromiseResolveProtector",
("OLD_SPACE", 0x00839): "MapIteratorProtector",
("OLD_SPACE", 0x00861): "PromiseThenProtector",
("OLD_SPACE", 0x00889): "SetIteratorProtector",
("OLD_SPACE", 0x008b1): "StringIteratorProtector",
("OLD_SPACE", 0x008d9): "SingleCharacterStringCache",
("OLD_SPACE", 0x010e9): "StringSplitCache",
("OLD_SPACE", 0x018f9): "RegExpMultipleCache",
("OLD_SPACE", 0x02109): "DefaultMicrotaskQueue",
("OLD_SPACE", 0x02121): "BuiltinsConstantsTable",
}
# List of known V8 Frame Markers.