From bd75b0ba3e026a9b8fae04fde00cd1aab1612f81 Mon Sep 17 00:00:00 2001 From: Tobias Tebbi Date: Mon, 9 Nov 2020 14:11:38 +0100 Subject: [PATCH] Reland "[torque] allow exported classes with custom C++ class" This is a reland of 26f10ecd95979c1b1ceeeab48d114e4eae362102 Change compared to original CL: The deserializer changes StrongDescriptorArray to DescriptorArray. Since this CL uses separate BodyDescriptors for the two kinds of descriptor arrays, this caused a DCHECK failure when the deserializer changes the map while the object is visited from the concurrent marking thread. Fix this by disabling the corresponding checks. Original change's description: > [torque] allow exported classes with custom C++ class > > Introduce a new annotation @customCppClass that can be used for > non-extern @export classes, that is, generate everything, remove > boilerplate from all the internal lists and switches, but allow > a custom C++ class, which in turn also allows overwriting the generated > print and verify functions. > > Port DescriptorArray and StrongDescriptorArray as an example. > > Bug: v8:7793 > Change-Id: I744e52fb4102ac49c0097f1c95bb17d301975bf0 > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2489687 > Reviewed-by: Ulan Degenbaev > Reviewed-by: Nico Hartmann > Reviewed-by: Seth Brenith > Commit-Queue: Tobias Tebbi > Cr-Commit-Position: refs/heads/master@{#70989} Bug: v8:7793 Change-Id: I7505fb111896991d16d7d113704c8c3676669f34 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2526383 Reviewed-by: Nico Hartmann Reviewed-by: Ulan Degenbaev Commit-Queue: Tobias Tebbi Cr-Commit-Position: refs/heads/master@{#71048} --- src/compiler/types.cc | 2 - src/diagnostics/objects-debug.cc | 5 - src/diagnostics/objects-printer.cc | 4 - src/heap/concurrent-marking.cc | 7 + src/heap/factory.h | 4 + src/heap/objects-visiting.h | 1 - src/heap/setup-heap-internal.cc | 8 +- src/objects/descriptor-array.h | 4 +- src/objects/descriptor-array.tq | 8 +- src/objects/map.cc | 4 - src/objects/map.h | 1 - src/objects/object-list-macros.h | 2 - src/objects/objects-body-descriptors-inl.h | 4 - src/objects/torque-defined-classes.h | 1 + src/roots/roots.h | 2 - src/torque/constants.h | 2 + src/torque/implementation-visitor.cc | 6 +- src/torque/torque-parser.cc | 8 +- src/torque/type-visitor.cc | 9 + src/torque/types.h | 3 + tools/v8heapconst.py | 224 ++++++++++----------- 21 files changed, 158 insertions(+), 151 deletions(-) diff --git a/src/compiler/types.cc b/src/compiler/types.cc index a97cd33cd6..525d0cdacb 100644 --- a/src/compiler/types.cc +++ b/src/compiler/types.cc @@ -294,8 +294,6 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) { case BYTECODE_ARRAY_TYPE: case OBJECT_BOILERPLATE_DESCRIPTION_TYPE: case ARRAY_BOILERPLATE_DESCRIPTION_TYPE: - case DESCRIPTOR_ARRAY_TYPE: - case STRONG_DESCRIPTOR_ARRAY_TYPE: case TRANSITION_ARRAY_TYPE: case FEEDBACK_CELL_TYPE: case CLOSURE_FEEDBACK_CELL_ARRAY_TYPE: diff --git a/src/diagnostics/objects-debug.cc b/src/diagnostics/objects-debug.cc index 06fade949e..b99ddb814e 100644 --- a/src/diagnostics/objects-debug.cc +++ b/src/diagnostics/objects-debug.cc @@ -252,11 +252,6 @@ void HeapObject::HeapObjectVerify(Isolate* isolate) { TORQUE_INSTANCE_CHECKERS_MULTIPLE_FULLY_DEFINED(MAKE_TORQUE_CASE) #undef MAKE_TORQUE_CASE - case DESCRIPTOR_ARRAY_TYPE: - case STRONG_DESCRIPTOR_ARRAY_TYPE: - DescriptorArray::cast(*this).DescriptorArrayVerify(isolate); - break; - case FOREIGN_TYPE: break; // No interesting fields. diff --git a/src/diagnostics/objects-printer.cc b/src/diagnostics/objects-printer.cc index 124190e9f6..d65c0eeb4b 100644 --- a/src/diagnostics/objects-printer.cc +++ b/src/diagnostics/objects-printer.cc @@ -169,10 +169,6 @@ void HeapObject::HeapObjectPrint(std::ostream& os) { // NOLINT TORQUE_INSTANCE_CHECKERS_MULTIPLE_FULLY_DEFINED(MAKE_TORQUE_CASE) #undef MAKE_TORQUE_CASE - case DESCRIPTOR_ARRAY_TYPE: - case STRONG_DESCRIPTOR_ARRAY_TYPE: - DescriptorArray::cast(*this).DescriptorArrayPrint(os); - break; case FOREIGN_TYPE: Foreign::cast(*this).ForeignPrint(os); break; diff --git a/src/heap/concurrent-marking.cc b/src/heap/concurrent-marking.cc index 9700752c52..f2dfad057b 100644 --- a/src/heap/concurrent-marking.cc +++ b/src/heap/concurrent-marking.cc @@ -347,6 +347,13 @@ FixedArray ConcurrentMarkingVisitor::Cast(HeapObject object) { return FixedArray::unchecked_cast(object); } +// The Deserializer changes the map from StrongDescriptorArray to +// DescriptorArray +template <> +StrongDescriptorArray ConcurrentMarkingVisitor::Cast(HeapObject object) { + return StrongDescriptorArray::unchecked_cast(DescriptorArray::cast(object)); +} + class ConcurrentMarking::JobTask : public v8::JobTask { public: JobTask(ConcurrentMarking* concurrent_marking, unsigned mark_compact_epoch, diff --git a/src/heap/factory.h b/src/heap/factory.h index 6b01faa31d..e09e1ab7d6 100644 --- a/src/heap/factory.h +++ b/src/heap/factory.h @@ -121,6 +121,10 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase { #include "torque-generated/factory.inc" + // Avoid the Torque-generated factory function to shadow the one from + // FactoryBase. + using FactoryBase::NewDescriptorArray; + Handle NewOddball(Handle map, const char* to_string, Handle to_number, const char* type_of, byte kind); diff --git a/src/heap/objects-visiting.h b/src/heap/objects-visiting.h index 84d378a277..aa1f5376b1 100644 --- a/src/heap/objects-visiting.h +++ b/src/heap/objects-visiting.h @@ -25,7 +25,6 @@ namespace internal { V(Context) \ V(CoverageInfo) \ V(DataHandler) \ - V(DescriptorArray) \ V(EmbedderDataArray) \ V(EphemeronHashTable) \ V(FeedbackCell) \ diff --git a/src/heap/setup-heap-internal.cc b/src/heap/setup-heap-internal.cc index 3ea284a8b4..521d1a10c6 100644 --- a/src/heap/setup-heap-internal.cc +++ b/src/heap/setup-heap-internal.cc @@ -386,7 +386,6 @@ bool Heap::CreateInitialMaps() { ALLOCATE_PRIMITIVE_MAP(SYMBOL_TYPE, Symbol::kSize, symbol, Context::SYMBOL_FUNCTION_INDEX) ALLOCATE_MAP(FOREIGN_TYPE, Foreign::kSize, foreign) - ALLOCATE_VARSIZE_MAP(STRONG_DESCRIPTOR_ARRAY_TYPE, strong_descriptor_array) ALLOCATE_PRIMITIVE_MAP(ODDBALL_TYPE, Oddball::kSize, boolean, Context::BOOLEAN_FUNCTION_INDEX); @@ -428,8 +427,11 @@ bool Heap::CreateInitialMaps() { TORQUE_DEFINED_FIXED_INSTANCE_TYPE_LIST(TORQUE_ALLOCATE_MAP); #undef TORQUE_ALLOCATE_MAP -#define TORQUE_ALLOCATE_VARSIZE_MAP(NAME, Name, name) \ - ALLOCATE_VARSIZE_MAP(NAME, name) +#define TORQUE_ALLOCATE_VARSIZE_MAP(NAME, Name, name) \ + /* The DescriptorArray map is pre-allocated and initialized above. */ \ + if (NAME != DESCRIPTOR_ARRAY_TYPE) { \ + ALLOCATE_VARSIZE_MAP(NAME, name) \ + } TORQUE_DEFINED_VARSIZE_INSTANCE_TYPE_LIST(TORQUE_ALLOCATE_VARSIZE_MAP); #undef TORQUE_ALLOCATE_VARSIZE_MAP diff --git a/src/objects/descriptor-array.h b/src/objects/descriptor-array.h index eae7769e3b..57f9162c65 100644 --- a/src/objects/descriptor-array.h +++ b/src/objects/descriptor-array.h @@ -170,9 +170,7 @@ class DescriptorArray "Weak fields extend up to the end of the header."); static_assert(kDescriptorsOffset == kHeaderSize, "Variable-size array follows header."); - // We use this visitor to also visitor to also visit the enum_cache, which is - // the only tagged field in the header, and placed at the end of the header. - using BodyDescriptor = FlexibleWeakBodyDescriptor; + class BodyDescriptor; // Layout of descriptor. // Naming is consistent with Dictionary classes for easy templating. diff --git a/src/objects/descriptor-array.tq b/src/objects/descriptor-array.tq index c791f3988c..eb86a3343e 100644 --- a/src/objects/descriptor-array.tq +++ b/src/objects/descriptor-array.tq @@ -16,8 +16,9 @@ struct DescriptorEntry { value: JSAny|Weak|AccessorInfo|AccessorPair|ClassPositions; } -@generateCppClass -extern class DescriptorArray extends HeapObject { +@export +@customCppClass +class DescriptorArray extends HeapObject { const number_of_all_descriptors: uint16; number_of_descriptors: uint16; raw_number_of_marked_descriptors: uint16; @@ -27,5 +28,4 @@ extern class DescriptorArray extends HeapObject { } // A descriptor array where all values are held strongly. -extern class StrongDescriptorArray extends DescriptorArray - generates 'TNode'; +class StrongDescriptorArray extends DescriptorArray {} diff --git a/src/objects/map.cc b/src/objects/map.cc index d125fb8979..51c561282f 100644 --- a/src/objects/map.cc +++ b/src/objects/map.cc @@ -202,10 +202,6 @@ VisitorId Map::GetVisitorId(Map map) { case PROPERTY_CELL_TYPE: return kVisitPropertyCell; - case DESCRIPTOR_ARRAY_TYPE: - case STRONG_DESCRIPTOR_ARRAY_TYPE: - return kVisitDescriptorArray; - case TRANSITION_ARRAY_TYPE: return kVisitTransitionArray; diff --git a/src/objects/map.h b/src/objects/map.h index 244c49a074..9c63929b51 100644 --- a/src/objects/map.h +++ b/src/objects/map.h @@ -40,7 +40,6 @@ enum InstanceType : uint16_t; V(CodeDataContainer) \ V(Context) \ V(DataHandler) \ - V(DescriptorArray) \ V(EmbedderDataArray) \ V(EphemeronHashTable) \ V(FeedbackCell) \ diff --git a/src/objects/object-list-macros.h b/src/objects/object-list-macros.h index 6de6f553e6..a4f451eb49 100644 --- a/src/objects/object-list-macros.h +++ b/src/objects/object-list-macros.h @@ -104,7 +104,6 @@ class ZoneForwardList; V(DataHandler) \ V(DeoptimizationData) \ V(DependentCode) \ - V(DescriptorArray) \ V(EmbedderDataArray) \ V(EphemeronHashTable) \ V(ExternalOneByteString) \ @@ -281,7 +280,6 @@ class ZoneForwardList; V(ModuleContext) \ V(NonNullForeign) \ V(ScriptContext) \ - V(StrongDescriptorArray) \ V(WithContext) #define HEAP_OBJECT_TYPE_LIST(V) \ diff --git a/src/objects/objects-body-descriptors-inl.h b/src/objects/objects-body-descriptors-inl.h index 650b361162..57bf195b5c 100644 --- a/src/objects/objects-body-descriptors-inl.h +++ b/src/objects/objects-body-descriptors-inl.h @@ -945,10 +945,6 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) { p4); case PROPERTY_ARRAY_TYPE: return Op::template apply(p1, p2, p3, p4); - case DESCRIPTOR_ARRAY_TYPE: - case STRONG_DESCRIPTOR_ARRAY_TYPE: - return Op::template apply(p1, p2, p3, - p4); case TRANSITION_ARRAY_TYPE: return Op::template apply(p1, p2, p3, p4); diff --git a/src/objects/torque-defined-classes.h b/src/objects/torque-defined-classes.h index 8176ee4b62..aeea4e1c53 100644 --- a/src/objects/torque-defined-classes.h +++ b/src/objects/torque-defined-classes.h @@ -4,6 +4,7 @@ #ifndef V8_OBJECTS_TORQUE_DEFINED_CLASSES_H_ #define V8_OBJECTS_TORQUE_DEFINED_CLASSES_H_ +#include "src/objects/descriptor-array.h" #include "src/objects/fixed-array.h" #include "src/objects/heap-object.h" #include "src/objects/objects.h" diff --git a/src/roots/roots.h b/src/roots/roots.h index eac150f003..744176e35e 100644 --- a/src/roots/roots.h +++ b/src/roots/roots.h @@ -85,8 +85,6 @@ class Symbol; V(Map, bytecode_array_map, BytecodeArrayMap) \ V(Map, code_data_container_map, CodeDataContainerMap) \ V(Map, coverage_info_map, CoverageInfoMap) \ - V(Map, descriptor_array_map, DescriptorArrayMap) \ - V(Map, strong_descriptor_array_map, StrongDescriptorArrayMap) \ V(Map, fixed_double_array_map, FixedDoubleArrayMap) \ V(Map, global_dictionary_map, GlobalDictionaryMap) \ V(Map, many_closures_cell_map, ManyClosuresCellMap) \ diff --git a/src/torque/constants.h b/src/torque/constants.h index bcffd951ca..1bf4af7198 100644 --- a/src/torque/constants.h +++ b/src/torque/constants.h @@ -85,6 +85,7 @@ static const char* const ANNOTATION_ABSTRACT = "@abstract"; static const char* const ANNOTATION_HAS_SAME_INSTANCE_TYPE_AS_PARENT = "@hasSameInstanceTypeAsParent"; static const char* const ANNOTATION_GENERATE_CPP_CLASS = "@generateCppClass"; +static const char* const ANNOTATION_CUSTOM_CPP_CLASS = "@customCppClass"; static const char* const ANNOTATION_HIGHEST_INSTANCE_TYPE_WITHIN_PARENT = "@highestInstanceTypeWithinParentClassRange"; static const char* const ANNOTATION_LOWEST_INSTANCE_TYPE_WITHIN_PARENT = @@ -135,6 +136,7 @@ enum class ClassFlag { kIsShape = 1 << 5, kHasSameInstanceTypeAsParent = 1 << 6, kGenerateCppClassDefinitions = 1 << 7, + kCustomCppClass = 1 << 8, kHighestInstanceTypeWithinParent = 1 << 9, kLowestInstanceTypeWithinParent = 1 << 10, kUndefinedLayout = 1 << 11, diff --git a/src/torque/implementation-visitor.cc b/src/torque/implementation-visitor.cc index c868671a6c..0052702a48 100644 --- a/src/torque/implementation-visitor.cc +++ b/src/torque/implementation-visitor.cc @@ -3829,7 +3829,7 @@ void CppClassGenerator::GenerateClass() { hdr_ << "};\n\n"; - if (!type_->IsExtern()) { + if (type_->ShouldGenerateFullClassDefinition()) { GenerateClassExport(type_, hdr_, inl_); } } @@ -4542,8 +4542,10 @@ void ImplementationVisitor::GenerateBodyDescriptors( if (type->size().SingleValue()) { h_contents << " return " << *type->size().SingleValue() << ";\n"; } else { + // We use an unchecked_cast here because this is used for concurrent + // marking, where we shouldn't re-read the map. h_contents << " return " << name - << "::cast(raw_object).AllocatedSize();\n"; + << "::unchecked_cast(raw_object).AllocatedSize();\n"; } h_contents << " }\n\n"; diff --git a/src/torque/torque-parser.cc b/src/torque/torque-parser.cc index b000dd7ef3..9def97ff38 100644 --- a/src/torque/torque-parser.cc +++ b/src/torque/torque-parser.cc @@ -889,8 +889,9 @@ base::Optional MakeClassDeclaration( child_results, {ANNOTATION_GENERATE_PRINT, ANNOTATION_NO_VERIFIER, ANNOTATION_ABSTRACT, ANNOTATION_HAS_SAME_INSTANCE_TYPE_AS_PARENT, - ANNOTATION_GENERATE_CPP_CLASS, ANNOTATION_GENERATE_BODY_DESCRIPTOR, - ANNOTATION_EXPORT, ANNOTATION_DO_NOT_GENERATE_CAST, + ANNOTATION_GENERATE_CPP_CLASS, ANNOTATION_CUSTOM_CPP_CLASS, + ANNOTATION_GENERATE_BODY_DESCRIPTOR, ANNOTATION_EXPORT, + ANNOTATION_DO_NOT_GENERATE_CAST, ANNOTATION_HIGHEST_INSTANCE_TYPE_WITHIN_PARENT, ANNOTATION_LOWEST_INSTANCE_TYPE_WITHIN_PARENT}, {ANNOTATION_RESERVE_BITS_IN_INSTANCE_TYPE, @@ -909,6 +910,9 @@ base::Optional MakeClassDeclaration( if (annotations.Contains(ANNOTATION_GENERATE_CPP_CLASS)) { flags |= ClassFlag::kGenerateCppClassDefinitions; } + if (annotations.Contains(ANNOTATION_CUSTOM_CPP_CLASS)) { + flags |= ClassFlag::kCustomCppClass; + } if (annotations.Contains(ANNOTATION_DO_NOT_GENERATE_CAST)) { flags |= ClassFlag::kDoNotGenerateCast; } diff --git a/src/torque/type-visitor.cc b/src/torque/type-visitor.cc index a9d8b8e2fd..a706fc561d 100644 --- a/src/torque/type-visitor.cc +++ b/src/torque/type-visitor.cc @@ -287,6 +287,15 @@ const ClassType* TypeVisitor::ComputeType( Error("Class \"", decl->name->value, "\" requires a layout but doesn't have one"); } + if (flags & ClassFlag::kCustomCppClass) { + if (!(flags & ClassFlag::kExport)) { + Error("Only exported classes can have a custom C++ class."); + } + if (flags & ClassFlag::kExtern) { + Error("No need to specify ", ANNOTATION_CUSTOM_CPP_CLASS, + ", extern classes always have a custom C++ class."); + } + } if (flags & ClassFlag::kExtern) { if (decl->generates) { bool enforce_tnode_type = true; diff --git a/src/torque/types.h b/src/torque/types.h index 5335400346..419c3d5133 100644 --- a/src/torque/types.h +++ b/src/torque/types.h @@ -683,6 +683,9 @@ class ClassType final : public AggregateType { return flags_ & ClassFlag::kGenerateCppClassDefinitions || !IsExtern() || ShouldGenerateBodyDescriptor(); } + bool ShouldGenerateFullClassDefinition() const { + return !IsExtern() && !(flags_ & ClassFlag::kCustomCppClass); + } bool ShouldExport() const { return flags_ & ClassFlag::kExport; } bool IsShape() const { return flags_ & ClassFlag::kIsShape; } bool HasStaticSize() const; diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py index a70def974a..0138a0813a 100644 --- a/tools/v8heapconst.py +++ b/tools/v8heapconst.py @@ -249,92 +249,92 @@ KNOWN_MAPS = { ("read_only_space", 0x02a11): (131, "BytecodeArrayMap"), ("read_only_space", 0x02a39): (161, "CodeDataContainerMap"), ("read_only_space", 0x02a61): (162, "CoverageInfoMap"), - ("read_only_space", 0x02a89): (151, "DescriptorArrayMap"), - ("read_only_space", 0x02ab1): (132, "FixedDoubleArrayMap"), - ("read_only_space", 0x02ad9): (119, "GlobalDictionaryMap"), - ("read_only_space", 0x02b01): (97, "ManyClosuresCellMap"), - ("read_only_space", 0x02b29): (116, "ModuleInfoMap"), - ("read_only_space", 0x02b51): (120, "NameDictionaryMap"), - ("read_only_space", 0x02b79): (97, "NoClosuresCellMap"), - ("read_only_space", 0x02ba1): (121, "NumberDictionaryMap"), - ("read_only_space", 0x02bc9): (97, "OneClosureCellMap"), - ("read_only_space", 0x02bf1): (122, "OrderedHashMapMap"), - ("read_only_space", 0x02c19): (123, "OrderedHashSetMap"), - ("read_only_space", 0x02c41): (124, "OrderedNameDictionaryMap"), - ("read_only_space", 0x02c69): (172, "PreparseDataMap"), - ("read_only_space", 0x02c91): (173, "PropertyArrayMap"), - ("read_only_space", 0x02cb9): (93, "SideEffectCallHandlerInfoMap"), - ("read_only_space", 0x02ce1): (93, "SideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x02d09): (93, "NextCallSideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x02d31): (125, "SimpleNumberDictionaryMap"), - ("read_only_space", 0x02d59): (148, "SmallOrderedHashMapMap"), - ("read_only_space", 0x02d81): (149, "SmallOrderedHashSetMap"), - ("read_only_space", 0x02da9): (150, "SmallOrderedNameDictionaryMap"), - ("read_only_space", 0x02dd1): (153, "SourceTextModuleMap"), - ("read_only_space", 0x02df9): (154, "SyntheticModuleMap"), - ("read_only_space", 0x02e21): (156, "UncompiledDataWithoutPreparseDataMap"), - ("read_only_space", 0x02e49): (155, "UncompiledDataWithPreparseDataMap"), - ("read_only_space", 0x02e71): (71, "WasmTypeInfoMap"), - ("read_only_space", 0x02e99): (182, "WeakArrayListMap"), - ("read_only_space", 0x02ec1): (118, "EphemeronHashTableMap"), - ("read_only_space", 0x02ee9): (163, "EmbedderDataArrayMap"), - ("read_only_space", 0x02f11): (183, "WeakCellMap"), - ("read_only_space", 0x02f39): (32, "StringMap"), - ("read_only_space", 0x02f61): (41, "ConsOneByteStringMap"), - ("read_only_space", 0x02f89): (33, "ConsStringMap"), - ("read_only_space", 0x02fb1): (37, "ThinStringMap"), - ("read_only_space", 0x02fd9): (35, "SlicedStringMap"), - ("read_only_space", 0x03001): (43, "SlicedOneByteStringMap"), - ("read_only_space", 0x03029): (34, "ExternalStringMap"), - ("read_only_space", 0x03051): (42, "ExternalOneByteStringMap"), - ("read_only_space", 0x03079): (50, "UncachedExternalStringMap"), - ("read_only_space", 0x030a1): (0, "InternalizedStringMap"), - ("read_only_space", 0x030c9): (2, "ExternalInternalizedStringMap"), - ("read_only_space", 0x030f1): (10, "ExternalOneByteInternalizedStringMap"), - ("read_only_space", 0x03119): (18, "UncachedExternalInternalizedStringMap"), - ("read_only_space", 0x03141): (26, "UncachedExternalOneByteInternalizedStringMap"), - ("read_only_space", 0x03169): (58, "UncachedExternalOneByteStringMap"), - ("read_only_space", 0x03191): (67, "SelfReferenceMarkerMap"), - ("read_only_space", 0x031b9): (67, "BasicBlockCountersMarkerMap"), - ("read_only_space", 0x031fd): (87, "ArrayBoilerplateDescriptionMap"), - ("read_only_space", 0x032e5): (99, "InterceptorInfoMap"), - ("read_only_space", 0x053f1): (72, "PromiseFulfillReactionJobTaskMap"), - ("read_only_space", 0x05419): (73, "PromiseRejectReactionJobTaskMap"), - ("read_only_space", 0x05441): (74, "CallableTaskMap"), - ("read_only_space", 0x05469): (75, "CallbackTaskMap"), - ("read_only_space", 0x05491): (76, "PromiseResolveThenableJobTaskMap"), - ("read_only_space", 0x054b9): (79, "FunctionTemplateInfoMap"), - ("read_only_space", 0x054e1): (80, "ObjectTemplateInfoMap"), - ("read_only_space", 0x05509): (81, "AccessCheckInfoMap"), - ("read_only_space", 0x05531): (82, "AccessorInfoMap"), - ("read_only_space", 0x05559): (83, "AccessorPairMap"), - ("read_only_space", 0x05581): (84, "AliasedArgumentsEntryMap"), - ("read_only_space", 0x055a9): (85, "AllocationMementoMap"), - ("read_only_space", 0x055d1): (88, "AsmWasmDataMap"), - ("read_only_space", 0x055f9): (89, "AsyncGeneratorRequestMap"), - ("read_only_space", 0x05621): (90, "BreakPointMap"), - ("read_only_space", 0x05649): (91, "BreakPointInfoMap"), - ("read_only_space", 0x05671): (92, "CachedTemplateObjectMap"), - ("read_only_space", 0x05699): (94, "ClassPositionsMap"), - ("read_only_space", 0x056c1): (95, "DebugInfoMap"), - ("read_only_space", 0x056e9): (98, "FunctionTemplateRareDataMap"), - ("read_only_space", 0x05711): (100, "InterpreterDataMap"), - ("read_only_space", 0x05739): (101, "PromiseCapabilityMap"), - ("read_only_space", 0x05761): (102, "PromiseReactionMap"), - ("read_only_space", 0x05789): (103, "PropertyDescriptorObjectMap"), - ("read_only_space", 0x057b1): (104, "PrototypeInfoMap"), - ("read_only_space", 0x057d9): (105, "ScriptMap"), - ("read_only_space", 0x05801): (106, "SourceTextModuleInfoEntryMap"), - ("read_only_space", 0x05829): (107, "StackFrameInfoMap"), - ("read_only_space", 0x05851): (108, "StackTraceFrameMap"), - ("read_only_space", 0x05879): (109, "TemplateObjectDescriptionMap"), - ("read_only_space", 0x058a1): (110, "Tuple2Map"), - ("read_only_space", 0x058c9): (111, "WasmExceptionTagMap"), - ("read_only_space", 0x058f1): (112, "WasmExportedFunctionDataMap"), - ("read_only_space", 0x05919): (113, "WasmIndirectFunctionTableMap"), - ("read_only_space", 0x05941): (114, "WasmJSFunctionDataMap"), - ("read_only_space", 0x05969): (115, "WasmValueMap"), - ("read_only_space", 0x05991): (134, "SloppyArgumentsElementsMap"), + ("read_only_space", 0x02a89): (132, "FixedDoubleArrayMap"), + ("read_only_space", 0x02ab1): (119, "GlobalDictionaryMap"), + ("read_only_space", 0x02ad9): (97, "ManyClosuresCellMap"), + ("read_only_space", 0x02b01): (116, "ModuleInfoMap"), + ("read_only_space", 0x02b29): (120, "NameDictionaryMap"), + ("read_only_space", 0x02b51): (97, "NoClosuresCellMap"), + ("read_only_space", 0x02b79): (121, "NumberDictionaryMap"), + ("read_only_space", 0x02ba1): (97, "OneClosureCellMap"), + ("read_only_space", 0x02bc9): (122, "OrderedHashMapMap"), + ("read_only_space", 0x02bf1): (123, "OrderedHashSetMap"), + ("read_only_space", 0x02c19): (124, "OrderedNameDictionaryMap"), + ("read_only_space", 0x02c41): (172, "PreparseDataMap"), + ("read_only_space", 0x02c69): (173, "PropertyArrayMap"), + ("read_only_space", 0x02c91): (93, "SideEffectCallHandlerInfoMap"), + ("read_only_space", 0x02cb9): (93, "SideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x02ce1): (93, "NextCallSideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x02d09): (125, "SimpleNumberDictionaryMap"), + ("read_only_space", 0x02d31): (148, "SmallOrderedHashMapMap"), + ("read_only_space", 0x02d59): (149, "SmallOrderedHashSetMap"), + ("read_only_space", 0x02d81): (150, "SmallOrderedNameDictionaryMap"), + ("read_only_space", 0x02da9): (153, "SourceTextModuleMap"), + ("read_only_space", 0x02dd1): (154, "SyntheticModuleMap"), + ("read_only_space", 0x02df9): (156, "UncompiledDataWithoutPreparseDataMap"), + ("read_only_space", 0x02e21): (155, "UncompiledDataWithPreparseDataMap"), + ("read_only_space", 0x02e49): (71, "WasmTypeInfoMap"), + ("read_only_space", 0x02e71): (182, "WeakArrayListMap"), + ("read_only_space", 0x02e99): (118, "EphemeronHashTableMap"), + ("read_only_space", 0x02ec1): (163, "EmbedderDataArrayMap"), + ("read_only_space", 0x02ee9): (183, "WeakCellMap"), + ("read_only_space", 0x02f11): (32, "StringMap"), + ("read_only_space", 0x02f39): (41, "ConsOneByteStringMap"), + ("read_only_space", 0x02f61): (33, "ConsStringMap"), + ("read_only_space", 0x02f89): (37, "ThinStringMap"), + ("read_only_space", 0x02fb1): (35, "SlicedStringMap"), + ("read_only_space", 0x02fd9): (43, "SlicedOneByteStringMap"), + ("read_only_space", 0x03001): (34, "ExternalStringMap"), + ("read_only_space", 0x03029): (42, "ExternalOneByteStringMap"), + ("read_only_space", 0x03051): (50, "UncachedExternalStringMap"), + ("read_only_space", 0x03079): (0, "InternalizedStringMap"), + ("read_only_space", 0x030a1): (2, "ExternalInternalizedStringMap"), + ("read_only_space", 0x030c9): (10, "ExternalOneByteInternalizedStringMap"), + ("read_only_space", 0x030f1): (18, "UncachedExternalInternalizedStringMap"), + ("read_only_space", 0x03119): (26, "UncachedExternalOneByteInternalizedStringMap"), + ("read_only_space", 0x03141): (58, "UncachedExternalOneByteStringMap"), + ("read_only_space", 0x03169): (67, "SelfReferenceMarkerMap"), + ("read_only_space", 0x03191): (67, "BasicBlockCountersMarkerMap"), + ("read_only_space", 0x031d5): (87, "ArrayBoilerplateDescriptionMap"), + ("read_only_space", 0x032bd): (99, "InterceptorInfoMap"), + ("read_only_space", 0x053c9): (72, "PromiseFulfillReactionJobTaskMap"), + ("read_only_space", 0x053f1): (73, "PromiseRejectReactionJobTaskMap"), + ("read_only_space", 0x05419): (74, "CallableTaskMap"), + ("read_only_space", 0x05441): (75, "CallbackTaskMap"), + ("read_only_space", 0x05469): (76, "PromiseResolveThenableJobTaskMap"), + ("read_only_space", 0x05491): (79, "FunctionTemplateInfoMap"), + ("read_only_space", 0x054b9): (80, "ObjectTemplateInfoMap"), + ("read_only_space", 0x054e1): (81, "AccessCheckInfoMap"), + ("read_only_space", 0x05509): (82, "AccessorInfoMap"), + ("read_only_space", 0x05531): (83, "AccessorPairMap"), + ("read_only_space", 0x05559): (84, "AliasedArgumentsEntryMap"), + ("read_only_space", 0x05581): (85, "AllocationMementoMap"), + ("read_only_space", 0x055a9): (88, "AsmWasmDataMap"), + ("read_only_space", 0x055d1): (89, "AsyncGeneratorRequestMap"), + ("read_only_space", 0x055f9): (90, "BreakPointMap"), + ("read_only_space", 0x05621): (91, "BreakPointInfoMap"), + ("read_only_space", 0x05649): (92, "CachedTemplateObjectMap"), + ("read_only_space", 0x05671): (94, "ClassPositionsMap"), + ("read_only_space", 0x05699): (95, "DebugInfoMap"), + ("read_only_space", 0x056c1): (98, "FunctionTemplateRareDataMap"), + ("read_only_space", 0x056e9): (100, "InterpreterDataMap"), + ("read_only_space", 0x05711): (101, "PromiseCapabilityMap"), + ("read_only_space", 0x05739): (102, "PromiseReactionMap"), + ("read_only_space", 0x05761): (103, "PropertyDescriptorObjectMap"), + ("read_only_space", 0x05789): (104, "PrototypeInfoMap"), + ("read_only_space", 0x057b1): (105, "ScriptMap"), + ("read_only_space", 0x057d9): (106, "SourceTextModuleInfoEntryMap"), + ("read_only_space", 0x05801): (107, "StackFrameInfoMap"), + ("read_only_space", 0x05829): (108, "StackTraceFrameMap"), + ("read_only_space", 0x05851): (109, "TemplateObjectDescriptionMap"), + ("read_only_space", 0x05879): (110, "Tuple2Map"), + ("read_only_space", 0x058a1): (111, "WasmExceptionTagMap"), + ("read_only_space", 0x058c9): (112, "WasmExportedFunctionDataMap"), + ("read_only_space", 0x058f1): (113, "WasmIndirectFunctionTableMap"), + ("read_only_space", 0x05919): (114, "WasmJSFunctionDataMap"), + ("read_only_space", 0x05941): (115, "WasmValueMap"), + ("read_only_space", 0x05969): (134, "SloppyArgumentsElementsMap"), + ("read_only_space", 0x05991): (151, "DescriptorArrayMap"), ("read_only_space", 0x059b9): (171, "OnHeapBasicBlockProfilerDataMap"), ("read_only_space", 0x059e1): (180, "WasmCapiFunctionDataMap"), ("read_only_space", 0x05a09): (168, "InternalClassMap"), @@ -386,32 +386,32 @@ KNOWN_OBJECTS = { ("read_only_space", 0x02821): "TerminationException", ("read_only_space", 0x02889): "OptimizedOut", ("read_only_space", 0x028e9): "StaleRegister", - ("read_only_space", 0x031e1): "EmptyPropertyArray", - ("read_only_space", 0x031e9): "EmptyByteArray", - ("read_only_space", 0x031f1): "EmptyObjectBoilerplateDescription", - ("read_only_space", 0x03225): "EmptyArrayBoilerplateDescription", - ("read_only_space", 0x03231): "EmptyClosureFeedbackCellArray", - ("read_only_space", 0x03239): "EmptySlowElementDictionary", - ("read_only_space", 0x0325d): "EmptyOrderedHashMap", - ("read_only_space", 0x03271): "EmptyOrderedHashSet", - ("read_only_space", 0x03285): "EmptyFeedbackMetadata", - ("read_only_space", 0x03291): "EmptyPropertyCell", - ("read_only_space", 0x032a5): "EmptyPropertyDictionary", - ("read_only_space", 0x032cd): "EmptyOrderedPropertyDictionary", - ("read_only_space", 0x0330d): "NoOpInterceptorInfo", - ("read_only_space", 0x03335): "EmptyWeakArrayList", - ("read_only_space", 0x03341): "InfinityValue", - ("read_only_space", 0x0334d): "MinusZeroValue", - ("read_only_space", 0x03359): "MinusInfinityValue", - ("read_only_space", 0x03365): "SelfReferenceMarker", - ("read_only_space", 0x033a5): "BasicBlockCountersMarker", - ("read_only_space", 0x033e9): "OffHeapTrampolineRelocationInfo", - ("read_only_space", 0x033f5): "TrampolineTrivialCodeDataContainer", - ("read_only_space", 0x03401): "TrampolinePromiseRejectionCodeDataContainer", - ("read_only_space", 0x0340d): "GlobalThisBindingScopeInfo", - ("read_only_space", 0x03445): "EmptyFunctionScopeInfo", - ("read_only_space", 0x0346d): "NativeScopeInfo", - ("read_only_space", 0x03489): "HashSeed", + ("read_only_space", 0x031b9): "EmptyPropertyArray", + ("read_only_space", 0x031c1): "EmptyByteArray", + ("read_only_space", 0x031c9): "EmptyObjectBoilerplateDescription", + ("read_only_space", 0x031fd): "EmptyArrayBoilerplateDescription", + ("read_only_space", 0x03209): "EmptyClosureFeedbackCellArray", + ("read_only_space", 0x03211): "EmptySlowElementDictionary", + ("read_only_space", 0x03235): "EmptyOrderedHashMap", + ("read_only_space", 0x03249): "EmptyOrderedHashSet", + ("read_only_space", 0x0325d): "EmptyFeedbackMetadata", + ("read_only_space", 0x03269): "EmptyPropertyCell", + ("read_only_space", 0x0327d): "EmptyPropertyDictionary", + ("read_only_space", 0x032a5): "EmptyOrderedPropertyDictionary", + ("read_only_space", 0x032e5): "NoOpInterceptorInfo", + ("read_only_space", 0x0330d): "EmptyWeakArrayList", + ("read_only_space", 0x03319): "InfinityValue", + ("read_only_space", 0x03325): "MinusZeroValue", + ("read_only_space", 0x03331): "MinusInfinityValue", + ("read_only_space", 0x0333d): "SelfReferenceMarker", + ("read_only_space", 0x0337d): "BasicBlockCountersMarker", + ("read_only_space", 0x033c1): "OffHeapTrampolineRelocationInfo", + ("read_only_space", 0x033cd): "TrampolineTrivialCodeDataContainer", + ("read_only_space", 0x033d9): "TrampolinePromiseRejectionCodeDataContainer", + ("read_only_space", 0x033e5): "GlobalThisBindingScopeInfo", + ("read_only_space", 0x0341d): "EmptyFunctionScopeInfo", + ("read_only_space", 0x03445): "NativeScopeInfo", + ("read_only_space", 0x03461): "HashSeed", ("old_space", 0x02115): "ArgumentsIteratorAccessor", ("old_space", 0x02159): "ArrayLengthAccessor", ("old_space", 0x0219d): "BoundFunctionLengthAccessor",