From cd0ca02aaf9686000994bf87f6e6ecc88a21d381 Mon Sep 17 00:00:00 2001 From: Manos Koukoutos Date: Wed, 27 Oct 2021 12:37:27 +0000 Subject: [PATCH] [wasm] Add WasmApiFunctionRef object This object will be used for the 'ref' field of WasmCapiFunctionData and WasmJSFunctionData, replacing the currently used pair. Design doc: https://bit.ly/3jEVgzz Bug: v8:11510 Change-Id: Ic5dec88458b562883d571b3463269b2308f489c5 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3236718 Reviewed-by: Michael Lippautz Reviewed-by: Jakob Kummerow Commit-Queue: Manos Koukoutos Cr-Commit-Position: refs/heads/main@{#77575} --- src/diagnostics/objects-printer.cc | 8 + src/heap/factory.cc | 16 + src/heap/factory.h | 1 + src/heap/objects-visiting.h | 1 + src/heap/setup-heap-internal.cc | 2 + src/objects/map.cc | 2 + src/objects/map.h | 1 + src/objects/object-list-macros.h | 1 + src/objects/objects-body-descriptors-inl.h | 21 + src/roots/roots.h | 1 + src/wasm/wasm-objects-inl.h | 1 + src/wasm/wasm-objects.h | 11 + src/wasm/wasm-objects.tq | 10 + tools/v8heapconst.py | 564 +++++++++++---------- 14 files changed, 359 insertions(+), 281 deletions(-) diff --git a/src/diagnostics/objects-printer.cc b/src/diagnostics/objects-printer.cc index b22b686fa4..d1fcf70ed6 100644 --- a/src/diagnostics/objects-printer.cc +++ b/src/diagnostics/objects-printer.cc @@ -1929,6 +1929,14 @@ void WasmJSFunctionData::WasmJSFunctionDataPrint(std::ostream& os) { os << "\n"; } +void WasmApiFunctionRef::WasmApiFunctionRefPrint(std::ostream& os) { + PrintHeader(os, "WasmApiFunctionRef"); + os << "\n - isolate_root: " << reinterpret_cast(foreign_address()); + os << "\n - native_context: " << Brief(native_context()); + os << "\n - callable: " << Brief(callable()); + os << "\n"; +} + void WasmCapiFunctionData::WasmCapiFunctionDataPrint(std::ostream& os) { PrintHeader(os, "WasmCapiFunctionData"); WasmFunctionDataPrint(os); diff --git a/src/heap/factory.cc b/src/heap/factory.cc index 93bdf21962..2602f0a0d5 100644 --- a/src/heap/factory.cc +++ b/src/heap/factory.cc @@ -1473,6 +1473,22 @@ Handle Factory::NewWasmTypeInfo( return handle(result, isolate()); } +Handle Factory::NewWasmApiFunctionRef( + Handle callable) { + Map map = *wasm_api_function_ref_map(); + auto result = WasmApiFunctionRef::cast(AllocateRawWithImmortalMap( + map.instance_size(), AllocationType::kOld, map)); + DisallowGarbageCollection no_gc; + result.set_foreign_address(isolate(), isolate()->isolate_root()); + result.set_native_context(*isolate()->native_context()); + if (!callable.is_null()) { + result.set_callable(*callable); + } else { + result.set_callable(*undefined_value()); + } + return handle(result, isolate()); +} + Handle Factory::NewWasmJSFunctionData( Address opt_call_target, Handle callable, int return_count, int parameter_count, Handle> serialized_sig, diff --git a/src/heap/factory.h b/src/heap/factory.h index 86a6ab47a4..f11687559f 100644 --- a/src/heap/factory.h +++ b/src/heap/factory.h @@ -576,6 +576,7 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase { Handle export_wrapper, Handle instance, Address call_target, Handle ref, int func_index, Address sig_address, int wrapper_budget); + Handle NewWasmApiFunctionRef(Handle callable); // {opt_call_target} is kNullAddress for JavaScript functions, and // non-null for exported Wasm functions. Handle NewWasmJSFunctionData( diff --git a/src/heap/objects-visiting.h b/src/heap/objects-visiting.h index 7babd44fb4..cd85ef715c 100644 --- a/src/heap/objects-visiting.h +++ b/src/heap/objects-visiting.h @@ -57,6 +57,7 @@ namespace internal { IF_WASM(V, WasmIndirectFunctionTable) \ IF_WASM(V, WasmInstanceObject) \ IF_WASM(V, WasmJSFunctionData) \ + IF_WASM(V, WasmApiFunctionRef) \ IF_WASM(V, WasmStruct) \ IF_WASM(V, WasmTypeInfo) diff --git a/src/heap/setup-heap-internal.cc b/src/heap/setup-heap-internal.cc index b3034dff8b..d54ea9c722 100644 --- a/src/heap/setup-heap-internal.cc +++ b/src/heap/setup-heap-internal.cc @@ -506,6 +506,8 @@ bool Heap::CreateInitialMaps() { WasmCapiFunctionData::kSize, wasm_capi_function_data) IF_WASM(ALLOCATE_MAP, WASM_EXPORTED_FUNCTION_DATA_TYPE, WasmExportedFunctionData::kSize, wasm_exported_function_data) + IF_WASM(ALLOCATE_MAP, WASM_API_FUNCTION_REF_TYPE, WasmApiFunctionRef::kSize, + wasm_api_function_ref) IF_WASM(ALLOCATE_MAP, WASM_JS_FUNCTION_DATA_TYPE, WasmJSFunctionData::kSize, wasm_js_function_data) IF_WASM(ALLOCATE_MAP, WASM_TYPE_INFO_TYPE, WasmTypeInfo::kSize, diff --git a/src/objects/map.cc b/src/objects/map.cc index 817e1864ac..e2ef2f8ce5 100644 --- a/src/objects/map.cc +++ b/src/objects/map.cc @@ -368,6 +368,8 @@ VisitorId Map::GetVisitorId(Map map) { return kVisitWasmTypeInfo; case WASM_JS_FUNCTION_DATA_TYPE: return kVisitWasmJSFunctionData; + case WASM_API_FUNCTION_REF_TYPE: + return kVisitWasmApiFunctionRef; case WASM_EXPORTED_FUNCTION_DATA_TYPE: return kVisitWasmExportedFunctionData; case WASM_CAPI_FUNCTION_DATA_TYPE: diff --git a/src/objects/map.h b/src/objects/map.h index d60890d910..4e1991579e 100644 --- a/src/objects/map.h +++ b/src/objects/map.h @@ -75,6 +75,7 @@ enum InstanceType : uint16_t; IF_WASM(V, WasmIndirectFunctionTable) \ IF_WASM(V, WasmInstanceObject) \ IF_WASM(V, WasmJSFunctionData) \ + IF_WASM(V, WasmApiFunctionRef) \ IF_WASM(V, WasmStruct) \ IF_WASM(V, WasmTypeInfo) \ V(WeakCell) diff --git a/src/objects/object-list-macros.h b/src/objects/object-list-macros.h index a55b82064e..40df12d83d 100644 --- a/src/objects/object-list-macros.h +++ b/src/objects/object-list-macros.h @@ -234,6 +234,7 @@ class ZoneForwardList; IF_WASM(V, WasmGlobalObject) \ IF_WASM(V, WasmInstanceObject) \ IF_WASM(V, WasmJSFunctionData) \ + IF_WASM(V, WasmApiFunctionRef) \ IF_WASM(V, WasmMemoryObject) \ IF_WASM(V, WasmModuleObject) \ IF_WASM(V, WasmObject) \ diff --git a/src/objects/objects-body-descriptors-inl.h b/src/objects/objects-body-descriptors-inl.h index 60cb8def38..6307f7f03d 100644 --- a/src/objects/objects-body-descriptors-inl.h +++ b/src/objects/objects-body-descriptors-inl.h @@ -641,6 +641,24 @@ class WasmJSFunctionData::BodyDescriptor final : public BodyDescriptorBase { static inline int SizeOf(Map map, HeapObject object) { return kSize; } }; +class WasmApiFunctionRef::BodyDescriptor final : public BodyDescriptorBase { + public: + static bool IsValidSlot(Map map, HeapObject obj, int offset) { + UNREACHABLE(); + } + + template + static inline void IterateBody(Map map, HeapObject obj, int object_size, + ObjectVisitor* v) { + Foreign::BodyDescriptor::IterateBody(map, obj, object_size, + v); + IteratePointers(obj, WasmFunctionData::kStartOfStrongFieldsOffset, + kEndOfStrongFieldsOffset, v); + } + + static inline int SizeOf(Map map, HeapObject object) { return kSize; } +}; + class WasmExportedFunctionData::BodyDescriptor final : public BodyDescriptorBase { public: @@ -1060,6 +1078,9 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) { case WASM_JS_FUNCTION_DATA_TYPE: return Op::template apply(p1, p2, p3, p4); + case WASM_API_FUNCTION_REF_TYPE: + return Op::template apply(p1, p2, p3, + p4); case WASM_STRUCT_TYPE: return Op::template apply(p1, p2, p3, p4); case WASM_TYPE_INFO_TYPE: diff --git a/src/roots/roots.h b/src/roots/roots.h index e7ec614c63..1a6c531a7f 100644 --- a/src/roots/roots.h +++ b/src/roots/roots.h @@ -115,6 +115,7 @@ class Symbol; IF_WASM(V, Map, wasm_exported_function_data_map, \ WasmExportedFunctionDataMap) \ IF_WASM(V, Map, wasm_js_function_data_map, WasmJSFunctionDataMap) \ + IF_WASM(V, Map, wasm_api_function_ref_map, WasmApiFunctionRefMap) \ IF_WASM(V, Map, wasm_type_info_map, WasmTypeInfoMap) \ V(Map, weak_fixed_array_map, WeakFixedArrayMap) \ V(Map, weak_array_list_map, WeakArrayListMap) \ diff --git a/src/wasm/wasm-objects-inl.h b/src/wasm/wasm-objects-inl.h index d17c3acb4c..e18d6c23d4 100644 --- a/src/wasm/wasm-objects-inl.h +++ b/src/wasm/wasm-objects-inl.h @@ -47,6 +47,7 @@ TQ_OBJECT_CONSTRUCTORS_IMPL(WasmModuleObject) TQ_OBJECT_CONSTRUCTORS_IMPL(WasmTableObject) TQ_OBJECT_CONSTRUCTORS_IMPL(AsmWasmData) TQ_OBJECT_CONSTRUCTORS_IMPL(WasmFunctionData) +TQ_OBJECT_CONSTRUCTORS_IMPL(WasmApiFunctionRef) TQ_OBJECT_CONSTRUCTORS_IMPL(WasmTypeInfo) TQ_OBJECT_CONSTRUCTORS_IMPL(WasmStruct) TQ_OBJECT_CONSTRUCTORS_IMPL(WasmArray) diff --git a/src/wasm/wasm-objects.h b/src/wasm/wasm-objects.h index b20a74ca61..dc007e3bdb 100644 --- a/src/wasm/wasm-objects.h +++ b/src/wasm/wasm-objects.h @@ -733,6 +733,17 @@ class WasmExportedFunctionData TQ_OBJECT_CONSTRUCTORS(WasmExportedFunctionData) }; +class WasmApiFunctionRef + : public TorqueGeneratedWasmApiFunctionRef { + public: + // Dispatched behavior. + DECL_PRINTER(WasmApiFunctionRef) + + class BodyDescriptor; + + TQ_OBJECT_CONSTRUCTORS(WasmApiFunctionRef) +}; + // Information for a WasmJSFunction which is referenced as the function data of // the SharedFunctionInfo underlying the function. For details please see the // {SharedFunctionInfo::HasWasmJSFunctionData} predicate. diff --git a/src/wasm/wasm-objects.tq b/src/wasm/wasm-objects.tq index d15bd1a690..8636964b51 100644 --- a/src/wasm/wasm-objects.tq +++ b/src/wasm/wasm-objects.tq @@ -11,6 +11,16 @@ type ManagedWasmNativeModule extends Foreign extern class WasmInstanceObject extends JSObject; +// Represents the context of a function that is defined through the JS or C +// APIs. Corresponds to the WasmInstanceObject passed to a Wasm function +// reference. +// The {foreign_address} field inherited from {Foreign} points the IsolateRoots +// of the defining isolate. +extern class WasmApiFunctionRef extends Foreign { + native_context: NativeContext; + callable: JSReceiver|Undefined; +} + extern class WasmFunctionData extends Foreign { // This is the "reference" value that must be passed along in the "instance" // register when calling the given function. It is either the target instance, diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py index de388db93d..592f119b22 100644 --- a/tools/v8heapconst.py +++ b/tools/v8heapconst.py @@ -36,126 +36,127 @@ INSTANCE_TYPES = { 72: "WASM_CAPI_FUNCTION_DATA_TYPE", 73: "WASM_EXPORTED_FUNCTION_DATA_TYPE", 74: "WASM_JS_FUNCTION_DATA_TYPE", - 75: "WASM_TYPE_INFO_TYPE", - 76: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE", - 77: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE", - 78: "CALLABLE_TASK_TYPE", - 79: "CALLBACK_TASK_TYPE", - 80: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE", - 81: "LOAD_HANDLER_TYPE", - 82: "STORE_HANDLER_TYPE", - 83: "FUNCTION_TEMPLATE_INFO_TYPE", - 84: "OBJECT_TEMPLATE_INFO_TYPE", - 85: "ACCESS_CHECK_INFO_TYPE", - 86: "ACCESSOR_INFO_TYPE", - 87: "ACCESSOR_PAIR_TYPE", - 88: "ALIASED_ARGUMENTS_ENTRY_TYPE", - 89: "ALLOCATION_MEMENTO_TYPE", - 90: "ALLOCATION_SITE_TYPE", - 91: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE", - 92: "ASM_WASM_DATA_TYPE", - 93: "ASYNC_GENERATOR_REQUEST_TYPE", - 94: "BREAK_POINT_TYPE", - 95: "BREAK_POINT_INFO_TYPE", - 96: "CACHED_TEMPLATE_OBJECT_TYPE", - 97: "CALL_HANDLER_INFO_TYPE", - 98: "CLASS_POSITIONS_TYPE", - 99: "DEBUG_INFO_TYPE", - 100: "ENUM_CACHE_TYPE", - 101: "FEEDBACK_CELL_TYPE", - 102: "FUNCTION_TEMPLATE_RARE_DATA_TYPE", - 103: "INTERCEPTOR_INFO_TYPE", - 104: "INTERPRETER_DATA_TYPE", - 105: "MODULE_REQUEST_TYPE", - 106: "PROMISE_CAPABILITY_TYPE", - 107: "PROMISE_REACTION_TYPE", - 108: "PROPERTY_DESCRIPTOR_OBJECT_TYPE", - 109: "PROTOTYPE_INFO_TYPE", - 110: "REG_EXP_BOILERPLATE_DESCRIPTION_TYPE", - 111: "SCRIPT_TYPE", - 112: "SCRIPT_OR_MODULE_TYPE", - 113: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE", - 114: "STACK_FRAME_INFO_TYPE", - 115: "TEMPLATE_OBJECT_DESCRIPTION_TYPE", - 116: "TUPLE2_TYPE", - 117: "WASM_CONTINUATION_OBJECT_TYPE", - 118: "WASM_EXCEPTION_TAG_TYPE", - 119: "WASM_INDIRECT_FUNCTION_TABLE_TYPE", - 120: "FIXED_ARRAY_TYPE", - 121: "HASH_TABLE_TYPE", - 122: "EPHEMERON_HASH_TABLE_TYPE", - 123: "GLOBAL_DICTIONARY_TYPE", - 124: "NAME_DICTIONARY_TYPE", - 125: "NUMBER_DICTIONARY_TYPE", - 126: "ORDERED_HASH_MAP_TYPE", - 127: "ORDERED_HASH_SET_TYPE", - 128: "ORDERED_NAME_DICTIONARY_TYPE", - 129: "SIMPLE_NUMBER_DICTIONARY_TYPE", - 130: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE", - 131: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE", - 132: "SCRIPT_CONTEXT_TABLE_TYPE", - 133: "BYTE_ARRAY_TYPE", - 134: "BYTECODE_ARRAY_TYPE", - 135: "FIXED_DOUBLE_ARRAY_TYPE", - 136: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE", - 137: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE", - 138: "AWAIT_CONTEXT_TYPE", - 139: "BLOCK_CONTEXT_TYPE", - 140: "CATCH_CONTEXT_TYPE", - 141: "DEBUG_EVALUATE_CONTEXT_TYPE", - 142: "EVAL_CONTEXT_TYPE", - 143: "FUNCTION_CONTEXT_TYPE", - 144: "MODULE_CONTEXT_TYPE", - 145: "NATIVE_CONTEXT_TYPE", - 146: "SCRIPT_CONTEXT_TYPE", - 147: "WITH_CONTEXT_TYPE", - 148: "EXPORTED_SUB_CLASS_BASE_TYPE", - 149: "EXPORTED_SUB_CLASS_TYPE", - 150: "EXPORTED_SUB_CLASS2_TYPE", - 151: "SMALL_ORDERED_HASH_MAP_TYPE", - 152: "SMALL_ORDERED_HASH_SET_TYPE", - 153: "SMALL_ORDERED_NAME_DICTIONARY_TYPE", - 154: "DESCRIPTOR_ARRAY_TYPE", - 155: "STRONG_DESCRIPTOR_ARRAY_TYPE", - 156: "SOURCE_TEXT_MODULE_TYPE", - 157: "SYNTHETIC_MODULE_TYPE", - 158: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE", - 159: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE", - 160: "WEAK_FIXED_ARRAY_TYPE", - 161: "TRANSITION_ARRAY_TYPE", - 162: "CALL_REF_DATA_TYPE", - 163: "CELL_TYPE", - 164: "CODE_TYPE", - 165: "CODE_DATA_CONTAINER_TYPE", - 166: "COVERAGE_INFO_TYPE", - 167: "EMBEDDER_DATA_ARRAY_TYPE", - 168: "FEEDBACK_METADATA_TYPE", - 169: "FEEDBACK_VECTOR_TYPE", - 170: "FILLER_TYPE", - 171: "FREE_SPACE_TYPE", - 172: "INTERNAL_CLASS_TYPE", - 173: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE", - 174: "MAP_TYPE", - 175: "MEGA_DOM_HANDLER_TYPE", - 176: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE", - 177: "PREPARSE_DATA_TYPE", - 178: "PROPERTY_ARRAY_TYPE", - 179: "PROPERTY_CELL_TYPE", - 180: "SCOPE_INFO_TYPE", - 181: "SHARED_FUNCTION_INFO_TYPE", - 182: "SMI_BOX_TYPE", - 183: "SMI_PAIR_TYPE", - 184: "SORT_STATE_TYPE", - 185: "SWISS_NAME_DICTIONARY_TYPE", - 186: "WEAK_ARRAY_LIST_TYPE", - 187: "WEAK_CELL_TYPE", - 188: "WASM_ARRAY_TYPE", - 189: "WASM_STRUCT_TYPE", - 190: "JS_PROXY_TYPE", + 75: "WASM_API_FUNCTION_REF_TYPE", + 76: "WASM_TYPE_INFO_TYPE", + 77: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE", + 78: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE", + 79: "CALLABLE_TASK_TYPE", + 80: "CALLBACK_TASK_TYPE", + 81: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE", + 82: "LOAD_HANDLER_TYPE", + 83: "STORE_HANDLER_TYPE", + 84: "FUNCTION_TEMPLATE_INFO_TYPE", + 85: "OBJECT_TEMPLATE_INFO_TYPE", + 86: "ACCESS_CHECK_INFO_TYPE", + 87: "ACCESSOR_INFO_TYPE", + 88: "ACCESSOR_PAIR_TYPE", + 89: "ALIASED_ARGUMENTS_ENTRY_TYPE", + 90: "ALLOCATION_MEMENTO_TYPE", + 91: "ALLOCATION_SITE_TYPE", + 92: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE", + 93: "ASM_WASM_DATA_TYPE", + 94: "ASYNC_GENERATOR_REQUEST_TYPE", + 95: "BREAK_POINT_TYPE", + 96: "BREAK_POINT_INFO_TYPE", + 97: "CACHED_TEMPLATE_OBJECT_TYPE", + 98: "CALL_HANDLER_INFO_TYPE", + 99: "CLASS_POSITIONS_TYPE", + 100: "DEBUG_INFO_TYPE", + 101: "ENUM_CACHE_TYPE", + 102: "FEEDBACK_CELL_TYPE", + 103: "FUNCTION_TEMPLATE_RARE_DATA_TYPE", + 104: "INTERCEPTOR_INFO_TYPE", + 105: "INTERPRETER_DATA_TYPE", + 106: "MODULE_REQUEST_TYPE", + 107: "PROMISE_CAPABILITY_TYPE", + 108: "PROMISE_REACTION_TYPE", + 109: "PROPERTY_DESCRIPTOR_OBJECT_TYPE", + 110: "PROTOTYPE_INFO_TYPE", + 111: "REG_EXP_BOILERPLATE_DESCRIPTION_TYPE", + 112: "SCRIPT_TYPE", + 113: "SCRIPT_OR_MODULE_TYPE", + 114: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE", + 115: "STACK_FRAME_INFO_TYPE", + 116: "TEMPLATE_OBJECT_DESCRIPTION_TYPE", + 117: "TUPLE2_TYPE", + 118: "WASM_CONTINUATION_OBJECT_TYPE", + 119: "WASM_EXCEPTION_TAG_TYPE", + 120: "WASM_INDIRECT_FUNCTION_TABLE_TYPE", + 121: "FIXED_ARRAY_TYPE", + 122: "HASH_TABLE_TYPE", + 123: "EPHEMERON_HASH_TABLE_TYPE", + 124: "GLOBAL_DICTIONARY_TYPE", + 125: "NAME_DICTIONARY_TYPE", + 126: "NUMBER_DICTIONARY_TYPE", + 127: "ORDERED_HASH_MAP_TYPE", + 128: "ORDERED_HASH_SET_TYPE", + 129: "ORDERED_NAME_DICTIONARY_TYPE", + 130: "SIMPLE_NUMBER_DICTIONARY_TYPE", + 131: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE", + 132: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE", + 133: "SCRIPT_CONTEXT_TABLE_TYPE", + 134: "BYTE_ARRAY_TYPE", + 135: "BYTECODE_ARRAY_TYPE", + 136: "FIXED_DOUBLE_ARRAY_TYPE", + 137: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE", + 138: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE", + 139: "AWAIT_CONTEXT_TYPE", + 140: "BLOCK_CONTEXT_TYPE", + 141: "CATCH_CONTEXT_TYPE", + 142: "DEBUG_EVALUATE_CONTEXT_TYPE", + 143: "EVAL_CONTEXT_TYPE", + 144: "FUNCTION_CONTEXT_TYPE", + 145: "MODULE_CONTEXT_TYPE", + 146: "NATIVE_CONTEXT_TYPE", + 147: "SCRIPT_CONTEXT_TYPE", + 148: "WITH_CONTEXT_TYPE", + 149: "EXPORTED_SUB_CLASS_BASE_TYPE", + 150: "EXPORTED_SUB_CLASS_TYPE", + 151: "EXPORTED_SUB_CLASS2_TYPE", + 152: "SMALL_ORDERED_HASH_MAP_TYPE", + 153: "SMALL_ORDERED_HASH_SET_TYPE", + 154: "SMALL_ORDERED_NAME_DICTIONARY_TYPE", + 155: "DESCRIPTOR_ARRAY_TYPE", + 156: "STRONG_DESCRIPTOR_ARRAY_TYPE", + 157: "SOURCE_TEXT_MODULE_TYPE", + 158: "SYNTHETIC_MODULE_TYPE", + 159: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE", + 160: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE", + 161: "WEAK_FIXED_ARRAY_TYPE", + 162: "TRANSITION_ARRAY_TYPE", + 163: "CALL_REF_DATA_TYPE", + 164: "CELL_TYPE", + 165: "CODE_TYPE", + 166: "CODE_DATA_CONTAINER_TYPE", + 167: "COVERAGE_INFO_TYPE", + 168: "EMBEDDER_DATA_ARRAY_TYPE", + 169: "FEEDBACK_METADATA_TYPE", + 170: "FEEDBACK_VECTOR_TYPE", + 171: "FILLER_TYPE", + 172: "FREE_SPACE_TYPE", + 173: "INTERNAL_CLASS_TYPE", + 174: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE", + 175: "MAP_TYPE", + 176: "MEGA_DOM_HANDLER_TYPE", + 177: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE", + 178: "PREPARSE_DATA_TYPE", + 179: "PROPERTY_ARRAY_TYPE", + 180: "PROPERTY_CELL_TYPE", + 181: "SCOPE_INFO_TYPE", + 182: "SHARED_FUNCTION_INFO_TYPE", + 183: "SMI_BOX_TYPE", + 184: "SMI_PAIR_TYPE", + 185: "SORT_STATE_TYPE", + 186: "SWISS_NAME_DICTIONARY_TYPE", + 187: "WEAK_ARRAY_LIST_TYPE", + 188: "WEAK_CELL_TYPE", + 189: "WASM_ARRAY_TYPE", + 190: "WASM_STRUCT_TYPE", + 191: "JS_PROXY_TYPE", 1057: "JS_OBJECT_TYPE", - 191: "JS_GLOBAL_OBJECT_TYPE", - 192: "JS_GLOBAL_PROXY_TYPE", - 193: "JS_MODULE_NAMESPACE_TYPE", + 192: "JS_GLOBAL_OBJECT_TYPE", + 193: "JS_GLOBAL_PROXY_TYPE", + 194: "JS_MODULE_NAMESPACE_TYPE", 1040: "JS_SPECIAL_API_OBJECT_TYPE", 1041: "JS_PRIMITIVE_WRAPPER_TYPE", 1058: "JS_API_OBJECT_TYPE", @@ -249,162 +250,163 @@ INSTANCE_TYPES = { # List of known V8 maps. KNOWN_MAPS = { - ("read_only_space", 0x02119): (174, "MetaMap"), + ("read_only_space", 0x02119): (175, "MetaMap"), ("read_only_space", 0x02141): (67, "NullMap"), - ("read_only_space", 0x02169): (155, "StrongDescriptorArrayMap"), - ("read_only_space", 0x02191): (160, "WeakFixedArrayMap"), - ("read_only_space", 0x021d1): (100, "EnumCacheMap"), - ("read_only_space", 0x02205): (120, "FixedArrayMap"), + ("read_only_space", 0x02169): (156, "StrongDescriptorArrayMap"), + ("read_only_space", 0x02191): (161, "WeakFixedArrayMap"), + ("read_only_space", 0x021d1): (101, "EnumCacheMap"), + ("read_only_space", 0x02205): (121, "FixedArrayMap"), ("read_only_space", 0x02251): (8, "OneByteInternalizedStringMap"), - ("read_only_space", 0x0229d): (171, "FreeSpaceMap"), - ("read_only_space", 0x022c5): (170, "OnePointerFillerMap"), - ("read_only_space", 0x022ed): (170, "TwoPointerFillerMap"), + ("read_only_space", 0x0229d): (172, "FreeSpaceMap"), + ("read_only_space", 0x022c5): (171, "OnePointerFillerMap"), + ("read_only_space", 0x022ed): (171, "TwoPointerFillerMap"), ("read_only_space", 0x02315): (67, "UninitializedMap"), ("read_only_space", 0x0238d): (67, "UndefinedMap"), ("read_only_space", 0x023d1): (66, "HeapNumberMap"), ("read_only_space", 0x02405): (67, "TheHoleMap"), ("read_only_space", 0x02465): (67, "BooleanMap"), - ("read_only_space", 0x02509): (133, "ByteArrayMap"), - ("read_only_space", 0x02531): (120, "FixedCOWArrayMap"), - ("read_only_space", 0x02559): (121, "HashTableMap"), + ("read_only_space", 0x02509): (134, "ByteArrayMap"), + ("read_only_space", 0x02531): (121, "FixedCOWArrayMap"), + ("read_only_space", 0x02559): (122, "HashTableMap"), ("read_only_space", 0x02581): (64, "SymbolMap"), ("read_only_space", 0x025a9): (40, "OneByteStringMap"), - ("read_only_space", 0x025d1): (180, "ScopeInfoMap"), - ("read_only_space", 0x025f9): (181, "SharedFunctionInfoMap"), - ("read_only_space", 0x02621): (164, "CodeMap"), - ("read_only_space", 0x02649): (163, "CellMap"), - ("read_only_space", 0x02671): (179, "GlobalPropertyCellMap"), + ("read_only_space", 0x025d1): (181, "ScopeInfoMap"), + ("read_only_space", 0x025f9): (182, "SharedFunctionInfoMap"), + ("read_only_space", 0x02621): (165, "CodeMap"), + ("read_only_space", 0x02649): (164, "CellMap"), + ("read_only_space", 0x02671): (180, "GlobalPropertyCellMap"), ("read_only_space", 0x02699): (70, "ForeignMap"), - ("read_only_space", 0x026c1): (161, "TransitionArrayMap"), + ("read_only_space", 0x026c1): (162, "TransitionArrayMap"), ("read_only_space", 0x026e9): (45, "ThinOneByteStringMap"), - ("read_only_space", 0x02711): (169, "FeedbackVectorMap"), + ("read_only_space", 0x02711): (170, "FeedbackVectorMap"), ("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): (132, "ScriptContextTableMap"), - ("read_only_space", 0x02955): (130, "ClosureFeedbackCellArrayMap"), - ("read_only_space", 0x0297d): (168, "FeedbackMetadataArrayMap"), - ("read_only_space", 0x029a5): (120, "ArrayListMap"), + ("read_only_space", 0x0292d): (133, "ScriptContextTableMap"), + ("read_only_space", 0x02955): (131, "ClosureFeedbackCellArrayMap"), + ("read_only_space", 0x0297d): (169, "FeedbackMetadataArrayMap"), + ("read_only_space", 0x029a5): (121, "ArrayListMap"), ("read_only_space", 0x029cd): (65, "BigIntMap"), - ("read_only_space", 0x029f5): (131, "ObjectBoilerplateDescriptionMap"), - ("read_only_space", 0x02a1d): (134, "BytecodeArrayMap"), - ("read_only_space", 0x02a45): (165, "CodeDataContainerMap"), - ("read_only_space", 0x02a6d): (166, "CoverageInfoMap"), - ("read_only_space", 0x02a95): (135, "FixedDoubleArrayMap"), - ("read_only_space", 0x02abd): (123, "GlobalDictionaryMap"), - ("read_only_space", 0x02ae5): (101, "ManyClosuresCellMap"), - ("read_only_space", 0x02b0d): (175, "MegaDomHandlerMap"), - ("read_only_space", 0x02b35): (120, "ModuleInfoMap"), - ("read_only_space", 0x02b5d): (124, "NameDictionaryMap"), - ("read_only_space", 0x02b85): (101, "NoClosuresCellMap"), - ("read_only_space", 0x02bad): (125, "NumberDictionaryMap"), - ("read_only_space", 0x02bd5): (101, "OneClosureCellMap"), - ("read_only_space", 0x02bfd): (126, "OrderedHashMapMap"), - ("read_only_space", 0x02c25): (127, "OrderedHashSetMap"), - ("read_only_space", 0x02c4d): (128, "OrderedNameDictionaryMap"), - ("read_only_space", 0x02c75): (177, "PreparseDataMap"), - ("read_only_space", 0x02c9d): (178, "PropertyArrayMap"), - ("read_only_space", 0x02cc5): (97, "SideEffectCallHandlerInfoMap"), - ("read_only_space", 0x02ced): (97, "SideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x02d15): (97, "NextCallSideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x02d3d): (129, "SimpleNumberDictionaryMap"), - ("read_only_space", 0x02d65): (151, "SmallOrderedHashMapMap"), - ("read_only_space", 0x02d8d): (152, "SmallOrderedHashSetMap"), - ("read_only_space", 0x02db5): (153, "SmallOrderedNameDictionaryMap"), - ("read_only_space", 0x02ddd): (156, "SourceTextModuleMap"), - ("read_only_space", 0x02e05): (185, "SwissNameDictionaryMap"), - ("read_only_space", 0x02e2d): (157, "SyntheticModuleMap"), + ("read_only_space", 0x029f5): (132, "ObjectBoilerplateDescriptionMap"), + ("read_only_space", 0x02a1d): (135, "BytecodeArrayMap"), + ("read_only_space", 0x02a45): (166, "CodeDataContainerMap"), + ("read_only_space", 0x02a6d): (167, "CoverageInfoMap"), + ("read_only_space", 0x02a95): (136, "FixedDoubleArrayMap"), + ("read_only_space", 0x02abd): (124, "GlobalDictionaryMap"), + ("read_only_space", 0x02ae5): (102, "ManyClosuresCellMap"), + ("read_only_space", 0x02b0d): (176, "MegaDomHandlerMap"), + ("read_only_space", 0x02b35): (121, "ModuleInfoMap"), + ("read_only_space", 0x02b5d): (125, "NameDictionaryMap"), + ("read_only_space", 0x02b85): (102, "NoClosuresCellMap"), + ("read_only_space", 0x02bad): (126, "NumberDictionaryMap"), + ("read_only_space", 0x02bd5): (102, "OneClosureCellMap"), + ("read_only_space", 0x02bfd): (127, "OrderedHashMapMap"), + ("read_only_space", 0x02c25): (128, "OrderedHashSetMap"), + ("read_only_space", 0x02c4d): (129, "OrderedNameDictionaryMap"), + ("read_only_space", 0x02c75): (178, "PreparseDataMap"), + ("read_only_space", 0x02c9d): (179, "PropertyArrayMap"), + ("read_only_space", 0x02cc5): (98, "SideEffectCallHandlerInfoMap"), + ("read_only_space", 0x02ced): (98, "SideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x02d15): (98, "NextCallSideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x02d3d): (130, "SimpleNumberDictionaryMap"), + ("read_only_space", 0x02d65): (152, "SmallOrderedHashMapMap"), + ("read_only_space", 0x02d8d): (153, "SmallOrderedHashSetMap"), + ("read_only_space", 0x02db5): (154, "SmallOrderedNameDictionaryMap"), + ("read_only_space", 0x02ddd): (157, "SourceTextModuleMap"), + ("read_only_space", 0x02e05): (186, "SwissNameDictionaryMap"), + ("read_only_space", 0x02e2d): (158, "SyntheticModuleMap"), ("read_only_space", 0x02e55): (72, "WasmCapiFunctionDataMap"), ("read_only_space", 0x02e7d): (73, "WasmExportedFunctionDataMap"), ("read_only_space", 0x02ea5): (74, "WasmJSFunctionDataMap"), - ("read_only_space", 0x02ecd): (75, "WasmTypeInfoMap"), - ("read_only_space", 0x02ef5): (186, "WeakArrayListMap"), - ("read_only_space", 0x02f1d): (122, "EphemeronHashTableMap"), - ("read_only_space", 0x02f45): (167, "EmbedderDataArrayMap"), - ("read_only_space", 0x02f6d): (187, "WeakCellMap"), - ("read_only_space", 0x02f95): (32, "StringMap"), - ("read_only_space", 0x02fbd): (41, "ConsOneByteStringMap"), - ("read_only_space", 0x02fe5): (33, "ConsStringMap"), - ("read_only_space", 0x0300d): (37, "ThinStringMap"), - ("read_only_space", 0x03035): (35, "SlicedStringMap"), - ("read_only_space", 0x0305d): (43, "SlicedOneByteStringMap"), - ("read_only_space", 0x03085): (34, "ExternalStringMap"), - ("read_only_space", 0x030ad): (42, "ExternalOneByteStringMap"), - ("read_only_space", 0x030d5): (50, "UncachedExternalStringMap"), - ("read_only_space", 0x030fd): (0, "InternalizedStringMap"), - ("read_only_space", 0x03125): (2, "ExternalInternalizedStringMap"), - ("read_only_space", 0x0314d): (10, "ExternalOneByteInternalizedStringMap"), - ("read_only_space", 0x03175): (18, "UncachedExternalInternalizedStringMap"), - ("read_only_space", 0x0319d): (26, "UncachedExternalOneByteInternalizedStringMap"), - ("read_only_space", 0x031c5): (58, "UncachedExternalOneByteStringMap"), - ("read_only_space", 0x031ed): (67, "SelfReferenceMarkerMap"), - ("read_only_space", 0x03215): (67, "BasicBlockCountersMarkerMap"), - ("read_only_space", 0x03259): (91, "ArrayBoilerplateDescriptionMap"), - ("read_only_space", 0x03359): (103, "InterceptorInfoMap"), - ("read_only_space", 0x05bed): (76, "PromiseFulfillReactionJobTaskMap"), - ("read_only_space", 0x05c15): (77, "PromiseRejectReactionJobTaskMap"), - ("read_only_space", 0x05c3d): (78, "CallableTaskMap"), - ("read_only_space", 0x05c65): (79, "CallbackTaskMap"), - ("read_only_space", 0x05c8d): (80, "PromiseResolveThenableJobTaskMap"), - ("read_only_space", 0x05cb5): (83, "FunctionTemplateInfoMap"), - ("read_only_space", 0x05cdd): (84, "ObjectTemplateInfoMap"), - ("read_only_space", 0x05d05): (85, "AccessCheckInfoMap"), - ("read_only_space", 0x05d2d): (86, "AccessorInfoMap"), - ("read_only_space", 0x05d55): (87, "AccessorPairMap"), - ("read_only_space", 0x05d7d): (88, "AliasedArgumentsEntryMap"), - ("read_only_space", 0x05da5): (89, "AllocationMementoMap"), - ("read_only_space", 0x05dcd): (92, "AsmWasmDataMap"), - ("read_only_space", 0x05df5): (93, "AsyncGeneratorRequestMap"), - ("read_only_space", 0x05e1d): (94, "BreakPointMap"), - ("read_only_space", 0x05e45): (95, "BreakPointInfoMap"), - ("read_only_space", 0x05e6d): (96, "CachedTemplateObjectMap"), - ("read_only_space", 0x05e95): (98, "ClassPositionsMap"), - ("read_only_space", 0x05ebd): (99, "DebugInfoMap"), - ("read_only_space", 0x05ee5): (102, "FunctionTemplateRareDataMap"), - ("read_only_space", 0x05f0d): (104, "InterpreterDataMap"), - ("read_only_space", 0x05f35): (105, "ModuleRequestMap"), - ("read_only_space", 0x05f5d): (106, "PromiseCapabilityMap"), - ("read_only_space", 0x05f85): (107, "PromiseReactionMap"), - ("read_only_space", 0x05fad): (108, "PropertyDescriptorObjectMap"), - ("read_only_space", 0x05fd5): (109, "PrototypeInfoMap"), - ("read_only_space", 0x05ffd): (110, "RegExpBoilerplateDescriptionMap"), - ("read_only_space", 0x06025): (111, "ScriptMap"), - ("read_only_space", 0x0604d): (112, "ScriptOrModuleMap"), - ("read_only_space", 0x06075): (113, "SourceTextModuleInfoEntryMap"), - ("read_only_space", 0x0609d): (114, "StackFrameInfoMap"), - ("read_only_space", 0x060c5): (115, "TemplateObjectDescriptionMap"), - ("read_only_space", 0x060ed): (116, "Tuple2Map"), - ("read_only_space", 0x06115): (117, "WasmContinuationObjectMap"), - ("read_only_space", 0x0613d): (118, "WasmExceptionTagMap"), - ("read_only_space", 0x06165): (119, "WasmIndirectFunctionTableMap"), - ("read_only_space", 0x0618d): (137, "SloppyArgumentsElementsMap"), - ("read_only_space", 0x061b5): (154, "DescriptorArrayMap"), - ("read_only_space", 0x061dd): (159, "UncompiledDataWithoutPreparseDataMap"), - ("read_only_space", 0x06205): (158, "UncompiledDataWithPreparseDataMap"), - ("read_only_space", 0x0622d): (176, "OnHeapBasicBlockProfilerDataMap"), - ("read_only_space", 0x06255): (172, "InternalClassMap"), - ("read_only_space", 0x0627d): (183, "SmiPairMap"), - ("read_only_space", 0x062a5): (182, "SmiBoxMap"), - ("read_only_space", 0x062cd): (148, "ExportedSubClassBaseMap"), - ("read_only_space", 0x062f5): (149, "ExportedSubClassMap"), - ("read_only_space", 0x0631d): (68, "AbstractInternalClassSubclass1Map"), - ("read_only_space", 0x06345): (69, "AbstractInternalClassSubclass2Map"), - ("read_only_space", 0x0636d): (136, "InternalClassWithSmiElementsMap"), - ("read_only_space", 0x06395): (173, "InternalClassWithStructElementsMap"), - ("read_only_space", 0x063bd): (150, "ExportedSubClass2Map"), - ("read_only_space", 0x063e5): (184, "SortStateMap"), - ("read_only_space", 0x0640d): (162, "CallRefDataMap"), - ("read_only_space", 0x06435): (90, "AllocationSiteWithWeakNextMap"), - ("read_only_space", 0x0645d): (90, "AllocationSiteWithoutWeakNextMap"), - ("read_only_space", 0x06485): (81, "LoadHandler1Map"), - ("read_only_space", 0x064ad): (81, "LoadHandler2Map"), - ("read_only_space", 0x064d5): (81, "LoadHandler3Map"), - ("read_only_space", 0x064fd): (82, "StoreHandler0Map"), - ("read_only_space", 0x06525): (82, "StoreHandler1Map"), - ("read_only_space", 0x0654d): (82, "StoreHandler2Map"), - ("read_only_space", 0x06575): (82, "StoreHandler3Map"), + ("read_only_space", 0x02ecd): (75, "WasmApiFunctionRefMap"), + ("read_only_space", 0x02ef5): (76, "WasmTypeInfoMap"), + ("read_only_space", 0x02f1d): (187, "WeakArrayListMap"), + ("read_only_space", 0x02f45): (123, "EphemeronHashTableMap"), + ("read_only_space", 0x02f6d): (168, "EmbedderDataArrayMap"), + ("read_only_space", 0x02f95): (188, "WeakCellMap"), + ("read_only_space", 0x02fbd): (32, "StringMap"), + ("read_only_space", 0x02fe5): (41, "ConsOneByteStringMap"), + ("read_only_space", 0x0300d): (33, "ConsStringMap"), + ("read_only_space", 0x03035): (37, "ThinStringMap"), + ("read_only_space", 0x0305d): (35, "SlicedStringMap"), + ("read_only_space", 0x03085): (43, "SlicedOneByteStringMap"), + ("read_only_space", 0x030ad): (34, "ExternalStringMap"), + ("read_only_space", 0x030d5): (42, "ExternalOneByteStringMap"), + ("read_only_space", 0x030fd): (50, "UncachedExternalStringMap"), + ("read_only_space", 0x03125): (0, "InternalizedStringMap"), + ("read_only_space", 0x0314d): (2, "ExternalInternalizedStringMap"), + ("read_only_space", 0x03175): (10, "ExternalOneByteInternalizedStringMap"), + ("read_only_space", 0x0319d): (18, "UncachedExternalInternalizedStringMap"), + ("read_only_space", 0x031c5): (26, "UncachedExternalOneByteInternalizedStringMap"), + ("read_only_space", 0x031ed): (58, "UncachedExternalOneByteStringMap"), + ("read_only_space", 0x03215): (67, "SelfReferenceMarkerMap"), + ("read_only_space", 0x0323d): (67, "BasicBlockCountersMarkerMap"), + ("read_only_space", 0x03281): (92, "ArrayBoilerplateDescriptionMap"), + ("read_only_space", 0x03381): (104, "InterceptorInfoMap"), + ("read_only_space", 0x05c15): (77, "PromiseFulfillReactionJobTaskMap"), + ("read_only_space", 0x05c3d): (78, "PromiseRejectReactionJobTaskMap"), + ("read_only_space", 0x05c65): (79, "CallableTaskMap"), + ("read_only_space", 0x05c8d): (80, "CallbackTaskMap"), + ("read_only_space", 0x05cb5): (81, "PromiseResolveThenableJobTaskMap"), + ("read_only_space", 0x05cdd): (84, "FunctionTemplateInfoMap"), + ("read_only_space", 0x05d05): (85, "ObjectTemplateInfoMap"), + ("read_only_space", 0x05d2d): (86, "AccessCheckInfoMap"), + ("read_only_space", 0x05d55): (87, "AccessorInfoMap"), + ("read_only_space", 0x05d7d): (88, "AccessorPairMap"), + ("read_only_space", 0x05da5): (89, "AliasedArgumentsEntryMap"), + ("read_only_space", 0x05dcd): (90, "AllocationMementoMap"), + ("read_only_space", 0x05df5): (93, "AsmWasmDataMap"), + ("read_only_space", 0x05e1d): (94, "AsyncGeneratorRequestMap"), + ("read_only_space", 0x05e45): (95, "BreakPointMap"), + ("read_only_space", 0x05e6d): (96, "BreakPointInfoMap"), + ("read_only_space", 0x05e95): (97, "CachedTemplateObjectMap"), + ("read_only_space", 0x05ebd): (99, "ClassPositionsMap"), + ("read_only_space", 0x05ee5): (100, "DebugInfoMap"), + ("read_only_space", 0x05f0d): (103, "FunctionTemplateRareDataMap"), + ("read_only_space", 0x05f35): (105, "InterpreterDataMap"), + ("read_only_space", 0x05f5d): (106, "ModuleRequestMap"), + ("read_only_space", 0x05f85): (107, "PromiseCapabilityMap"), + ("read_only_space", 0x05fad): (108, "PromiseReactionMap"), + ("read_only_space", 0x05fd5): (109, "PropertyDescriptorObjectMap"), + ("read_only_space", 0x05ffd): (110, "PrototypeInfoMap"), + ("read_only_space", 0x06025): (111, "RegExpBoilerplateDescriptionMap"), + ("read_only_space", 0x0604d): (112, "ScriptMap"), + ("read_only_space", 0x06075): (113, "ScriptOrModuleMap"), + ("read_only_space", 0x0609d): (114, "SourceTextModuleInfoEntryMap"), + ("read_only_space", 0x060c5): (115, "StackFrameInfoMap"), + ("read_only_space", 0x060ed): (116, "TemplateObjectDescriptionMap"), + ("read_only_space", 0x06115): (117, "Tuple2Map"), + ("read_only_space", 0x0613d): (118, "WasmContinuationObjectMap"), + ("read_only_space", 0x06165): (119, "WasmExceptionTagMap"), + ("read_only_space", 0x0618d): (120, "WasmIndirectFunctionTableMap"), + ("read_only_space", 0x061b5): (138, "SloppyArgumentsElementsMap"), + ("read_only_space", 0x061dd): (155, "DescriptorArrayMap"), + ("read_only_space", 0x06205): (160, "UncompiledDataWithoutPreparseDataMap"), + ("read_only_space", 0x0622d): (159, "UncompiledDataWithPreparseDataMap"), + ("read_only_space", 0x06255): (177, "OnHeapBasicBlockProfilerDataMap"), + ("read_only_space", 0x0627d): (173, "InternalClassMap"), + ("read_only_space", 0x062a5): (184, "SmiPairMap"), + ("read_only_space", 0x062cd): (183, "SmiBoxMap"), + ("read_only_space", 0x062f5): (149, "ExportedSubClassBaseMap"), + ("read_only_space", 0x0631d): (150, "ExportedSubClassMap"), + ("read_only_space", 0x06345): (68, "AbstractInternalClassSubclass1Map"), + ("read_only_space", 0x0636d): (69, "AbstractInternalClassSubclass2Map"), + ("read_only_space", 0x06395): (137, "InternalClassWithSmiElementsMap"), + ("read_only_space", 0x063bd): (174, "InternalClassWithStructElementsMap"), + ("read_only_space", 0x063e5): (151, "ExportedSubClass2Map"), + ("read_only_space", 0x0640d): (185, "SortStateMap"), + ("read_only_space", 0x06435): (163, "CallRefDataMap"), + ("read_only_space", 0x0645d): (91, "AllocationSiteWithWeakNextMap"), + ("read_only_space", 0x06485): (91, "AllocationSiteWithoutWeakNextMap"), + ("read_only_space", 0x064ad): (82, "LoadHandler1Map"), + ("read_only_space", 0x064d5): (82, "LoadHandler2Map"), + ("read_only_space", 0x064fd): (82, "LoadHandler3Map"), + ("read_only_space", 0x06525): (83, "StoreHandler0Map"), + ("read_only_space", 0x0654d): (83, "StoreHandler1Map"), + ("read_only_space", 0x06575): (83, "StoreHandler2Map"), + ("read_only_space", 0x0659d): (83, "StoreHandler3Map"), ("map_space", 0x02119): (1057, "ExternalMap"), ("map_space", 0x02141): (2114, "JSMessageObjectMap"), } @@ -430,32 +432,32 @@ KNOWN_OBJECTS = { ("read_only_space", 0x0282d): "TerminationException", ("read_only_space", 0x02895): "OptimizedOut", ("read_only_space", 0x028f5): "StaleRegister", - ("read_only_space", 0x0323d): "EmptyPropertyArray", - ("read_only_space", 0x03245): "EmptyByteArray", - ("read_only_space", 0x0324d): "EmptyObjectBoilerplateDescription", - ("read_only_space", 0x03281): "EmptyArrayBoilerplateDescription", - ("read_only_space", 0x0328d): "EmptyClosureFeedbackCellArray", - ("read_only_space", 0x03295): "EmptySlowElementDictionary", - ("read_only_space", 0x032b9): "EmptyOrderedHashMap", - ("read_only_space", 0x032cd): "EmptyOrderedHashSet", - ("read_only_space", 0x032e1): "EmptyFeedbackMetadata", - ("read_only_space", 0x032ed): "EmptyPropertyDictionary", - ("read_only_space", 0x03315): "EmptyOrderedPropertyDictionary", - ("read_only_space", 0x0332d): "EmptySwissPropertyDictionary", - ("read_only_space", 0x03381): "NoOpInterceptorInfo", - ("read_only_space", 0x033a9): "EmptyWeakArrayList", - ("read_only_space", 0x033b5): "InfinityValue", - ("read_only_space", 0x033c1): "MinusZeroValue", - ("read_only_space", 0x033cd): "MinusInfinityValue", - ("read_only_space", 0x033d9): "SelfReferenceMarker", - ("read_only_space", 0x03419): "BasicBlockCountersMarker", - ("read_only_space", 0x0345d): "OffHeapTrampolineRelocationInfo", - ("read_only_space", 0x03469): "TrampolineTrivialCodeDataContainer", - ("read_only_space", 0x03475): "TrampolinePromiseRejectionCodeDataContainer", - ("read_only_space", 0x03481): "GlobalThisBindingScopeInfo", - ("read_only_space", 0x034b1): "EmptyFunctionScopeInfo", - ("read_only_space", 0x034d5): "NativeScopeInfo", - ("read_only_space", 0x034ed): "HashSeed", + ("read_only_space", 0x03265): "EmptyPropertyArray", + ("read_only_space", 0x0326d): "EmptyByteArray", + ("read_only_space", 0x03275): "EmptyObjectBoilerplateDescription", + ("read_only_space", 0x032a9): "EmptyArrayBoilerplateDescription", + ("read_only_space", 0x032b5): "EmptyClosureFeedbackCellArray", + ("read_only_space", 0x032bd): "EmptySlowElementDictionary", + ("read_only_space", 0x032e1): "EmptyOrderedHashMap", + ("read_only_space", 0x032f5): "EmptyOrderedHashSet", + ("read_only_space", 0x03309): "EmptyFeedbackMetadata", + ("read_only_space", 0x03315): "EmptyPropertyDictionary", + ("read_only_space", 0x0333d): "EmptyOrderedPropertyDictionary", + ("read_only_space", 0x03355): "EmptySwissPropertyDictionary", + ("read_only_space", 0x033a9): "NoOpInterceptorInfo", + ("read_only_space", 0x033d1): "EmptyWeakArrayList", + ("read_only_space", 0x033dd): "InfinityValue", + ("read_only_space", 0x033e9): "MinusZeroValue", + ("read_only_space", 0x033f5): "MinusInfinityValue", + ("read_only_space", 0x03401): "SelfReferenceMarker", + ("read_only_space", 0x03441): "BasicBlockCountersMarker", + ("read_only_space", 0x03485): "OffHeapTrampolineRelocationInfo", + ("read_only_space", 0x03491): "TrampolineTrivialCodeDataContainer", + ("read_only_space", 0x0349d): "TrampolinePromiseRejectionCodeDataContainer", + ("read_only_space", 0x034a9): "GlobalThisBindingScopeInfo", + ("read_only_space", 0x034d9): "EmptyFunctionScopeInfo", + ("read_only_space", 0x034fd): "NativeScopeInfo", + ("read_only_space", 0x03515): "HashSeed", ("old_space", 0x04211): "ArgumentsIteratorAccessor", ("old_space", 0x04255): "ArrayLengthAccessor", ("old_space", 0x04299): "BoundFunctionLengthAccessor",