[wasm] Introduce WasmIndirectFunctionTable

This is the first of three CLs which refactors indirect function calls
through tables with index > 0 to work without runtime calls.

The first CL introduces the WasmIndirectFunctionTable heap object. For
a table of type anyfunc within a WebAssembly instance,
WasmIndirectFunctionTable stores the size, the signature id's, the
call targets, and the reference parameters for that table. I used the
names that are already used for the matching fields of the
WasmInstanceObject.

The second CL expands the IndirectFunctionTableEntry to work also on
WasmIndirectFunctionTable objects. All changes to a function table go
through this class.

The third CL introduces uses of the WasmIndirectFunctionTable. In this
CL I change the code generation in TurboFan to replace runime calls with
direct accesses to the new WasmIndirectFunctionTable. Additionally I
extended the initialization of WasmIndirectFunctionTable, and also
implement Table.grow.

R=jkummerow@chromium.org

Bug: v8:7581
Change-Id: I0ecfcb9565e992ddba087d46c1f0e952abfa5822
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1681134Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Commit-Queue: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#62492}

src/builtins/base.tq

@@ -928,6 +928,16 @@ extern class WasmCapiFunctionData extends Struct {
   serialized_signature: ByteArray;  // PodArray<wasm::ValueType>
 }
 
+extern class WasmIndirectFunctionTable extends Struct {
+  size: uint32;
+  @if(TAGGED_SIZE_8_BYTES) optional_padding: uint32;
+  @ifnot(TAGGED_SIZE_8_BYTES) optional_padding: void;
+  sig_ids: RawPtr;
+  targets: RawPtr;
+  managed_native_allocations: Foreign | Undefined;
+  refs: FixedArray;
+}
+
 extern class WasmDebugInfo extends Struct {
   instance: WasmInstanceObject;
   interpreter_handle: Foreign | Undefined;

src/compiler/code-assembler.h

@@ -338,6 +338,7 @@ class WasmExceptionObject;
 class WasmExceptionTag;
 class WasmExportedFunctionData;
 class WasmGlobalObject;
+class WasmIndirectFunctionTable;
 class WasmJSFunctionData;
 class WasmMemoryObject;
 class WasmModuleObject;

src/compiler/types.cc

@@ -6,9 +6,10 @@
 
 #include "src/compiler/types.h"
 
-#include "src/utils/ostreams.h"
 #include "src/handles/handles-inl.h"
+#include "src/objects/instance-type.h"
 #include "src/objects/objects-inl.h"
+#include "src/utils/ostreams.h"
 
 namespace v8 {
 namespace internal {
@@ -350,6 +351,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) {
     case ENUM_CACHE_TYPE:
     case SOURCE_POSITION_TABLE_WITH_FRAME_CACHE_TYPE:
     case WASM_CAPI_FUNCTION_DATA_TYPE:
+    case WASM_INDIRECT_FUNCTION_TABLE_TYPE:
     case WASM_DEBUG_INFO_TYPE:
     case WASM_EXCEPTION_TAG_TYPE:
     case WASM_EXPORTED_FUNCTION_DATA_TYPE:

src/diagnostics/objects-debug.cc

@@ -1748,6 +1748,8 @@ USE_TORQUE_VERIFIER(WasmCapiFunctionData)
 
 USE_TORQUE_VERIFIER(WasmJSFunctionData)
 
+USE_TORQUE_VERIFIER(WasmIndirectFunctionTable)
+
 USE_TORQUE_VERIFIER(ObjectTemplateInfo)
 
 void AllocationSite::AllocationSiteVerify(Isolate* isolate) {

src/diagnostics/objects-printer.cc

@@ -2071,6 +2071,20 @@ void WasmCapiFunctionData::WasmCapiFunctionDataPrint(
   os << "\n";
 }
 
+void WasmIndirectFunctionTable::WasmIndirectFunctionTablePrint(
+    std::ostream& os) {
+  PrintHeader(os, "WasmIndirectFunctionTable");
+  os << "\n - size: " << size();
+  os << "\n - sig_ids: " << static_cast<void*>(sig_ids());
+  os << "\n - targets: " << static_cast<void*>(targets());
+  if (has_managed_native_allocations()) {
+    os << "\n - managed_native_allocations: "
+       << Brief(managed_native_allocations());
+  }
+  os << "\n - refs: " << Brief(refs());
+  os << "\n";
+}
+
 void ObjectTemplateInfo::ObjectTemplateInfoPrint(std::ostream& os) {  // NOLINT
   PrintHeader(os, "ObjectTemplateInfo");
   os << "\n - tag: " << Brief(tag());

src/heap/objects-visiting.h

@@ -62,6 +62,7 @@ namespace internal {
   V(UncompiledDataWithoutPreparseData, UncompiledDataWithoutPreparseData) \
   V(UncompiledDataWithPreparseData, UncompiledDataWithPreparseData)       \
   V(WasmCapiFunctionData, WasmCapiFunctionData)                           \
+  V(WasmIndirectFunctionTable, WasmIndirectFunctionTable)                 \
   V(WasmInstanceObject, WasmInstanceObject)
 
 #define FORWARD_DECLARE(TypeName, Type) class Type;

src/objects/instance-type.h

@@ -143,6 +143,7 @@ enum InstanceType : uint16_t {
   ACCESSOR_PAIR_TYPE,
   ALIASED_ARGUMENTS_ENTRY_TYPE,
   ALLOCATION_MEMENTO_TYPE,
+  ARRAY_BOILERPLATE_DESCRIPTION_TYPE,
   ASM_WASM_DATA_TYPE,
   ASYNC_GENERATOR_REQUEST_TYPE,
   CLASS_POSITIONS_TYPE,
@@ -164,11 +165,11 @@ enum InstanceType : uint16_t {
   TEMPLATE_OBJECT_DESCRIPTION_TYPE,
   TUPLE2_TYPE,
   TUPLE3_TYPE,
-  ARRAY_BOILERPLATE_DESCRIPTION_TYPE,
   WASM_CAPI_FUNCTION_DATA_TYPE,
   WASM_DEBUG_INFO_TYPE,
   WASM_EXCEPTION_TAG_TYPE,
   WASM_EXPORTED_FUNCTION_DATA_TYPE,
+  WASM_INDIRECT_FUNCTION_TABLE_TYPE,
   WASM_JS_FUNCTION_DATA_TYPE,
 
   CALLABLE_TASK_TYPE,  // FIRST_MICROTASK_TYPE

src/objects/map.cc

@@ -352,6 +352,9 @@ VisitorId Map::GetVisitorId(Map map) {
       if (instance_type == WASM_CAPI_FUNCTION_DATA_TYPE) {
         return kVisitWasmCapiFunctionData;
       }
+      if (instance_type == WASM_INDIRECT_FUNCTION_TABLE_TYPE) {
+        return kVisitWasmIndirectFunctionTable;
+      }
       return kVisitStruct;
 
     case LOAD_HANDLER_TYPE:

src/objects/map.h

@@ -74,6 +74,7 @@ enum InstanceType : uint16_t;
   V(UncompiledDataWithoutPreparseData) \
   V(UncompiledDataWithPreparseData)    \
   V(WasmCapiFunctionData)              \
+  V(WasmIndirectFunctionTable)         \
   V(WasmInstanceObject)                \
   V(WeakArray)                         \
   V(WeakCell)

src/objects/objects-body-descriptors-inl.h

@@ -1045,6 +1045,9 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
       } else if (type == WASM_CAPI_FUNCTION_DATA_TYPE) {
         return Op::template apply<WasmCapiFunctionData::BodyDescriptor>(p1, p2,
                                                                         p3, p4);
+      } else if (type == WASM_INDIRECT_FUNCTION_TABLE_TYPE) {
+        return Op::template apply<WasmIndirectFunctionTable::BodyDescriptor>(
+            p1, p2, p3, p4);
       } else {
         return Op::template apply<StructBodyDescriptor>(p1, p2, p3, p4);
       }

src/objects/objects-definitions.h

@@ -82,6 +82,7 @@ namespace internal {
   V(ACCESSOR_PAIR_TYPE)                                  \
   V(ALIASED_ARGUMENTS_ENTRY_TYPE)                        \
   V(ALLOCATION_MEMENTO_TYPE)                             \
+  V(ARRAY_BOILERPLATE_DESCRIPTION_TYPE)                  \
   V(ASM_WASM_DATA_TYPE)                                  \
   V(ASYNC_GENERATOR_REQUEST_TYPE)                        \
   V(CLASS_POSITIONS_TYPE)                                \
@@ -103,11 +104,11 @@ namespace internal {
   V(TEMPLATE_OBJECT_DESCRIPTION_TYPE)                    \
   V(TUPLE2_TYPE)                                         \
   V(TUPLE3_TYPE)                                         \
-  V(ARRAY_BOILERPLATE_DESCRIPTION_TYPE)                  \
   V(WASM_CAPI_FUNCTION_DATA_TYPE)                        \
   V(WASM_DEBUG_INFO_TYPE)                                \
   V(WASM_EXCEPTION_TAG_TYPE)                             \
   V(WASM_EXPORTED_FUNCTION_DATA_TYPE)                    \
+  V(WASM_INDIRECT_FUNCTION_TABLE_TYPE)                   \
   V(WASM_JS_FUNCTION_DATA_TYPE)                          \
                                                          \
   V(CALLABLE_TASK_TYPE)                                  \
@@ -302,6 +303,8 @@ namespace internal {
   V(_, ALIASED_ARGUMENTS_ENTRY_TYPE, AliasedArgumentsEntry,                    \
     aliased_arguments_entry)                                                   \
   V(_, ALLOCATION_MEMENTO_TYPE, AllocationMemento, allocation_memento)         \
+  V(_, ARRAY_BOILERPLATE_DESCRIPTION_TYPE, ArrayBoilerplateDescription,        \
+    array_boilerplate_description)                                             \
   V(_, ASM_WASM_DATA_TYPE, AsmWasmData, asm_wasm_data)                         \
   V(_, ASYNC_GENERATOR_REQUEST_TYPE, AsyncGeneratorRequest,                    \
     async_generator_request)                                                   \
@@ -329,14 +332,14 @@ namespace internal {
     template_object_description)                                               \
   V(_, TUPLE2_TYPE, Tuple2, tuple2)                                            \
   V(_, TUPLE3_TYPE, Tuple3, tuple3)                                            \
-  V(_, ARRAY_BOILERPLATE_DESCRIPTION_TYPE, ArrayBoilerplateDescription,        \
-    array_boilerplate_description)                                             \
   V(_, WASM_CAPI_FUNCTION_DATA_TYPE, WasmCapiFunctionData,                     \
     wasm_capi_function_data)                                                   \
   V(_, WASM_DEBUG_INFO_TYPE, WasmDebugInfo, wasm_debug_info)                   \
   V(_, WASM_EXCEPTION_TAG_TYPE, WasmExceptionTag, wasm_exception_tag)          \
   V(_, WASM_EXPORTED_FUNCTION_DATA_TYPE, WasmExportedFunctionData,             \
     wasm_exported_function_data)                                               \
+  V(_, WASM_INDIRECT_FUNCTION_TABLE_TYPE, WasmIndirectFunctionTable,           \
+    wasm_indirect_function_table)                                              \
   V(_, WASM_JS_FUNCTION_DATA_TYPE, WasmJSFunctionData, wasm_js_function_data)  \
   V(_, CALLABLE_TASK_TYPE, CallableTask, callable_task)                        \
   V(_, CALLBACK_TASK_TYPE, CallbackTask, callback_task)                        \

src/wasm/module-instantiate.cc

@@ -397,15 +397,30 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
   // Set up table storage space.
   //--------------------------------------------------------------------------
   int table_count = static_cast<int>(module_->tables.size());
-  Handle<FixedArray> tables = isolate_->factory()->NewFixedArray(table_count);
-  for (int i = module_->num_imported_tables; i < table_count; i++) {
-    const WasmTable& table = module_->tables[i];
-    Handle<WasmTableObject> table_obj = WasmTableObject::New(
-        isolate_, table.type, table.initial_size, table.has_maximum_size,
-        table.maximum_size, nullptr);
-    tables->set(i, *table_obj);
-  }
-  instance->set_tables(*tables);
+  {
+    Handle<FixedArray> tables = isolate_->factory()->NewFixedArray(table_count);
+    for (int i = module_->num_imported_tables; i < table_count; i++) {
+      const WasmTable& table = module_->tables[i];
+      Handle<WasmTableObject> table_obj = WasmTableObject::New(
+          isolate_, table.type, table.initial_size, table.has_maximum_size,
+          table.maximum_size, nullptr);
+      tables->set(i, *table_obj);
+    }
+    instance->set_tables(*tables);
+  }
+
+  {
+    Handle<FixedArray> tables = isolate_->factory()->NewFixedArray(table_count);
+    for (int i = 0; i < table_count; ++i) {
+      const WasmTable& table = module_->tables[i];
+      if (table.type == kWasmAnyFunc) {
+        Handle<WasmIndirectFunctionTable> table_obj =
+            WasmIndirectFunctionTable::New(isolate_, table.initial_size);
+        tables->set(i, *table_obj);
+      }
+    }
+    instance->set_indirect_function_tables(*tables);
+  }
 
   //--------------------------------------------------------------------------
   // Process the imports for the module.

src/wasm/wasm-objects-inl.h

@@ -251,6 +251,8 @@ OPTIONAL_ACCESSORS(WasmInstanceObject, imported_mutable_globals_buffers,
 OPTIONAL_ACCESSORS(WasmInstanceObject, debug_info, WasmDebugInfo,
                    kDebugInfoOffset)
 OPTIONAL_ACCESSORS(WasmInstanceObject, tables, FixedArray, kTablesOffset)
+OPTIONAL_ACCESSORS(WasmInstanceObject, indirect_function_tables, FixedArray,
+                   kIndirectFunctionTablesOffset)
 ACCESSORS(WasmInstanceObject, imported_function_refs, FixedArray,
           kImportedFunctionRefsOffset)
 OPTIONAL_ACCESSORS(WasmInstanceObject, indirect_function_table_refs, FixedArray,
@@ -349,6 +351,18 @@ ACCESSORS(WasmCapiFunctionData, wrapper_code, Code, kWrapperCodeOffset)
 ACCESSORS(WasmCapiFunctionData, serialized_signature, PodArray<wasm::ValueType>,
           kSerializedSignatureOffset)
 
+// WasmIndirectFunctionTable
+OBJECT_CONSTRUCTORS_IMPL(WasmIndirectFunctionTable, Struct)
+CAST_ACCESSOR(WasmIndirectFunctionTable)
+PRIMITIVE_ACCESSORS(WasmIndirectFunctionTable, size, uint32_t, kSizeOffset)
+PRIMITIVE_ACCESSORS(WasmIndirectFunctionTable, sig_ids, uint32_t*,
+                    kSigIdsOffset)
+PRIMITIVE_ACCESSORS(WasmIndirectFunctionTable, targets, Address*,
+                    kTargetsOffset)
+OPTIONAL_ACCESSORS(WasmIndirectFunctionTable, managed_native_allocations,
+                   Foreign, kManagedNativeAllocationsOffset)
+ACCESSORS(WasmIndirectFunctionTable, refs, FixedArray, kRefsOffset)
+
 // WasmDebugInfo
 ACCESSORS(WasmDebugInfo, wasm_instance, WasmInstanceObject, kInstanceOffset)
 ACCESSORS(WasmDebugInfo, interpreter_handle, Object, kInterpreterHandleOffset)

src/wasm/wasm-objects.cc

@@ -1183,6 +1183,38 @@ void WasmTableObject::GetFunctionTableEntry(
   *is_valid = false;
 }
 
+namespace {
+class IftNativeAllocations {
+ public:
+  IftNativeAllocations(Handle<WasmIndirectFunctionTable> table, uint32_t size)
+      : sig_ids_(size), targets_(size) {
+    table->set_sig_ids(sig_ids_.data());
+    table->set_targets(targets_.data());
+  }
+
+  static size_t SizeInMemory(uint32_t size) {
+    return size * (sizeof(Address) + sizeof(uint32_t));
+  }
+
+ private:
+  std::vector<uint32_t> sig_ids_;
+  std::vector<Address> targets_;
+};
+}  // namespace
+
+Handle<WasmIndirectFunctionTable> WasmIndirectFunctionTable::New(
+    Isolate* isolate, uint32_t size) {
+  auto refs = isolate->factory()->NewFixedArray(static_cast<int>(size));
+  auto table = Handle<WasmIndirectFunctionTable>::cast(
+      isolate->factory()->NewStruct(WASM_INDIRECT_FUNCTION_TABLE_TYPE));
+  table->set_size(size);
+  table->set_refs(*refs);
+  auto native_allocations = Managed<IftNativeAllocations>::Allocate(
+      isolate, IftNativeAllocations::SizeInMemory(size), table, size);
+  table->set_managed_native_allocations(*native_allocations);
+  return table;
+}
+
 namespace {
 bool AdjustBufferPermissions(Isolate* isolate, Handle<JSArrayBuffer> old_buffer,
                              size_t new_size) {

src/wasm/wasm-objects.h

@@ -435,6 +435,7 @@ class WasmInstanceObject : public JSObject {
   DECL_OPTIONAL_ACCESSORS(imported_mutable_globals_buffers, FixedArray)
   DECL_OPTIONAL_ACCESSORS(debug_info, WasmDebugInfo)
   DECL_OPTIONAL_ACCESSORS(tables, FixedArray)
+  DECL_OPTIONAL_ACCESSORS(indirect_function_tables, FixedArray)
   DECL_ACCESSORS(imported_function_refs, FixedArray)
   DECL_OPTIONAL_ACCESSORS(indirect_function_table_refs, FixedArray)
   DECL_OPTIONAL_ACCESSORS(managed_native_allocations, Foreign)
@@ -499,6 +500,7 @@ class WasmInstanceObject : public JSObject {
   V(kImportedMutableGlobalsBuffersOffset, kTaggedSize)                    \
   V(kDebugInfoOffset, kTaggedSize)                                        \
   V(kTablesOffset, kTaggedSize)                                           \
+  V(kIndirectFunctionTablesOffset, kTaggedSize)                           \
   V(kManagedNativeAllocationsOffset, kTaggedSize)                         \
   V(kExceptionsTableOffset, kTaggedSize)                                  \
   V(kNullValueOffset, kTaggedSize)                                        \
@@ -540,6 +542,7 @@ class WasmInstanceObject : public JSObject {
       kImportedMutableGlobalsBuffersOffset,
       kDebugInfoOffset,
       kTablesOffset,
+      kIndirectFunctionTablesOffset,
       kManagedNativeAllocationsOffset,
       kExceptionsTableOffset,
       kNullValueOffset,
@@ -721,6 +724,31 @@ class WasmCapiFunction : public JSFunction {
   OBJECT_CONSTRUCTORS(WasmCapiFunction, JSFunction);
 };
 
+class WasmIndirectFunctionTable : public Struct {
+ public:
+  DECL_PRIMITIVE_ACCESSORS(size, uint32_t)
+  DECL_PRIMITIVE_ACCESSORS(sig_ids, uint32_t*)
+  DECL_PRIMITIVE_ACCESSORS(targets, Address*)
+  DECL_OPTIONAL_ACCESSORS(managed_native_allocations, Foreign)
+  DECL_ACCESSORS(refs, FixedArray)
+
+  static Handle<WasmIndirectFunctionTable> New(Isolate* isolate, uint32_t size);
+
+  DECL_CAST(WasmIndirectFunctionTable)
+
+  DECL_PRINTER(WasmIndirectFunctionTable)
+  DECL_VERIFIER(WasmIndirectFunctionTable)
+
+  DEFINE_FIELD_OFFSET_CONSTANTS(
+      HeapObject::kHeaderSize,
+      TORQUE_GENERATED_WASM_INDIRECT_FUNCTION_TABLE_FIELDS)
+
+  STATIC_ASSERT(kStartOfStrongFieldsOffset == kManagedNativeAllocationsOffset);
+  using BodyDescriptor = FlexibleBodyDescriptor<kStartOfStrongFieldsOffset>;
+
+  OBJECT_CONSTRUCTORS(WasmIndirectFunctionTable, Struct);
+};
+
 class WasmCapiFunctionData : public Struct {
  public:
   DECL_PRIMITIVE_ACCESSORS(call_target, Address)

tools/v8heapconst.py

@@ -44,93 +44,94 @@ INSTANCE_TYPES = {
   80: "ACCESSOR_PAIR_TYPE",
   81: "ALIASED_ARGUMENTS_ENTRY_TYPE",
   82: "ALLOCATION_MEMENTO_TYPE",
-  83: "ASM_WASM_DATA_TYPE",
-  84: "ASYNC_GENERATOR_REQUEST_TYPE",
-  85: "CLASS_POSITIONS_TYPE",
-  86: "DEBUG_INFO_TYPE",
-  87: "ENUM_CACHE_TYPE",
-  88: "FUNCTION_TEMPLATE_INFO_TYPE",
-  89: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
-  90: "INTERCEPTOR_INFO_TYPE",
-  91: "INTERPRETER_DATA_TYPE",
-  92: "OBJECT_TEMPLATE_INFO_TYPE",
-  93: "PROMISE_CAPABILITY_TYPE",
-  94: "PROMISE_REACTION_TYPE",
-  95: "PROTOTYPE_INFO_TYPE",
-  96: "SCRIPT_TYPE",
-  97: "SOURCE_POSITION_TABLE_WITH_FRAME_CACHE_TYPE",
-  98: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
-  99: "STACK_FRAME_INFO_TYPE",
-  100: "STACK_TRACE_FRAME_TYPE",
-  101: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
-  102: "TUPLE2_TYPE",
-  103: "TUPLE3_TYPE",
-  104: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE",
+  83: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE",
+  84: "ASM_WASM_DATA_TYPE",
+  85: "ASYNC_GENERATOR_REQUEST_TYPE",
+  86: "CLASS_POSITIONS_TYPE",
+  87: "DEBUG_INFO_TYPE",
+  88: "ENUM_CACHE_TYPE",
+  89: "FUNCTION_TEMPLATE_INFO_TYPE",
+  90: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
+  91: "INTERCEPTOR_INFO_TYPE",
+  92: "INTERPRETER_DATA_TYPE",
+  93: "OBJECT_TEMPLATE_INFO_TYPE",
+  94: "PROMISE_CAPABILITY_TYPE",
+  95: "PROMISE_REACTION_TYPE",
+  96: "PROTOTYPE_INFO_TYPE",
+  97: "SCRIPT_TYPE",
+  98: "SOURCE_POSITION_TABLE_WITH_FRAME_CACHE_TYPE",
+  99: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
+  100: "STACK_FRAME_INFO_TYPE",
+  101: "STACK_TRACE_FRAME_TYPE",
+  102: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
+  103: "TUPLE2_TYPE",
+  104: "TUPLE3_TYPE",
   105: "WASM_CAPI_FUNCTION_DATA_TYPE",
   106: "WASM_DEBUG_INFO_TYPE",
   107: "WASM_EXCEPTION_TAG_TYPE",
   108: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
-  109: "WASM_JS_FUNCTION_DATA_TYPE",
-  110: "CALLABLE_TASK_TYPE",
-  111: "CALLBACK_TASK_TYPE",
-  112: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
-  113: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
-  114: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
-  115: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE",
-  116: "INTERNAL_CLASS_TYPE",
-  117: "SMI_PAIR_TYPE",
-  118: "SMI_BOX_TYPE",
-  119: "SORT_STATE_TYPE",
-  120: "SOURCE_TEXT_MODULE_TYPE",
-  121: "SYNTHETIC_MODULE_TYPE",
-  122: "ALLOCATION_SITE_TYPE",
-  123: "EMBEDDER_DATA_ARRAY_TYPE",
-  124: "FIXED_ARRAY_TYPE",
-  125: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  126: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
-  127: "HASH_TABLE_TYPE",
-  128: "ORDERED_HASH_MAP_TYPE",
-  129: "ORDERED_HASH_SET_TYPE",
-  130: "ORDERED_NAME_DICTIONARY_TYPE",
-  131: "NAME_DICTIONARY_TYPE",
-  132: "GLOBAL_DICTIONARY_TYPE",
-  133: "NUMBER_DICTIONARY_TYPE",
-  134: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  135: "STRING_TABLE_TYPE",
-  136: "EPHEMERON_HASH_TABLE_TYPE",
-  137: "SCOPE_INFO_TYPE",
-  138: "SCRIPT_CONTEXT_TABLE_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: "WEAK_FIXED_ARRAY_TYPE",
-  150: "TRANSITION_ARRAY_TYPE",
-  151: "CALL_HANDLER_INFO_TYPE",
-  152: "CELL_TYPE",
-  153: "CODE_DATA_CONTAINER_TYPE",
-  154: "DESCRIPTOR_ARRAY_TYPE",
-  155: "FEEDBACK_CELL_TYPE",
-  156: "FEEDBACK_VECTOR_TYPE",
-  157: "LOAD_HANDLER_TYPE",
-  158: "PREPARSE_DATA_TYPE",
-  159: "PROPERTY_ARRAY_TYPE",
-  160: "PROPERTY_CELL_TYPE",
-  161: "SHARED_FUNCTION_INFO_TYPE",
-  162: "SMALL_ORDERED_HASH_MAP_TYPE",
-  163: "SMALL_ORDERED_HASH_SET_TYPE",
-  164: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
-  165: "STORE_HANDLER_TYPE",
-  166: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
-  167: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
-  168: "WEAK_ARRAY_LIST_TYPE",
-  169: "WEAK_CELL_TYPE",
+  109: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
+  110: "WASM_JS_FUNCTION_DATA_TYPE",
+  111: "CALLABLE_TASK_TYPE",
+  112: "CALLBACK_TASK_TYPE",
+  113: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
+  114: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
+  115: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
+  116: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE",
+  117: "INTERNAL_CLASS_TYPE",
+  118: "SMI_PAIR_TYPE",
+  119: "SMI_BOX_TYPE",
+  120: "SORT_STATE_TYPE",
+  121: "SOURCE_TEXT_MODULE_TYPE",
+  122: "SYNTHETIC_MODULE_TYPE",
+  123: "ALLOCATION_SITE_TYPE",
+  124: "EMBEDDER_DATA_ARRAY_TYPE",
+  125: "FIXED_ARRAY_TYPE",
+  126: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
+  127: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
+  128: "HASH_TABLE_TYPE",
+  129: "ORDERED_HASH_MAP_TYPE",
+  130: "ORDERED_HASH_SET_TYPE",
+  131: "ORDERED_NAME_DICTIONARY_TYPE",
+  132: "NAME_DICTIONARY_TYPE",
+  133: "GLOBAL_DICTIONARY_TYPE",
+  134: "NUMBER_DICTIONARY_TYPE",
+  135: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  136: "STRING_TABLE_TYPE",
+  137: "EPHEMERON_HASH_TABLE_TYPE",
+  138: "SCOPE_INFO_TYPE",
+  139: "SCRIPT_CONTEXT_TABLE_TYPE",
+  140: "AWAIT_CONTEXT_TYPE",
+  141: "BLOCK_CONTEXT_TYPE",
+  142: "CATCH_CONTEXT_TYPE",
+  143: "DEBUG_EVALUATE_CONTEXT_TYPE",
+  144: "EVAL_CONTEXT_TYPE",
+  145: "FUNCTION_CONTEXT_TYPE",
+  146: "MODULE_CONTEXT_TYPE",
+  147: "NATIVE_CONTEXT_TYPE",
+  148: "SCRIPT_CONTEXT_TYPE",
+  149: "WITH_CONTEXT_TYPE",
+  150: "WEAK_FIXED_ARRAY_TYPE",
+  151: "TRANSITION_ARRAY_TYPE",
+  152: "CALL_HANDLER_INFO_TYPE",
+  153: "CELL_TYPE",
+  154: "CODE_DATA_CONTAINER_TYPE",
+  155: "DESCRIPTOR_ARRAY_TYPE",
+  156: "FEEDBACK_CELL_TYPE",
+  157: "FEEDBACK_VECTOR_TYPE",
+  158: "LOAD_HANDLER_TYPE",
+  159: "PREPARSE_DATA_TYPE",
+  160: "PROPERTY_ARRAY_TYPE",
+  161: "PROPERTY_CELL_TYPE",
+  162: "SHARED_FUNCTION_INFO_TYPE",
+  163: "SMALL_ORDERED_HASH_MAP_TYPE",
+  164: "SMALL_ORDERED_HASH_SET_TYPE",
+  165: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
+  166: "STORE_HANDLER_TYPE",
+  167: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
+  168: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
+  169: "WEAK_ARRAY_LIST_TYPE",
+  170: "WEAK_CELL_TYPE",
   1024: "JS_PROXY_TYPE",
   1025: "JS_GLOBAL_OBJECT_TYPE",
   1026: "JS_GLOBAL_PROXY_TYPE",
@@ -194,8 +195,8 @@ KNOWN_MAPS = {
   ("read_only_space", 0x00139): (74, "FreeSpaceMap"),
   ("read_only_space", 0x00189): (68, "MetaMap"),
   ("read_only_space", 0x00209): (67, "NullMap"),
-  ("read_only_space", 0x00271): (154, "DescriptorArrayMap"),
-  ("read_only_space", 0x002d1): (149, "WeakFixedArrayMap"),
+  ("read_only_space", 0x00271): (155, "DescriptorArrayMap"),
+  ("read_only_space", 0x002d1): (150, "WeakFixedArrayMap"),
   ("read_only_space", 0x00321): (77, "OnePointerFillerMap"),
   ("read_only_space", 0x00371): (77, "TwoPointerFillerMap"),
   ("read_only_space", 0x003f1): (67, "UninitializedMap"),
@@ -205,73 +206,73 @@ KNOWN_MAPS = {
   ("read_only_space", 0x005e1): (67, "TheHoleMap"),
   ("read_only_space", 0x00689): (67, "BooleanMap"),
   ("read_only_space", 0x00761): (72, "ByteArrayMap"),
-  ("read_only_space", 0x007b1): (124, "FixedArrayMap"),
-  ("read_only_space", 0x00801): (124, "FixedCOWArrayMap"),
-  ("read_only_space", 0x00851): (127, "HashTableMap"),
+  ("read_only_space", 0x007b1): (125, "FixedArrayMap"),
+  ("read_only_space", 0x00801): (125, "FixedCOWArrayMap"),
+  ("read_only_space", 0x00851): (128, "HashTableMap"),
   ("read_only_space", 0x008a1): (64, "SymbolMap"),
   ("read_only_space", 0x008f1): (40, "OneByteStringMap"),
-  ("read_only_space", 0x00941): (137, "ScopeInfoMap"),
-  ("read_only_space", 0x00991): (161, "SharedFunctionInfoMap"),
+  ("read_only_space", 0x00941): (138, "ScopeInfoMap"),
+  ("read_only_space", 0x00991): (162, "SharedFunctionInfoMap"),
   ("read_only_space", 0x009e1): (69, "CodeMap"),
-  ("read_only_space", 0x00a31): (144, "FunctionContextMap"),
-  ("read_only_space", 0x00a81): (152, "CellMap"),
-  ("read_only_space", 0x00ad1): (160, "GlobalPropertyCellMap"),
+  ("read_only_space", 0x00a31): (145, "FunctionContextMap"),
+  ("read_only_space", 0x00a81): (153, "CellMap"),
+  ("read_only_space", 0x00ad1): (161, "GlobalPropertyCellMap"),
   ("read_only_space", 0x00b21): (71, "ForeignMap"),
-  ("read_only_space", 0x00b71): (150, "TransitionArrayMap"),
-  ("read_only_space", 0x00bc1): (156, "FeedbackVectorMap"),
+  ("read_only_space", 0x00b71): (151, "TransitionArrayMap"),
+  ("read_only_space", 0x00bc1): (157, "FeedbackVectorMap"),
   ("read_only_space", 0x00c61): (67, "ArgumentsMarkerMap"),
   ("read_only_space", 0x00d01): (67, "ExceptionMap"),
   ("read_only_space", 0x00da1): (67, "TerminationExceptionMap"),
   ("read_only_space", 0x00e49): (67, "OptimizedOutMap"),
   ("read_only_space", 0x00ee9): (67, "StaleRegisterMap"),
-  ("read_only_space", 0x00f59): (146, "NativeContextMap"),
-  ("read_only_space", 0x00fa9): (145, "ModuleContextMap"),
-  ("read_only_space", 0x00ff9): (143, "EvalContextMap"),
-  ("read_only_space", 0x01049): (147, "ScriptContextMap"),
-  ("read_only_space", 0x01099): (139, "AwaitContextMap"),
-  ("read_only_space", 0x010e9): (140, "BlockContextMap"),
-  ("read_only_space", 0x01139): (141, "CatchContextMap"),
-  ("read_only_space", 0x01189): (148, "WithContextMap"),
-  ("read_only_space", 0x011d9): (142, "DebugEvaluateContextMap"),
-  ("read_only_space", 0x01229): (138, "ScriptContextTableMap"),
-  ("read_only_space", 0x01279): (126, "ClosureFeedbackCellArrayMap"),
+  ("read_only_space", 0x00f59): (147, "NativeContextMap"),
+  ("read_only_space", 0x00fa9): (146, "ModuleContextMap"),
+  ("read_only_space", 0x00ff9): (144, "EvalContextMap"),
+  ("read_only_space", 0x01049): (148, "ScriptContextMap"),
+  ("read_only_space", 0x01099): (140, "AwaitContextMap"),
+  ("read_only_space", 0x010e9): (141, "BlockContextMap"),
+  ("read_only_space", 0x01139): (142, "CatchContextMap"),
+  ("read_only_space", 0x01189): (149, "WithContextMap"),
+  ("read_only_space", 0x011d9): (143, "DebugEvaluateContextMap"),
+  ("read_only_space", 0x01229): (139, "ScriptContextTableMap"),
+  ("read_only_space", 0x01279): (127, "ClosureFeedbackCellArrayMap"),
   ("read_only_space", 0x012c9): (76, "FeedbackMetadataArrayMap"),
-  ("read_only_space", 0x01319): (124, "ArrayListMap"),
+  ("read_only_space", 0x01319): (125, "ArrayListMap"),
   ("read_only_space", 0x01369): (66, "BigIntMap"),
-  ("read_only_space", 0x013b9): (125, "ObjectBoilerplateDescriptionMap"),
+  ("read_only_space", 0x013b9): (126, "ObjectBoilerplateDescriptionMap"),
   ("read_only_space", 0x01409): (73, "BytecodeArrayMap"),
-  ("read_only_space", 0x01459): (153, "CodeDataContainerMap"),
+  ("read_only_space", 0x01459): (154, "CodeDataContainerMap"),
   ("read_only_space", 0x014a9): (75, "FixedDoubleArrayMap"),
-  ("read_only_space", 0x014f9): (132, "GlobalDictionaryMap"),
-  ("read_only_space", 0x01549): (155, "ManyClosuresCellMap"),
-  ("read_only_space", 0x01599): (124, "ModuleInfoMap"),
+  ("read_only_space", 0x014f9): (133, "GlobalDictionaryMap"),
+  ("read_only_space", 0x01549): (156, "ManyClosuresCellMap"),
+  ("read_only_space", 0x01599): (125, "ModuleInfoMap"),
   ("read_only_space", 0x015e9): (70, "MutableHeapNumberMap"),
-  ("read_only_space", 0x01639): (131, "NameDictionaryMap"),
-  ("read_only_space", 0x01689): (155, "NoClosuresCellMap"),
-  ("read_only_space", 0x016d9): (133, "NumberDictionaryMap"),
-  ("read_only_space", 0x01729): (155, "OneClosureCellMap"),
-  ("read_only_space", 0x01779): (128, "OrderedHashMapMap"),
-  ("read_only_space", 0x017c9): (129, "OrderedHashSetMap"),
-  ("read_only_space", 0x01819): (130, "OrderedNameDictionaryMap"),
-  ("read_only_space", 0x01869): (158, "PreparseDataMap"),
-  ("read_only_space", 0x018b9): (159, "PropertyArrayMap"),
-  ("read_only_space", 0x01909): (151, "SideEffectCallHandlerInfoMap"),
-  ("read_only_space", 0x01959): (151, "SideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x019a9): (151, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x019f9): (134, "SimpleNumberDictionaryMap"),
-  ("read_only_space", 0x01a49): (124, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x01a99): (162, "SmallOrderedHashMapMap"),
-  ("read_only_space", 0x01ae9): (163, "SmallOrderedHashSetMap"),
-  ("read_only_space", 0x01b39): (164, "SmallOrderedNameDictionaryMap"),
-  ("read_only_space", 0x01b89): (120, "SourceTextModuleMap"),
-  ("read_only_space", 0x01bd9): (135, "StringTableMap"),
-  ("read_only_space", 0x01c29): (121, "SyntheticModuleMap"),
-  ("read_only_space", 0x01c79): (166, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x01cc9): (167, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x01d19): (168, "WeakArrayListMap"),
-  ("read_only_space", 0x01d69): (136, "EphemeronHashTableMap"),
-  ("read_only_space", 0x01db9): (123, "EmbedderDataArrayMap"),
-  ("read_only_space", 0x01e09): (169, "WeakCellMap"),
+  ("read_only_space", 0x01639): (132, "NameDictionaryMap"),
+  ("read_only_space", 0x01689): (156, "NoClosuresCellMap"),
+  ("read_only_space", 0x016d9): (134, "NumberDictionaryMap"),
+  ("read_only_space", 0x01729): (156, "OneClosureCellMap"),
+  ("read_only_space", 0x01779): (129, "OrderedHashMapMap"),
+  ("read_only_space", 0x017c9): (130, "OrderedHashSetMap"),
+  ("read_only_space", 0x01819): (131, "OrderedNameDictionaryMap"),
+  ("read_only_space", 0x01869): (159, "PreparseDataMap"),
+  ("read_only_space", 0x018b9): (160, "PropertyArrayMap"),
+  ("read_only_space", 0x01909): (152, "SideEffectCallHandlerInfoMap"),
+  ("read_only_space", 0x01959): (152, "SideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x019a9): (152, "NextCallSideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x019f9): (135, "SimpleNumberDictionaryMap"),
+  ("read_only_space", 0x01a49): (125, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x01a99): (163, "SmallOrderedHashMapMap"),
+  ("read_only_space", 0x01ae9): (164, "SmallOrderedHashSetMap"),
+  ("read_only_space", 0x01b39): (165, "SmallOrderedNameDictionaryMap"),
+  ("read_only_space", 0x01b89): (121, "SourceTextModuleMap"),
+  ("read_only_space", 0x01bd9): (136, "StringTableMap"),
+  ("read_only_space", 0x01c29): (122, "SyntheticModuleMap"),
+  ("read_only_space", 0x01c79): (167, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x01cc9): (168, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x01d19): (169, "WeakArrayListMap"),
+  ("read_only_space", 0x01d69): (137, "EphemeronHashTableMap"),
+  ("read_only_space", 0x01db9): (124, "EmbedderDataArrayMap"),
+  ("read_only_space", 0x01e09): (170, "WeakCellMap"),
   ("read_only_space", 0x01e59): (58, "NativeSourceStringMap"),
   ("read_only_space", 0x01ea9): (32, "StringMap"),
   ("read_only_space", 0x01ef9): (41, "ConsOneByteStringMap"),
@@ -290,57 +291,58 @@ KNOWN_MAPS = {
   ("read_only_space", 0x02309): (26, "UncachedExternalOneByteInternalizedStringMap"),
   ("read_only_space", 0x02359): (58, "UncachedExternalOneByteStringMap"),
   ("read_only_space", 0x023a9): (67, "SelfReferenceMarkerMap"),
-  ("read_only_space", 0x02411): (87, "EnumCacheMap"),
-  ("read_only_space", 0x024b1): (104, "ArrayBoilerplateDescriptionMap"),
-  ("read_only_space", 0x026a1): (90, "InterceptorInfoMap"),
+  ("read_only_space", 0x02411): (88, "EnumCacheMap"),
+  ("read_only_space", 0x024b1): (83, "ArrayBoilerplateDescriptionMap"),
+  ("read_only_space", 0x026a1): (91, "InterceptorInfoMap"),
   ("read_only_space", 0x04e81): (78, "AccessCheckInfoMap"),
   ("read_only_space", 0x04ed1): (79, "AccessorInfoMap"),
   ("read_only_space", 0x04f21): (80, "AccessorPairMap"),
   ("read_only_space", 0x04f71): (81, "AliasedArgumentsEntryMap"),
   ("read_only_space", 0x04fc1): (82, "AllocationMementoMap"),
-  ("read_only_space", 0x05011): (83, "AsmWasmDataMap"),
-  ("read_only_space", 0x05061): (84, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x050b1): (85, "ClassPositionsMap"),
-  ("read_only_space", 0x05101): (86, "DebugInfoMap"),
-  ("read_only_space", 0x05151): (88, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x051a1): (89, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x051f1): (91, "InterpreterDataMap"),
-  ("read_only_space", 0x05241): (92, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x05291): (93, "PromiseCapabilityMap"),
-  ("read_only_space", 0x052e1): (94, "PromiseReactionMap"),
-  ("read_only_space", 0x05331): (95, "PrototypeInfoMap"),
-  ("read_only_space", 0x05381): (96, "ScriptMap"),
-  ("read_only_space", 0x053d1): (97, "SourcePositionTableWithFrameCacheMap"),
-  ("read_only_space", 0x05421): (98, "SourceTextModuleInfoEntryMap"),
-  ("read_only_space", 0x05471): (99, "StackFrameInfoMap"),
-  ("read_only_space", 0x054c1): (100, "StackTraceFrameMap"),
-  ("read_only_space", 0x05511): (101, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x05561): (102, "Tuple2Map"),
-  ("read_only_space", 0x055b1): (103, "Tuple3Map"),
+  ("read_only_space", 0x05011): (84, "AsmWasmDataMap"),
+  ("read_only_space", 0x05061): (85, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x050b1): (86, "ClassPositionsMap"),
+  ("read_only_space", 0x05101): (87, "DebugInfoMap"),
+  ("read_only_space", 0x05151): (89, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x051a1): (90, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x051f1): (92, "InterpreterDataMap"),
+  ("read_only_space", 0x05241): (93, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x05291): (94, "PromiseCapabilityMap"),
+  ("read_only_space", 0x052e1): (95, "PromiseReactionMap"),
+  ("read_only_space", 0x05331): (96, "PrototypeInfoMap"),
+  ("read_only_space", 0x05381): (97, "ScriptMap"),
+  ("read_only_space", 0x053d1): (98, "SourcePositionTableWithFrameCacheMap"),
+  ("read_only_space", 0x05421): (99, "SourceTextModuleInfoEntryMap"),
+  ("read_only_space", 0x05471): (100, "StackFrameInfoMap"),
+  ("read_only_space", 0x054c1): (101, "StackTraceFrameMap"),
+  ("read_only_space", 0x05511): (102, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x05561): (103, "Tuple2Map"),
+  ("read_only_space", 0x055b1): (104, "Tuple3Map"),
   ("read_only_space", 0x05601): (105, "WasmCapiFunctionDataMap"),
   ("read_only_space", 0x05651): (106, "WasmDebugInfoMap"),
   ("read_only_space", 0x056a1): (107, "WasmExceptionTagMap"),
   ("read_only_space", 0x056f1): (108, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x05741): (109, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x05791): (110, "CallableTaskMap"),
-  ("read_only_space", 0x057e1): (111, "CallbackTaskMap"),
-  ("read_only_space", 0x05831): (112, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x05881): (113, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x058d1): (114, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x05921): (115, "FinalizationGroupCleanupJobTaskMap"),
-  ("read_only_space", 0x05971): (116, "InternalClassMap"),
-  ("read_only_space", 0x059c1): (117, "SmiPairMap"),
-  ("read_only_space", 0x05a11): (118, "SmiBoxMap"),
-  ("read_only_space", 0x05a61): (119, "SortStateMap"),
-  ("read_only_space", 0x05ab1): (122, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x05b01): (122, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x05b51): (157, "LoadHandler1Map"),
-  ("read_only_space", 0x05ba1): (157, "LoadHandler2Map"),
-  ("read_only_space", 0x05bf1): (157, "LoadHandler3Map"),
-  ("read_only_space", 0x05c41): (165, "StoreHandler0Map"),
-  ("read_only_space", 0x05c91): (165, "StoreHandler1Map"),
-  ("read_only_space", 0x05ce1): (165, "StoreHandler2Map"),
-  ("read_only_space", 0x05d31): (165, "StoreHandler3Map"),
+  ("read_only_space", 0x05741): (109, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x05791): (110, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x057e1): (111, "CallableTaskMap"),
+  ("read_only_space", 0x05831): (112, "CallbackTaskMap"),
+  ("read_only_space", 0x05881): (113, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x058d1): (114, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x05921): (115, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x05971): (116, "FinalizationGroupCleanupJobTaskMap"),
+  ("read_only_space", 0x059c1): (117, "InternalClassMap"),
+  ("read_only_space", 0x05a11): (118, "SmiPairMap"),
+  ("read_only_space", 0x05a61): (119, "SmiBoxMap"),
+  ("read_only_space", 0x05ab1): (120, "SortStateMap"),
+  ("read_only_space", 0x05b01): (123, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x05b51): (123, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x05ba1): (158, "LoadHandler1Map"),
+  ("read_only_space", 0x05bf1): (158, "LoadHandler2Map"),
+  ("read_only_space", 0x05c41): (158, "LoadHandler3Map"),
+  ("read_only_space", 0x05c91): (166, "StoreHandler0Map"),
+  ("read_only_space", 0x05ce1): (166, "StoreHandler1Map"),
+  ("read_only_space", 0x05d31): (166, "StoreHandler2Map"),
+  ("read_only_space", 0x05d81): (166, "StoreHandler3Map"),
   ("map_space", 0x00139): (1057, "ExternalMap"),
   ("map_space", 0x00189): (1073, "JSMessageObjectMap"),
 }