[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/+/3236718Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Commit-Queue: Manos Koukoutos <manoskouk@chromium.org>
Cr-Commit-Position: refs/heads/main@{#77575}

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<void*>(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);

src/heap/factory.cc

@@ -1473,6 +1473,22 @@ Handle<WasmTypeInfo> Factory::NewWasmTypeInfo(
   return handle(result, isolate());
 }
 
+Handle<WasmApiFunctionRef> Factory::NewWasmApiFunctionRef(
+    Handle<JSReceiver> 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<WasmJSFunctionData> Factory::NewWasmJSFunctionData(
     Address opt_call_target, Handle<JSReceiver> callable, int return_count,
     int parameter_count, Handle<PodArray<wasm::ValueType>> serialized_sig,

src/heap/factory.h

@@ -576,6 +576,7 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
       Handle<Code> export_wrapper, Handle<WasmInstanceObject> instance,
       Address call_target, Handle<Object> ref, int func_index,
       Address sig_address, int wrapper_budget);
+  Handle<WasmApiFunctionRef> NewWasmApiFunctionRef(Handle<JSReceiver> callable);
   // {opt_call_target} is kNullAddress for JavaScript functions, and
   // non-null for exported Wasm functions.
   Handle<WasmJSFunctionData> NewWasmJSFunctionData(

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)
 

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,

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:

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)

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)                       \

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 <typename ObjectVisitor>
+  static inline void IterateBody(Map map, HeapObject obj, int object_size,
+                                 ObjectVisitor* v) {
+    Foreign::BodyDescriptor::IterateBody<ObjectVisitor>(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<WasmJSFunctionData::BodyDescriptor>(p1, p2, p3,
                                                                     p4);
+    case WASM_API_FUNCTION_REF_TYPE:
+      return Op::template apply<WasmApiFunctionRef::BodyDescriptor>(p1, p2, p3,
+                                                                    p4);
     case WASM_STRUCT_TYPE:
       return Op::template apply<WasmStruct::BodyDescriptor>(p1, p2, p3, p4);
     case WASM_TYPE_INFO_TYPE:

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)                                \

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)

src/wasm/wasm-objects.h

@@ -733,6 +733,17 @@ class WasmExportedFunctionData
   TQ_OBJECT_CONSTRUCTORS(WasmExportedFunctionData)
 };
 
+class WasmApiFunctionRef
+    : public TorqueGeneratedWasmApiFunctionRef<WasmApiFunctionRef, Foreign> {
+ 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.

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,

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",