diff --git a/src/diagnostics/objects-debug.cc b/src/diagnostics/objects-debug.cc index 324ecacd46..eb9e4c4ac1 100644 --- a/src/diagnostics/objects-debug.cc +++ b/src/diagnostics/objects-debug.cc @@ -827,7 +827,7 @@ void SharedFunctionInfo::SharedFunctionInfoVerify(LocalIsolate* isolate) { void SharedFunctionInfo::SharedFunctionInfoVerify(ReadOnlyRoots roots) { Object value = name_or_scope_info(kAcquireLoad); if (value.IsScopeInfo()) { - CHECK_LT(0, ScopeInfo::cast(value).length()); + CHECK(!ScopeInfo::cast(value).IsEmpty()); CHECK_NE(value, roots.empty_scope_info()); } @@ -855,7 +855,7 @@ void SharedFunctionInfo::SharedFunctionInfoVerify(ReadOnlyRoots roots) { language_mode(), kind(), HasSharedName(), needs_home_object()); CHECK_EQ(expected_map_index, function_map_index()); - if (scope_info().length() > 0) { + if (!scope_info().IsEmpty()) { ScopeInfo info = scope_info(); CHECK(kind() == info.function_kind()); CHECK_EQ(internal::IsModule(kind()), info.scope_type() == MODULE_SCOPE); diff --git a/src/heap/setup-heap-internal.cc b/src/heap/setup-heap-internal.cc index 0ed2fbea84..030f38fd2c 100644 --- a/src/heap/setup-heap-internal.cc +++ b/src/heap/setup-heap-internal.cc @@ -528,10 +528,20 @@ bool Heap::CreateInitialMaps() { { AllocationResult alloc = - AllocateRaw(FixedArray::SizeFor(0), AllocationType::kReadOnly); + AllocateRaw(FixedArray::SizeFor(ScopeInfo::kVariablePartIndex), + AllocationType::kReadOnly); if (!alloc.To(&obj)) return false; obj.set_map_after_allocation(roots.scope_info_map(), SKIP_WRITE_BARRIER); - FixedArray::cast(obj).set_length(0); + FixedArray::cast(obj).set_length(ScopeInfo::kVariablePartIndex); + int flags = ScopeInfo::IsEmptyBit::encode(true); + DCHECK_EQ(ScopeInfo::LanguageModeBit::decode(flags), LanguageMode::kSloppy); + DCHECK_EQ(ScopeInfo::ReceiverVariableBits::decode(flags), + VariableAllocationInfo::NONE); + DCHECK_EQ(ScopeInfo::FunctionVariableBits::decode(flags), + VariableAllocationInfo::NONE); + ScopeInfo::cast(obj).SetFlags(flags); + ScopeInfo::cast(obj).SetContextLocalCount(0); + ScopeInfo::cast(obj).SetParameterCount(0); } set_empty_scope_info(ScopeInfo::cast(obj)); diff --git a/src/objects/objects-inl.h b/src/objects/objects-inl.h index 5ac543cb44..56c311b961 100644 --- a/src/objects/objects-inl.h +++ b/src/objects/objects-inl.h @@ -1129,11 +1129,8 @@ bool ScopeInfo::HasSimpleParameters() const { #define FIELD_ACCESSORS(name) \ void ScopeInfo::Set##name(int value) { set(k##name, Smi::FromInt(value)); } \ int ScopeInfo::name() const { \ - if (length() > 0) { \ - return Smi::ToInt(get(k##name)); \ - } else { \ - return 0; \ - } \ + DCHECK_GE(length(), kVariablePartIndex); \ + return Smi::ToInt(get(k##name)); \ } FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(FIELD_ACCESSORS) #undef FIELD_ACCESSORS diff --git a/src/objects/objects.cc b/src/objects/objects.cc index f017a7706a..520955b51d 100644 --- a/src/objects/objects.cc +++ b/src/objects/objects.cc @@ -2077,8 +2077,8 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) { // NOLINT case SCOPE_INFO_TYPE: { ScopeInfo scope = ScopeInfo::cast(*this); os << ""; + if (!scope.IsEmpty()) os << " " << scope.scope_type(); + os << ">"; break; } case CODE_TYPE: { diff --git a/src/objects/scope-info.cc b/src/objects/scope-info.cc index 03a2aeee0b..bd6fd3cb0b 100644 --- a/src/objects/scope-info.cc +++ b/src/objects/scope-info.cc @@ -588,26 +588,27 @@ ScopeInfo ScopeInfo::Empty(Isolate* isolate) { return ReadOnlyRoots(isolate).empty_scope_info(); } +bool ScopeInfo::IsEmpty() const { return IsEmptyBit::decode(Flags()); } + ScopeType ScopeInfo::scope_type() const { - DCHECK_LT(0, length()); + DCHECK(!IsEmpty()); return ScopeTypeBits::decode(Flags()); } bool ScopeInfo::is_script_scope() const { - return length() > 0 && scope_type() == SCRIPT_SCOPE; + return !IsEmpty() && scope_type() == SCRIPT_SCOPE; } bool ScopeInfo::SloppyEvalCanExtendVars() const { bool sloppy_eval_can_extend_vars = - length() > 0 && SloppyEvalCanExtendVarsBit::decode(Flags()); + SloppyEvalCanExtendVarsBit::decode(Flags()); DCHECK_IMPLIES(sloppy_eval_can_extend_vars, is_sloppy(language_mode())); DCHECK_IMPLIES(sloppy_eval_can_extend_vars, is_declaration_scope()); return sloppy_eval_can_extend_vars; } LanguageMode ScopeInfo::language_mode() const { - return length() > 0 ? LanguageModeBit::decode(Flags()) - : LanguageMode::kSloppy; + return LanguageModeBit::decode(Flags()); } bool ScopeInfo::is_declaration_scope() const { @@ -615,7 +616,7 @@ bool ScopeInfo::is_declaration_scope() const { } int ScopeInfo::ContextLength() const { - if (length() > 0) { + if (!IsEmpty()) { int context_locals = ContextLocalCount(); bool function_name_context_slot = FunctionVariableBits::decode(Flags()) == VariableAllocationInfo::CONTEXT; @@ -647,12 +648,10 @@ int ScopeInfo::ContextHeaderLength() const { } bool ScopeInfo::HasReceiver() const { - if (length() == 0) return false; return VariableAllocationInfo::NONE != ReceiverVariableBits::decode(Flags()); } bool ScopeInfo::HasAllocatedReceiver() const { - if (length() == 0) return false; VariableAllocationInfo allocation = ReceiverVariableBits::decode(Flags()); return allocation == VariableAllocationInfo::STACK || allocation == VariableAllocationInfo::CONTEXT; @@ -671,17 +670,15 @@ bool ScopeInfo::HasNewTarget() const { } bool ScopeInfo::HasFunctionName() const { - if (length() == 0) return false; return VariableAllocationInfo::NONE != FunctionVariableBits::decode(Flags()); } bool ScopeInfo::HasInferredFunctionName() const { - if (length() == 0) return false; return HasInferredFunctionNameBit::decode(Flags()); } bool ScopeInfo::HasPositionInfo() const { - if (length() == 0) return false; + if (IsEmpty()) return false; return NeedsPositionInfo(scope_type()); } @@ -707,36 +704,28 @@ void ScopeInfo::SetInferredFunctionName(String name) { } bool ScopeInfo::HasOuterScopeInfo() const { - if (length() == 0) return false; return HasOuterScopeInfoBit::decode(Flags()); } bool ScopeInfo::IsDebugEvaluateScope() const { - if (length() == 0) return false; return IsDebugEvaluateScopeBit::decode(Flags()); } void ScopeInfo::SetIsDebugEvaluateScope() { - if (length() > 0) { - DCHECK_EQ(scope_type(), WITH_SCOPE); - SetFlags(Flags() | IsDebugEvaluateScopeBit::encode(true)); - } else { - UNREACHABLE(); - } + CHECK(!IsEmpty()); + DCHECK_EQ(scope_type(), WITH_SCOPE); + SetFlags(Flags() | IsDebugEvaluateScopeBit::encode(true)); } bool ScopeInfo::PrivateNameLookupSkipsOuterClass() const { - if (length() == 0) return false; return PrivateNameLookupSkipsOuterClassBit::decode(Flags()); } bool ScopeInfo::IsReplModeScope() const { - if (length() == 0) return false; return IsReplModeScopeBit::decode(Flags()); } bool ScopeInfo::HasLocalsBlockList() const { - if (length() == 0) return false; return HasLocalsBlockListBit::decode(Flags()); } @@ -898,7 +887,7 @@ int ScopeInfo::ContextSlotIndex(ScopeInfo scope_info, String name, DCHECK_NOT_NULL(init_flag); DCHECK_NOT_NULL(maybe_assigned_flag); - if (scope_info.length() == 0) return -1; + if (scope_info.IsEmpty()) return -1; int start = scope_info.ContextLocalNamesIndex(); int end = start + scope_info.ContextLocalCount(); @@ -919,7 +908,7 @@ int ScopeInfo::ContextSlotIndex(ScopeInfo scope_info, String name, } int ScopeInfo::SavedClassVariableContextLocalIndex() const { - if (length() > 0 && HasSavedClassVariableIndexBit::decode(Flags())) { + if (HasSavedClassVariableIndexBit::decode(Flags())) { int index = Smi::ToInt(get(SavedClassVariableInfoIndex())); return index - Context::MIN_CONTEXT_SLOTS; } @@ -927,8 +916,8 @@ int ScopeInfo::SavedClassVariableContextLocalIndex() const { } int ScopeInfo::ReceiverContextSlotIndex() const { - if (length() > 0 && ReceiverVariableBits::decode(Flags()) == - VariableAllocationInfo::CONTEXT) { + if (ReceiverVariableBits::decode(Flags()) == + VariableAllocationInfo::CONTEXT) { return Smi::ToInt(get(ReceiverInfoIndex())); } return -1; @@ -936,12 +925,10 @@ int ScopeInfo::ReceiverContextSlotIndex() const { int ScopeInfo::FunctionContextSlotIndex(String name) const { DCHECK(name.IsInternalizedString()); - if (length() > 0) { - if (FunctionVariableBits::decode(Flags()) == - VariableAllocationInfo::CONTEXT && - FunctionName() == name) { - return Smi::ToInt(get(FunctionNameInfoIndex() + 1)); - } + if (FunctionVariableBits::decode(Flags()) == + VariableAllocationInfo::CONTEXT && + FunctionName() == name) { + return Smi::ToInt(get(FunctionNameInfoIndex() + 1)); } return -1; } @@ -951,7 +938,7 @@ FunctionKind ScopeInfo::function_kind() const { } int ScopeInfo::ContextLocalNamesIndex() const { - DCHECK_LT(0, length()); + DCHECK_LE(kVariablePartIndex, length()); return kVariablePartIndex; } diff --git a/src/objects/scope-info.h b/src/objects/scope-info.h index 23c3949895..719f1d9204 100644 --- a/src/objects/scope-info.h +++ b/src/objects/scope-info.h @@ -270,6 +270,8 @@ class ScopeInfo : public FixedArray { STATIC_ASSERT(LanguageModeSize == 1 << LanguageModeBit::kSize); STATIC_ASSERT(kLastFunctionKind <= FunctionKindBits::kMax); + bool IsEmpty() const; + private: // The layout of the variable part of a ScopeInfo is as follows: // 1. ContextLocalNames: @@ -343,6 +345,10 @@ class ScopeInfo : public FixedArray { static const int kFunctionNameEntries = 2; static const int kPositionInfoEntries = 2; + // Hide an inherited member function to ensure that callers have been updated + // to use IsEmpty instead. + using FixedArray::length; + // Properties of variables. using VariableModeField = base::BitField; using InitFlagField = VariableModeField::Next; diff --git a/src/objects/scope-info.tq b/src/objects/scope-info.tq index c791f6df37..3bd717171b 100644 --- a/src/objects/scope-info.tq +++ b/src/objects/scope-info.tq @@ -21,7 +21,7 @@ type VariableAllocationInfo extends uint32 constexpr 'VariableAllocationInfo'; // Properties of scopes. -bitfield struct ScopeFlags extends uint32 { +bitfield struct ScopeFlags extends uint31 { scope_type: ScopeType: 4 bit; sloppy_eval_can_extend_vars: bool: 1 bit; language_mode: LanguageMode: 1 bit; @@ -44,4 +44,5 @@ bitfield struct ScopeFlags extends uint32 { has_context_extension_slot: bool: 1 bit; is_repl_mode_scope: bool: 1 bit; has_locals_block_list: bool: 1 bit; + is_empty: bool: 1 bit; } diff --git a/src/objects/shared-function-info-inl.h b/src/objects/shared-function-info-inl.h index 37d796d48d..890f9a3154 100644 --- a/src/objects/shared-function-info-inl.h +++ b/src/objects/shared-function-info-inl.h @@ -373,7 +373,7 @@ bool SharedFunctionInfo::HasOuterScopeInfo() const { if (!scope_info().HasOuterScopeInfo()) return false; outer_info = scope_info().OuterScopeInfo(); } - return outer_info.length() > 0; + return !outer_info.IsEmpty(); } ScopeInfo SharedFunctionInfo::GetOuterScopeInfo() const { diff --git a/test/unittests/objects/object-unittest.cc b/test/unittests/objects/object-unittest.cc index ac89786350..e5aea4c682 100644 --- a/test/unittests/objects/object-unittest.cc +++ b/test/unittests/objects/object-unittest.cc @@ -171,7 +171,6 @@ TEST_F(TestWithNativeContext, EmptyFunctionScopeInfo) { isolate()->empty_function()->shared().scope_info(), function->GetIsolate()); - EXPECT_EQ(scope_info->length(), empty_function_scope_info->length()); EXPECT_EQ(scope_info->Flags(), empty_function_scope_info->Flags()); EXPECT_EQ(scope_info->ParameterCount(), empty_function_scope_info->ParameterCount()); diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py index a95a82345f..f6ab484a80 100644 --- a/tools/v8heapconst.py +++ b/tools/v8heapconst.py @@ -236,129 +236,129 @@ KNOWN_MAPS = { ("read_only_space", 0x026bd): (159, "TransitionArrayMap"), ("read_only_space", 0x026e5): (45, "ThinOneByteStringMap"), ("read_only_space", 0x0270d): (166, "FeedbackVectorMap"), - ("read_only_space", 0x0273d): (67, "ArgumentsMarkerMap"), - ("read_only_space", 0x0279d): (67, "ExceptionMap"), - ("read_only_space", 0x027f9): (67, "TerminationExceptionMap"), - ("read_only_space", 0x02861): (67, "OptimizedOutMap"), - ("read_only_space", 0x028c1): (67, "StaleRegisterMap"), - ("read_only_space", 0x02921): (130, "ScriptContextTableMap"), - ("read_only_space", 0x02949): (127, "ClosureFeedbackCellArrayMap"), - ("read_only_space", 0x02971): (165, "FeedbackMetadataArrayMap"), - ("read_only_space", 0x02999): (117, "ArrayListMap"), - ("read_only_space", 0x029c1): (65, "BigIntMap"), - ("read_only_space", 0x029e9): (128, "ObjectBoilerplateDescriptionMap"), - ("read_only_space", 0x02a11): (132, "BytecodeArrayMap"), - ("read_only_space", 0x02a39): (162, "CodeDataContainerMap"), - ("read_only_space", 0x02a61): (163, "CoverageInfoMap"), - ("read_only_space", 0x02a89): (133, "FixedDoubleArrayMap"), - ("read_only_space", 0x02ab1): (120, "GlobalDictionaryMap"), - ("read_only_space", 0x02ad9): (97, "ManyClosuresCellMap"), - ("read_only_space", 0x02b01): (117, "ModuleInfoMap"), - ("read_only_space", 0x02b29): (121, "NameDictionaryMap"), - ("read_only_space", 0x02b51): (97, "NoClosuresCellMap"), - ("read_only_space", 0x02b79): (122, "NumberDictionaryMap"), - ("read_only_space", 0x02ba1): (97, "OneClosureCellMap"), - ("read_only_space", 0x02bc9): (123, "OrderedHashMapMap"), - ("read_only_space", 0x02bf1): (124, "OrderedHashSetMap"), - ("read_only_space", 0x02c19): (125, "OrderedNameDictionaryMap"), - ("read_only_space", 0x02c41): (173, "PreparseDataMap"), - ("read_only_space", 0x02c69): (174, "PropertyArrayMap"), - ("read_only_space", 0x02c91): (93, "SideEffectCallHandlerInfoMap"), - ("read_only_space", 0x02cb9): (93, "SideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x02ce1): (93, "NextCallSideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x02d09): (126, "SimpleNumberDictionaryMap"), - ("read_only_space", 0x02d31): (149, "SmallOrderedHashMapMap"), - ("read_only_space", 0x02d59): (150, "SmallOrderedHashSetMap"), - ("read_only_space", 0x02d81): (151, "SmallOrderedNameDictionaryMap"), - ("read_only_space", 0x02da9): (154, "SourceTextModuleMap"), - ("read_only_space", 0x02dd1): (155, "SyntheticModuleMap"), - ("read_only_space", 0x02df9): (71, "WasmTypeInfoMap"), - ("read_only_space", 0x02e21): (183, "WeakArrayListMap"), - ("read_only_space", 0x02e49): (119, "EphemeronHashTableMap"), - ("read_only_space", 0x02e71): (164, "EmbedderDataArrayMap"), - ("read_only_space", 0x02e99): (184, "WeakCellMap"), - ("read_only_space", 0x02ec1): (32, "StringMap"), - ("read_only_space", 0x02ee9): (41, "ConsOneByteStringMap"), - ("read_only_space", 0x02f11): (33, "ConsStringMap"), - ("read_only_space", 0x02f39): (37, "ThinStringMap"), - ("read_only_space", 0x02f61): (35, "SlicedStringMap"), - ("read_only_space", 0x02f89): (43, "SlicedOneByteStringMap"), - ("read_only_space", 0x02fb1): (34, "ExternalStringMap"), - ("read_only_space", 0x02fd9): (42, "ExternalOneByteStringMap"), - ("read_only_space", 0x03001): (50, "UncachedExternalStringMap"), - ("read_only_space", 0x03029): (0, "InternalizedStringMap"), - ("read_only_space", 0x03051): (2, "ExternalInternalizedStringMap"), - ("read_only_space", 0x03079): (10, "ExternalOneByteInternalizedStringMap"), - ("read_only_space", 0x030a1): (18, "UncachedExternalInternalizedStringMap"), - ("read_only_space", 0x030c9): (26, "UncachedExternalOneByteInternalizedStringMap"), - ("read_only_space", 0x030f1): (58, "UncachedExternalOneByteStringMap"), - ("read_only_space", 0x03119): (67, "SelfReferenceMarkerMap"), - ("read_only_space", 0x03141): (67, "BasicBlockCountersMarkerMap"), - ("read_only_space", 0x03185): (87, "ArrayBoilerplateDescriptionMap"), - ("read_only_space", 0x0326d): (99, "InterceptorInfoMap"), - ("read_only_space", 0x05389): (72, "PromiseFulfillReactionJobTaskMap"), - ("read_only_space", 0x053b1): (73, "PromiseRejectReactionJobTaskMap"), - ("read_only_space", 0x053d9): (74, "CallableTaskMap"), - ("read_only_space", 0x05401): (75, "CallbackTaskMap"), - ("read_only_space", 0x05429): (76, "PromiseResolveThenableJobTaskMap"), - ("read_only_space", 0x05451): (79, "FunctionTemplateInfoMap"), - ("read_only_space", 0x05479): (80, "ObjectTemplateInfoMap"), - ("read_only_space", 0x054a1): (81, "AccessCheckInfoMap"), - ("read_only_space", 0x054c9): (82, "AccessorInfoMap"), - ("read_only_space", 0x054f1): (83, "AccessorPairMap"), - ("read_only_space", 0x05519): (84, "AliasedArgumentsEntryMap"), - ("read_only_space", 0x05541): (85, "AllocationMementoMap"), - ("read_only_space", 0x05569): (88, "AsmWasmDataMap"), - ("read_only_space", 0x05591): (89, "AsyncGeneratorRequestMap"), - ("read_only_space", 0x055b9): (90, "BreakPointMap"), - ("read_only_space", 0x055e1): (91, "BreakPointInfoMap"), - ("read_only_space", 0x05609): (92, "CachedTemplateObjectMap"), - ("read_only_space", 0x05631): (94, "ClassPositionsMap"), - ("read_only_space", 0x05659): (95, "DebugInfoMap"), - ("read_only_space", 0x05681): (98, "FunctionTemplateRareDataMap"), - ("read_only_space", 0x056a9): (100, "InterpreterDataMap"), - ("read_only_space", 0x056d1): (101, "ModuleRequestMap"), - ("read_only_space", 0x056f9): (102, "PromiseCapabilityMap"), - ("read_only_space", 0x05721): (103, "PromiseReactionMap"), - ("read_only_space", 0x05749): (104, "PropertyDescriptorObjectMap"), - ("read_only_space", 0x05771): (105, "PrototypeInfoMap"), - ("read_only_space", 0x05799): (106, "ScriptMap"), - ("read_only_space", 0x057c1): (107, "SourceTextModuleInfoEntryMap"), - ("read_only_space", 0x057e9): (108, "StackFrameInfoMap"), - ("read_only_space", 0x05811): (109, "StackTraceFrameMap"), - ("read_only_space", 0x05839): (110, "TemplateObjectDescriptionMap"), - ("read_only_space", 0x05861): (111, "Tuple2Map"), - ("read_only_space", 0x05889): (112, "WasmExceptionTagMap"), - ("read_only_space", 0x058b1): (113, "WasmExportedFunctionDataMap"), - ("read_only_space", 0x058d9): (114, "WasmIndirectFunctionTableMap"), - ("read_only_space", 0x05901): (115, "WasmJSFunctionDataMap"), - ("read_only_space", 0x05929): (116, "WasmValueMap"), - ("read_only_space", 0x05951): (135, "SloppyArgumentsElementsMap"), - ("read_only_space", 0x05979): (152, "DescriptorArrayMap"), - ("read_only_space", 0x059a1): (157, "UncompiledDataWithoutPreparseDataMap"), - ("read_only_space", 0x059c9): (156, "UncompiledDataWithPreparseDataMap"), - ("read_only_space", 0x059f1): (172, "OnHeapBasicBlockProfilerDataMap"), - ("read_only_space", 0x05a19): (181, "WasmCapiFunctionDataMap"), - ("read_only_space", 0x05a41): (169, "InternalClassMap"), - ("read_only_space", 0x05a69): (178, "SmiPairMap"), - ("read_only_space", 0x05a91): (177, "SmiBoxMap"), - ("read_only_space", 0x05ab9): (146, "ExportedSubClassBaseMap"), - ("read_only_space", 0x05ae1): (147, "ExportedSubClassMap"), - ("read_only_space", 0x05b09): (68, "AbstractInternalClassSubclass1Map"), - ("read_only_space", 0x05b31): (69, "AbstractInternalClassSubclass2Map"), - ("read_only_space", 0x05b59): (134, "InternalClassWithSmiElementsMap"), - ("read_only_space", 0x05b81): (170, "InternalClassWithStructElementsMap"), - ("read_only_space", 0x05ba9): (148, "ExportedSubClass2Map"), - ("read_only_space", 0x05bd1): (179, "SortStateMap"), - ("read_only_space", 0x05bf9): (86, "AllocationSiteWithWeakNextMap"), - ("read_only_space", 0x05c21): (86, "AllocationSiteWithoutWeakNextMap"), - ("read_only_space", 0x05c49): (77, "LoadHandler1Map"), - ("read_only_space", 0x05c71): (77, "LoadHandler2Map"), - ("read_only_space", 0x05c99): (77, "LoadHandler3Map"), - ("read_only_space", 0x05cc1): (78, "StoreHandler0Map"), - ("read_only_space", 0x05ce9): (78, "StoreHandler1Map"), - ("read_only_space", 0x05d11): (78, "StoreHandler2Map"), - ("read_only_space", 0x05d39): (78, "StoreHandler3Map"), + ("read_only_space", 0x02749): (67, "ArgumentsMarkerMap"), + ("read_only_space", 0x027a9): (67, "ExceptionMap"), + ("read_only_space", 0x02805): (67, "TerminationExceptionMap"), + ("read_only_space", 0x0286d): (67, "OptimizedOutMap"), + ("read_only_space", 0x028cd): (67, "StaleRegisterMap"), + ("read_only_space", 0x0292d): (130, "ScriptContextTableMap"), + ("read_only_space", 0x02955): (127, "ClosureFeedbackCellArrayMap"), + ("read_only_space", 0x0297d): (165, "FeedbackMetadataArrayMap"), + ("read_only_space", 0x029a5): (117, "ArrayListMap"), + ("read_only_space", 0x029cd): (65, "BigIntMap"), + ("read_only_space", 0x029f5): (128, "ObjectBoilerplateDescriptionMap"), + ("read_only_space", 0x02a1d): (132, "BytecodeArrayMap"), + ("read_only_space", 0x02a45): (162, "CodeDataContainerMap"), + ("read_only_space", 0x02a6d): (163, "CoverageInfoMap"), + ("read_only_space", 0x02a95): (133, "FixedDoubleArrayMap"), + ("read_only_space", 0x02abd): (120, "GlobalDictionaryMap"), + ("read_only_space", 0x02ae5): (97, "ManyClosuresCellMap"), + ("read_only_space", 0x02b0d): (117, "ModuleInfoMap"), + ("read_only_space", 0x02b35): (121, "NameDictionaryMap"), + ("read_only_space", 0x02b5d): (97, "NoClosuresCellMap"), + ("read_only_space", 0x02b85): (122, "NumberDictionaryMap"), + ("read_only_space", 0x02bad): (97, "OneClosureCellMap"), + ("read_only_space", 0x02bd5): (123, "OrderedHashMapMap"), + ("read_only_space", 0x02bfd): (124, "OrderedHashSetMap"), + ("read_only_space", 0x02c25): (125, "OrderedNameDictionaryMap"), + ("read_only_space", 0x02c4d): (173, "PreparseDataMap"), + ("read_only_space", 0x02c75): (174, "PropertyArrayMap"), + ("read_only_space", 0x02c9d): (93, "SideEffectCallHandlerInfoMap"), + ("read_only_space", 0x02cc5): (93, "SideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x02ced): (93, "NextCallSideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x02d15): (126, "SimpleNumberDictionaryMap"), + ("read_only_space", 0x02d3d): (149, "SmallOrderedHashMapMap"), + ("read_only_space", 0x02d65): (150, "SmallOrderedHashSetMap"), + ("read_only_space", 0x02d8d): (151, "SmallOrderedNameDictionaryMap"), + ("read_only_space", 0x02db5): (154, "SourceTextModuleMap"), + ("read_only_space", 0x02ddd): (155, "SyntheticModuleMap"), + ("read_only_space", 0x02e05): (71, "WasmTypeInfoMap"), + ("read_only_space", 0x02e2d): (183, "WeakArrayListMap"), + ("read_only_space", 0x02e55): (119, "EphemeronHashTableMap"), + ("read_only_space", 0x02e7d): (164, "EmbedderDataArrayMap"), + ("read_only_space", 0x02ea5): (184, "WeakCellMap"), + ("read_only_space", 0x02ecd): (32, "StringMap"), + ("read_only_space", 0x02ef5): (41, "ConsOneByteStringMap"), + ("read_only_space", 0x02f1d): (33, "ConsStringMap"), + ("read_only_space", 0x02f45): (37, "ThinStringMap"), + ("read_only_space", 0x02f6d): (35, "SlicedStringMap"), + ("read_only_space", 0x02f95): (43, "SlicedOneByteStringMap"), + ("read_only_space", 0x02fbd): (34, "ExternalStringMap"), + ("read_only_space", 0x02fe5): (42, "ExternalOneByteStringMap"), + ("read_only_space", 0x0300d): (50, "UncachedExternalStringMap"), + ("read_only_space", 0x03035): (0, "InternalizedStringMap"), + ("read_only_space", 0x0305d): (2, "ExternalInternalizedStringMap"), + ("read_only_space", 0x03085): (10, "ExternalOneByteInternalizedStringMap"), + ("read_only_space", 0x030ad): (18, "UncachedExternalInternalizedStringMap"), + ("read_only_space", 0x030d5): (26, "UncachedExternalOneByteInternalizedStringMap"), + ("read_only_space", 0x030fd): (58, "UncachedExternalOneByteStringMap"), + ("read_only_space", 0x03125): (67, "SelfReferenceMarkerMap"), + ("read_only_space", 0x0314d): (67, "BasicBlockCountersMarkerMap"), + ("read_only_space", 0x03191): (87, "ArrayBoilerplateDescriptionMap"), + ("read_only_space", 0x03279): (99, "InterceptorInfoMap"), + ("read_only_space", 0x05395): (72, "PromiseFulfillReactionJobTaskMap"), + ("read_only_space", 0x053bd): (73, "PromiseRejectReactionJobTaskMap"), + ("read_only_space", 0x053e5): (74, "CallableTaskMap"), + ("read_only_space", 0x0540d): (75, "CallbackTaskMap"), + ("read_only_space", 0x05435): (76, "PromiseResolveThenableJobTaskMap"), + ("read_only_space", 0x0545d): (79, "FunctionTemplateInfoMap"), + ("read_only_space", 0x05485): (80, "ObjectTemplateInfoMap"), + ("read_only_space", 0x054ad): (81, "AccessCheckInfoMap"), + ("read_only_space", 0x054d5): (82, "AccessorInfoMap"), + ("read_only_space", 0x054fd): (83, "AccessorPairMap"), + ("read_only_space", 0x05525): (84, "AliasedArgumentsEntryMap"), + ("read_only_space", 0x0554d): (85, "AllocationMementoMap"), + ("read_only_space", 0x05575): (88, "AsmWasmDataMap"), + ("read_only_space", 0x0559d): (89, "AsyncGeneratorRequestMap"), + ("read_only_space", 0x055c5): (90, "BreakPointMap"), + ("read_only_space", 0x055ed): (91, "BreakPointInfoMap"), + ("read_only_space", 0x05615): (92, "CachedTemplateObjectMap"), + ("read_only_space", 0x0563d): (94, "ClassPositionsMap"), + ("read_only_space", 0x05665): (95, "DebugInfoMap"), + ("read_only_space", 0x0568d): (98, "FunctionTemplateRareDataMap"), + ("read_only_space", 0x056b5): (100, "InterpreterDataMap"), + ("read_only_space", 0x056dd): (101, "ModuleRequestMap"), + ("read_only_space", 0x05705): (102, "PromiseCapabilityMap"), + ("read_only_space", 0x0572d): (103, "PromiseReactionMap"), + ("read_only_space", 0x05755): (104, "PropertyDescriptorObjectMap"), + ("read_only_space", 0x0577d): (105, "PrototypeInfoMap"), + ("read_only_space", 0x057a5): (106, "ScriptMap"), + ("read_only_space", 0x057cd): (107, "SourceTextModuleInfoEntryMap"), + ("read_only_space", 0x057f5): (108, "StackFrameInfoMap"), + ("read_only_space", 0x0581d): (109, "StackTraceFrameMap"), + ("read_only_space", 0x05845): (110, "TemplateObjectDescriptionMap"), + ("read_only_space", 0x0586d): (111, "Tuple2Map"), + ("read_only_space", 0x05895): (112, "WasmExceptionTagMap"), + ("read_only_space", 0x058bd): (113, "WasmExportedFunctionDataMap"), + ("read_only_space", 0x058e5): (114, "WasmIndirectFunctionTableMap"), + ("read_only_space", 0x0590d): (115, "WasmJSFunctionDataMap"), + ("read_only_space", 0x05935): (116, "WasmValueMap"), + ("read_only_space", 0x0595d): (135, "SloppyArgumentsElementsMap"), + ("read_only_space", 0x05985): (152, "DescriptorArrayMap"), + ("read_only_space", 0x059ad): (157, "UncompiledDataWithoutPreparseDataMap"), + ("read_only_space", 0x059d5): (156, "UncompiledDataWithPreparseDataMap"), + ("read_only_space", 0x059fd): (172, "OnHeapBasicBlockProfilerDataMap"), + ("read_only_space", 0x05a25): (181, "WasmCapiFunctionDataMap"), + ("read_only_space", 0x05a4d): (169, "InternalClassMap"), + ("read_only_space", 0x05a75): (178, "SmiPairMap"), + ("read_only_space", 0x05a9d): (177, "SmiBoxMap"), + ("read_only_space", 0x05ac5): (146, "ExportedSubClassBaseMap"), + ("read_only_space", 0x05aed): (147, "ExportedSubClassMap"), + ("read_only_space", 0x05b15): (68, "AbstractInternalClassSubclass1Map"), + ("read_only_space", 0x05b3d): (69, "AbstractInternalClassSubclass2Map"), + ("read_only_space", 0x05b65): (134, "InternalClassWithSmiElementsMap"), + ("read_only_space", 0x05b8d): (170, "InternalClassWithStructElementsMap"), + ("read_only_space", 0x05bb5): (148, "ExportedSubClass2Map"), + ("read_only_space", 0x05bdd): (179, "SortStateMap"), + ("read_only_space", 0x05c05): (86, "AllocationSiteWithWeakNextMap"), + ("read_only_space", 0x05c2d): (86, "AllocationSiteWithoutWeakNextMap"), + ("read_only_space", 0x05c55): (77, "LoadHandler1Map"), + ("read_only_space", 0x05c7d): (77, "LoadHandler2Map"), + ("read_only_space", 0x05ca5): (77, "LoadHandler3Map"), + ("read_only_space", 0x05ccd): (78, "StoreHandler0Map"), + ("read_only_space", 0x05cf5): (78, "StoreHandler1Map"), + ("read_only_space", 0x05d1d): (78, "StoreHandler2Map"), + ("read_only_space", 0x05d45): (78, "StoreHandler3Map"), ("map_space", 0x02115): (1057, "ExternalMap"), ("map_space", 0x0213d): (1072, "JSMessageObjectMap"), ("map_space", 0x02165): (182, "WasmRttEqrefMap"), @@ -384,37 +384,37 @@ KNOWN_OBJECTS = { ("read_only_space", 0x024c9): "FalseValue", ("read_only_space", 0x024f9): "empty_string", ("read_only_space", 0x02735): "EmptyScopeInfo", - ("read_only_space", 0x02765): "ArgumentsMarker", - ("read_only_space", 0x027c5): "Exception", - ("read_only_space", 0x02821): "TerminationException", - ("read_only_space", 0x02889): "OptimizedOut", - ("read_only_space", 0x028e9): "StaleRegister", - ("read_only_space", 0x03169): "EmptyPropertyArray", - ("read_only_space", 0x03171): "EmptyByteArray", - ("read_only_space", 0x03179): "EmptyObjectBoilerplateDescription", - ("read_only_space", 0x031ad): "EmptyArrayBoilerplateDescription", - ("read_only_space", 0x031b9): "EmptyClosureFeedbackCellArray", - ("read_only_space", 0x031c1): "EmptySlowElementDictionary", - ("read_only_space", 0x031e5): "EmptyOrderedHashMap", - ("read_only_space", 0x031f9): "EmptyOrderedHashSet", - ("read_only_space", 0x0320d): "EmptyFeedbackMetadata", - ("read_only_space", 0x03219): "EmptyPropertyCell", - ("read_only_space", 0x0322d): "EmptyPropertyDictionary", - ("read_only_space", 0x03255): "EmptyOrderedPropertyDictionary", - ("read_only_space", 0x03295): "NoOpInterceptorInfo", - ("read_only_space", 0x032bd): "EmptyWeakArrayList", - ("read_only_space", 0x032c9): "InfinityValue", - ("read_only_space", 0x032d5): "MinusZeroValue", - ("read_only_space", 0x032e1): "MinusInfinityValue", - ("read_only_space", 0x032ed): "SelfReferenceMarker", - ("read_only_space", 0x0332d): "BasicBlockCountersMarker", - ("read_only_space", 0x03371): "OffHeapTrampolineRelocationInfo", - ("read_only_space", 0x0337d): "TrampolineTrivialCodeDataContainer", - ("read_only_space", 0x03389): "TrampolinePromiseRejectionCodeDataContainer", - ("read_only_space", 0x03395): "GlobalThisBindingScopeInfo", - ("read_only_space", 0x033cd): "EmptyFunctionScopeInfo", - ("read_only_space", 0x033f5): "NativeScopeInfo", - ("read_only_space", 0x03411): "HashSeed", + ("read_only_space", 0x02771): "ArgumentsMarker", + ("read_only_space", 0x027d1): "Exception", + ("read_only_space", 0x0282d): "TerminationException", + ("read_only_space", 0x02895): "OptimizedOut", + ("read_only_space", 0x028f5): "StaleRegister", + ("read_only_space", 0x03175): "EmptyPropertyArray", + ("read_only_space", 0x0317d): "EmptyByteArray", + ("read_only_space", 0x03185): "EmptyObjectBoilerplateDescription", + ("read_only_space", 0x031b9): "EmptyArrayBoilerplateDescription", + ("read_only_space", 0x031c5): "EmptyClosureFeedbackCellArray", + ("read_only_space", 0x031cd): "EmptySlowElementDictionary", + ("read_only_space", 0x031f1): "EmptyOrderedHashMap", + ("read_only_space", 0x03205): "EmptyOrderedHashSet", + ("read_only_space", 0x03219): "EmptyFeedbackMetadata", + ("read_only_space", 0x03225): "EmptyPropertyCell", + ("read_only_space", 0x03239): "EmptyPropertyDictionary", + ("read_only_space", 0x03261): "EmptyOrderedPropertyDictionary", + ("read_only_space", 0x032a1): "NoOpInterceptorInfo", + ("read_only_space", 0x032c9): "EmptyWeakArrayList", + ("read_only_space", 0x032d5): "InfinityValue", + ("read_only_space", 0x032e1): "MinusZeroValue", + ("read_only_space", 0x032ed): "MinusInfinityValue", + ("read_only_space", 0x032f9): "SelfReferenceMarker", + ("read_only_space", 0x03339): "BasicBlockCountersMarker", + ("read_only_space", 0x0337d): "OffHeapTrampolineRelocationInfo", + ("read_only_space", 0x03389): "TrampolineTrivialCodeDataContainer", + ("read_only_space", 0x03395): "TrampolinePromiseRejectionCodeDataContainer", + ("read_only_space", 0x033a1): "GlobalThisBindingScopeInfo", + ("read_only_space", 0x033d9): "EmptyFunctionScopeInfo", + ("read_only_space", 0x03401): "NativeScopeInfo", + ("read_only_space", 0x0341d): "HashSeed", ("old_space", 0x02115): "ArgumentsIteratorAccessor", ("old_space", 0x02159): "ArrayLengthAccessor", ("old_space", 0x0219d): "BoundFunctionLengthAccessor",