[wasm] Turn {WasmSharedModuleData} into a proper {Struct}.

This makes sure that the object can be identified by a unique instance
type and hence is not accidentally confused with other FixedArrays on
the heap.

R=clemensh@chromium.org
BUG=v8:7509

Change-Id: Ib3dcdb4559821d0ad9ca8cced37754e0e3c1d578
Reviewed-on: https://chromium-review.googlesource.com/943781
Commit-Queue: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#51687}

src/compiler/types.cc

@@ -312,6 +312,7 @@ Type::bitset BitsetType::Lub(i::Map* map) {
     case TUPLE2_TYPE:
     case TUPLE3_TYPE:
     case WASM_DEBUG_INFO_TYPE:
+    case WASM_SHARED_MODULE_DATA_TYPE:
     case LOAD_HANDLER_TYPE:
     case STORE_HANDLER_TYPE:
     case CONTEXT_EXTENSION_TYPE:

src/objects-debug.cc

@@ -1437,6 +1437,17 @@ void WasmDebugInfo::WasmDebugInfoVerify() {
   VerifyObjectField(kCWasmEntryMapOffset);
 }
 
+void WasmSharedModuleData::WasmSharedModuleDataVerify() {
+  CHECK(IsWasmSharedModuleData());
+  VerifyObjectField(kModuleWrapperOffset);
+  CHECK(module_wrapper()->IsForeign());
+  VerifyObjectField(kModuleBytesOffset);
+  VerifyObjectField(kScriptOffset);
+  VerifyObjectField(kAsmJsOffsetTableOffset);
+  VerifyObjectField(kBreakPointInfosOffset);
+  VerifyObjectField(kLazyCompilationOrchestratorOffset);
+}
+
 void DataHandler::DataHandlerVerify() {
   CHECK(IsDataHandler());
   CHECK_IMPLIES(!smi_handler()->IsSmi(),

src/objects-printer.cc

@@ -1470,6 +1470,13 @@ void WasmDebugInfo::WasmDebugInfoPrint(std::ostream& os) {  // NOLINT
   os << "\n";
 }
 
+void WasmSharedModuleData::WasmSharedModuleDataPrint(
+    std::ostream& os) {  // NOLINT
+  HeapObject::PrintHeader(os, "WasmSharedModuleData");
+  os << "\n - module: " << module();
+  os << "\n";
+}
+
 void LoadHandler::LoadHandlerPrint(std::ostream& os) {  // NOLINT
   HeapObject::PrintHeader(os, "LoadHandler");
   // TODO(ishell): implement printing based on handler kind

src/objects.h

@@ -384,6 +384,7 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
   V(TUPLE2_TYPE)                                                \
   V(TUPLE3_TYPE)                                                \
   V(WASM_DEBUG_INFO_TYPE)                                       \
+  V(WASM_SHARED_MODULE_DATA_TYPE)                               \
                                                                 \
   V(CALLABLE_TASK_TYPE)                                         \
   V(CALLBACK_TASK_TYPE)                                         \
@@ -585,6 +586,7 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
   V(TUPLE2, Tuple2, tuple2)                                                  \
   V(TUPLE3, Tuple3, tuple3)                                                  \
   V(WASM_DEBUG_INFO, WasmDebugInfo, wasm_debug_info)                         \
+  V(WASM_SHARED_MODULE_DATA, WasmSharedModuleData, wasm_shared_module_data)  \
   V(CALLABLE_TASK, CallableTask, callable_task)                              \
   V(CALLBACK_TASK, CallbackTask, callback_task)                              \
   V(PROMISE_FULFILL_REACTION_JOB_TASK, PromiseFulfillReactionJobTask,        \
@@ -776,6 +778,7 @@ enum InstanceType : uint16_t {
   TUPLE2_TYPE,
   TUPLE3_TYPE,
   WASM_DEBUG_INFO_TYPE,
+  WASM_SHARED_MODULE_DATA_TYPE,
 
   CALLABLE_TASK_TYPE,  // FIRST_MICROTASK_TYPE
   CALLBACK_TASK_TYPE,

src/wasm/wasm-objects-inl.h

@@ -18,6 +18,7 @@ CAST_ACCESSOR(WasmDebugInfo)
 CAST_ACCESSOR(WasmInstanceObject)
 CAST_ACCESSOR(WasmMemoryObject)
 CAST_ACCESSOR(WasmModuleObject)
+CAST_ACCESSOR(WasmSharedModuleData)
 CAST_ACCESSOR(WasmTableObject)
 
 #define OPTIONAL_ACCESSORS(holder, name, type, offset)           \
@@ -63,6 +64,7 @@ ACCESSORS(WasmInstanceObject, js_imports_table, FixedArray,
           kJsImportsTableOffset)
 
 // WasmSharedModuleData
+ACCESSORS(WasmSharedModuleData, module_wrapper, Object, kModuleWrapperOffset)
 ACCESSORS(WasmSharedModuleData, module_bytes, SeqOneByteString,
           kModuleBytesOffset)
 ACCESSORS(WasmSharedModuleData, script, Script, kScriptOffset)
@@ -72,6 +74,10 @@ OPTIONAL_ACCESSORS(WasmSharedModuleData, breakpoint_infos, FixedArray,
                    kBreakPointInfosOffset)
 OPTIONAL_ACCESSORS(WasmSharedModuleData, lazy_compilation_orchestrator, Foreign,
                    kLazyCompilationOrchestratorOffset)
+void WasmSharedModuleData::reset_breakpoint_infos() {
+  DCHECK(IsWasmSharedModuleData());
+  WRITE_FIELD(this, kBreakPointInfosOffset, GetHeap()->undefined_value());
+}
 
 // WasmDebugInfo
 ACCESSORS(WasmDebugInfo, wasm_instance, WasmInstanceObject, kInstanceOffset)

src/wasm/wasm-objects.cc

@@ -915,59 +915,33 @@ WasmCodeWrapper WasmExportedFunction::GetWasmCode() {
   UNREACHABLE();
 }
 
-bool WasmSharedModuleData::IsWasmSharedModuleData(Object* object) {
-  if (!object->IsFixedArray()) return false;
-  FixedArray* arr = FixedArray::cast(object);
-  if (arr->length() != kFieldCount) return false;
-  Isolate* isolate = arr->GetIsolate();
-  if (!arr->get(kModuleWrapperIndex)->IsForeign()) return false;
-  if (!arr->get(kModuleBytesIndex)->IsUndefined(isolate) &&
-      !arr->get(kModuleBytesIndex)->IsSeqOneByteString())
-    return false;
-  if (!arr->get(kScriptIndex)->IsScript()) return false;
-  if (!arr->get(kAsmJsOffsetTableIndex)->IsUndefined(isolate) &&
-      !arr->get(kAsmJsOffsetTableIndex)->IsByteArray())
-    return false;
-  if (!arr->get(kBreakPointInfosIndex)->IsUndefined(isolate) &&
-      !arr->get(kBreakPointInfosIndex)->IsFixedArray())
-    return false;
-  return true;
-}
-
-WasmSharedModuleData* WasmSharedModuleData::cast(Object* object) {
-  DCHECK(IsWasmSharedModuleData(object));
-  return reinterpret_cast<WasmSharedModuleData*>(object);
-}
-
-WasmModule* WasmSharedModuleData::module() {
+WasmModule* WasmSharedModuleData::module() const {
   // We populate the kModuleWrapper field with a Foreign holding the
   // address to the address of a WasmModule. This is because we can
   // handle both cases when the WasmModule's lifetime is managed through
   // a Managed<WasmModule> object, as well as cases when it's managed
   // by the embedder. CcTests fall into the latter case.
   return *(reinterpret_cast<WasmModule**>(
-      Foreign::cast(get(kModuleWrapperIndex))->foreign_address()));
+      Foreign::cast(module_wrapper())->foreign_address()));
 }
 
 Handle<WasmSharedModuleData> WasmSharedModuleData::New(
     Isolate* isolate, Handle<Foreign> module_wrapper,
     Handle<SeqOneByteString> module_bytes, Handle<Script> script,
     Handle<ByteArray> asm_js_offset_table) {
-  Handle<FixedArray> arr =
-      isolate->factory()->NewFixedArray(kFieldCount, TENURED);
-  arr->set(kModuleWrapperIndex, *module_wrapper);
+  Handle<WasmSharedModuleData> data = Handle<WasmSharedModuleData>::cast(
+      isolate->factory()->NewStruct(WASM_SHARED_MODULE_DATA_TYPE, TENURED));
+  data->set_module_wrapper(*module_wrapper);
   if (!module_bytes.is_null()) {
-    arr->set(kModuleBytesIndex, *module_bytes);
+    data->set_module_bytes(*module_bytes);
   }
   if (!script.is_null()) {
-    arr->set(kScriptIndex, *script);
+    data->set_script(*script);
   }
   if (!asm_js_offset_table.is_null()) {
-    arr->set(kAsmJsOffsetTableIndex, *asm_js_offset_table);
+    data->set_asm_js_offset_table(*asm_js_offset_table);
   }
-
-  DCHECK(WasmSharedModuleData::IsWasmSharedModuleData(*arr));
-  return Handle<WasmSharedModuleData>::cast(arr);
+  return data;
 }
 
 bool WasmSharedModuleData::is_asm_js() {
@@ -979,7 +953,7 @@ bool WasmSharedModuleData::is_asm_js() {
 
 void WasmSharedModuleData::ReinitializeAfterDeserialization(
     Isolate* isolate, Handle<WasmSharedModuleData> shared) {
-  DCHECK(shared->get(kModuleWrapperIndex)->IsUndefined(isolate));
+  DCHECK(shared->module_wrapper()->IsUndefined(isolate));
 #ifdef DEBUG
   // No BreakpointInfo objects should survive deserialization.
   if (shared->has_breakpoint_infos()) {
@@ -989,7 +963,7 @@ void WasmSharedModuleData::ReinitializeAfterDeserialization(
   }
 #endif
 
-  shared->set(kBreakPointInfosIndex, isolate->heap()->undefined_value());
+  shared->reset_breakpoint_infos();
 
   WasmModule* module = nullptr;
   {
@@ -1014,8 +988,7 @@ void WasmSharedModuleData::ReinitializeAfterDeserialization(
   Handle<wasm::WasmModuleWrapper> module_wrapper =
       wasm::WasmModuleWrapper::From(isolate, module);
 
-  shared->set(kModuleWrapperIndex, *module_wrapper);
-  DCHECK(WasmSharedModuleData::IsWasmSharedModuleData(*shared));
+  shared->set_module_wrapper(*module_wrapper);
 }
 
 namespace {
@@ -1059,7 +1032,7 @@ void WasmSharedModuleData::AddBreakpoint(Handle<WasmSharedModuleData> shared,
     breakpoint_infos = handle(shared->breakpoint_infos(), isolate);
   } else {
     breakpoint_infos = isolate->factory()->NewFixedArray(4, TENURED);
-    shared->set(kBreakPointInfosIndex, *breakpoint_infos);
+    shared->set_breakpoint_infos(*breakpoint_infos);
   }
 
   int insert_pos =
@@ -1083,7 +1056,7 @@ void WasmSharedModuleData::AddBreakpoint(Handle<WasmSharedModuleData> shared,
   if (need_realloc) {
     new_breakpoint_infos = isolate->factory()->NewFixedArray(
         2 * breakpoint_infos->length(), TENURED);
-    shared->set(kBreakPointInfosIndex, *new_breakpoint_infos);
+    shared->set_breakpoint_infos(*new_breakpoint_infos);
     // Copy over the entries [0, insert_pos).
     for (int i = 0; i < insert_pos; ++i)
       new_breakpoint_infos->set(i, breakpoint_infos->get(i));
@@ -1699,7 +1672,6 @@ void WasmCompiledModule::ReinitializeAfterDeserialization(
       static_cast<WasmSharedModuleData*>(compiled_module->get(kID_shared)),
       isolate);
   if (!FLAG_wasm_jit_to_native) {
-    DCHECK(!WasmSharedModuleData::IsWasmSharedModuleData(*shared));
     WasmSharedModuleData::ReinitializeAfterDeserialization(isolate, shared);
   }
   size_t function_table_count =
@@ -1728,7 +1700,6 @@ void WasmCompiledModule::ReinitializeAfterDeserialization(
   // Reset, but don't delete any global handles, because their owning instance
   // may still be active.
   WasmCompiledModule::Reset(isolate, *compiled_module);
-  DCHECK(WasmSharedModuleData::IsWasmSharedModuleData(*shared));
 }
 
 MaybeHandle<String> WasmSharedModuleData::GetModuleNameOrNull(

src/wasm/wasm-objects.h

@@ -40,11 +40,6 @@ class WasmInstanceObject;
 
 #define WASM_CONTEXT_TABLES FLAG_wasm_jit_to_native
 
-#define DECL_OOL_QUERY(type) static bool Is##type(Object* object);
-#define DECL_OOL_CAST(type) static type* cast(Object* object);
-
-#define DECL_GETTER(name, type) type* name();
-
 #define DECL_OPTIONAL_ACCESSORS(name, type) \
   INLINE(bool has_##name());                \
   DECL_ACCESSORS(name, type)
@@ -301,34 +296,35 @@ class WasmExportedFunction : public JSFunction {
 };
 
 // Information shared by all WasmCompiledModule objects for the same module.
-class WasmSharedModuleData : public FixedArray {
+class WasmSharedModuleData : public Struct {
  public:
-  DECL_OOL_QUERY(WasmSharedModuleData)
-  DECL_OOL_CAST(WasmSharedModuleData)
-
-  DECL_GETTER(module, wasm::WasmModule)
+  DECL_ACCESSORS(module_wrapper, Object)
+  wasm::WasmModule* module() const;
   DECL_OPTIONAL_ACCESSORS(module_bytes, SeqOneByteString)
   DECL_ACCESSORS(script, Script)
   DECL_OPTIONAL_ACCESSORS(asm_js_offset_table, ByteArray)
   DECL_OPTIONAL_ACCESSORS(breakpoint_infos, FixedArray)
+  inline void reset_breakpoint_infos();
 
-  enum {  // --
-    kModuleWrapperIndex,
-    kModuleBytesIndex,
-    kScriptIndex,
-    kAsmJsOffsetTableIndex,
-    kBreakPointInfosIndex,
-    kLazyCompilationOrchestratorIndex,
-    kFieldCount
-  };
+  DECL_CAST(WasmSharedModuleData)
+
+  // Dispatched behavior.
+  DECL_PRINTER(WasmSharedModuleData)
+  DECL_VERIFIER(WasmSharedModuleData)
+
+// Layout description.
+#define WASM_SHARED_MODULE_DATA_FIELDS(V)             \
+  V(kModuleWrapperOffset, kPointerSize)               \
+  V(kModuleBytesOffset, kPointerSize)                 \
+  V(kScriptOffset, kPointerSize)                      \
+  V(kAsmJsOffsetTableOffset, kPointerSize)            \
+  V(kBreakPointInfosOffset, kPointerSize)             \
+  V(kLazyCompilationOrchestratorOffset, kPointerSize) \
+  V(kSize, 0)
 
-  DEF_SIZE(FixedArray)
-  DEF_OFFSET(ModuleWrapper)
-  DEF_OFFSET(ModuleBytes)
-  DEF_OFFSET(Script)
-  DEF_OFFSET(AsmJsOffsetTable)
-  DEF_OFFSET(BreakPointInfos)
-  DEF_OFFSET(LazyCompilationOrchestrator)
+  DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
+                                WASM_SHARED_MODULE_DATA_FIELDS)
+#undef WASM_SHARED_MODULE_DATA_FIELDS
 
   // Check whether this module was generated from asm.js source.
   bool is_asm_js();
@@ -487,7 +483,7 @@ class WasmCompiledModule : public FixedArray {
 // By default, instance values go to WasmInstanceObject, however, if
 // we embed the generated code with a value, then we track that value here.
 #define CORE_WCM_PROPERTY_TABLE(MACRO)                  \
-  MACRO(WASM_OBJECT, WasmSharedModuleData, shared)      \
+  MACRO(CONST_OBJECT, WasmSharedModuleData, shared)     \
   MACRO(WEAK_LINK, Context, native_context)             \
   MACRO(CONST_OBJECT, FixedArray, export_wrappers)      \
   MACRO(OBJECT, FixedArray, weak_exported_functions)    \
@@ -700,9 +696,6 @@ struct WasmFunctionInfo {
 };
 WasmFunctionInfo GetWasmFunctionInfo(Isolate*, Handle<Code>);
 
-#undef DECL_OOL_QUERY
-#undef DECL_OOL_CAST
-#undef DECL_GETTER
 #undef DECL_OPTIONAL_ACCESSORS
 #undef WCM_CONST_OBJECT
 #undef WCM_LARGE_NUMBER

tools/v8heapconst.py

@@ -75,28 +75,29 @@ INSTANCE_TYPES = {
   171: "TUPLE2_TYPE",
   172: "TUPLE3_TYPE",
   173: "WASM_DEBUG_INFO_TYPE",
-  174: "CALLABLE_TASK_TYPE",
-  175: "CALLBACK_TASK_TYPE",
-  176: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
-  177: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
-  178: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
-  179: "FIXED_ARRAY_TYPE",
-  180: "DESCRIPTOR_ARRAY_TYPE",
-  181: "HASH_TABLE_TYPE",
-  182: "SCOPE_INFO_TYPE",
-  183: "TRANSITION_ARRAY_TYPE",
-  184: "CELL_TYPE",
-  185: "CODE_DATA_CONTAINER_TYPE",
-  186: "FEEDBACK_CELL_TYPE",
-  187: "FEEDBACK_VECTOR_TYPE",
-  188: "LOAD_HANDLER_TYPE",
-  189: "PROPERTY_ARRAY_TYPE",
-  190: "PROPERTY_CELL_TYPE",
-  191: "SHARED_FUNCTION_INFO_TYPE",
-  192: "SMALL_ORDERED_HASH_MAP_TYPE",
-  193: "SMALL_ORDERED_HASH_SET_TYPE",
-  194: "STORE_HANDLER_TYPE",
-  195: "WEAK_CELL_TYPE",
+  174: "WASM_SHARED_MODULE_DATA_TYPE",
+  175: "CALLABLE_TASK_TYPE",
+  176: "CALLBACK_TASK_TYPE",
+  177: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
+  178: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
+  179: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
+  180: "FIXED_ARRAY_TYPE",
+  181: "DESCRIPTOR_ARRAY_TYPE",
+  182: "HASH_TABLE_TYPE",
+  183: "SCOPE_INFO_TYPE",
+  184: "TRANSITION_ARRAY_TYPE",
+  185: "CELL_TYPE",
+  186: "CODE_DATA_CONTAINER_TYPE",
+  187: "FEEDBACK_CELL_TYPE",
+  188: "FEEDBACK_VECTOR_TYPE",
+  189: "LOAD_HANDLER_TYPE",
+  190: "PROPERTY_ARRAY_TYPE",
+  191: "PROPERTY_CELL_TYPE",
+  192: "SHARED_FUNCTION_INFO_TYPE",
+  193: "SMALL_ORDERED_HASH_MAP_TYPE",
+  194: "SMALL_ORDERED_HASH_SET_TYPE",
+  195: "STORE_HANDLER_TYPE",
+  196: "WEAK_CELL_TYPE",
   1024: "JS_PROXY_TYPE",
   1025: "JS_GLOBAL_OBJECT_TYPE",
   1026: "JS_GLOBAL_PROXY_TYPE",
@@ -181,8 +182,8 @@ KNOWN_MAPS = {
   0x02201: (138, "FreeSpaceMap"),
   0x02259: (132, "MetaMap"),
   0x022b1: (131, "NullMap"),
-  0x02309: (180, "DescriptorArrayMap"),
-  0x02361: (179, "FixedArrayMap"),
+  0x02309: (181, "DescriptorArrayMap"),
+  0x02361: (180, "FixedArrayMap"),
   0x023b9: (151, "OnePointerFillerMap"),
   0x02411: (151, "TwoPointerFillerMap"),
   0x02469: (131, "UninitializedMap"),
@@ -192,57 +193,57 @@ KNOWN_MAPS = {
   0x025c9: (131, "TheHoleMap"),
   0x02621: (131, "BooleanMap"),
   0x02679: (136, "ByteArrayMap"),
-  0x026d1: (179, "FixedCOWArrayMap"),
-  0x02729: (181, "HashTableMap"),
+  0x026d1: (180, "FixedCOWArrayMap"),
+  0x02729: (182, "HashTableMap"),
   0x02781: (128, "SymbolMap"),
   0x027d9: (72, "OneByteStringMap"),
-  0x02831: (182, "ScopeInfoMap"),
-  0x02889: (191, "SharedFunctionInfoMap"),
+  0x02831: (183, "ScopeInfoMap"),
+  0x02889: (192, "SharedFunctionInfoMap"),
   0x028e1: (133, "CodeMap"),
-  0x02939: (179, "FunctionContextMap"),
-  0x02991: (184, "CellMap"),
-  0x029e9: (195, "WeakCellMap"),
-  0x02a41: (190, "GlobalPropertyCellMap"),
+  0x02939: (180, "FunctionContextMap"),
+  0x02991: (185, "CellMap"),
+  0x029e9: (196, "WeakCellMap"),
+  0x02a41: (191, "GlobalPropertyCellMap"),
   0x02a99: (135, "ForeignMap"),
-  0x02af1: (183, "TransitionArrayMap"),
-  0x02b49: (187, "FeedbackVectorMap"),
+  0x02af1: (184, "TransitionArrayMap"),
+  0x02b49: (188, "FeedbackVectorMap"),
   0x02ba1: (131, "ArgumentsMarkerMap"),
   0x02bf9: (131, "ExceptionMap"),
   0x02c51: (131, "TerminationExceptionMap"),
   0x02ca9: (131, "OptimizedOutMap"),
   0x02d01: (131, "StaleRegisterMap"),
-  0x02d59: (179, "NativeContextMap"),
-  0x02db1: (179, "ModuleContextMap"),
-  0x02e09: (179, "EvalContextMap"),
-  0x02e61: (179, "ScriptContextMap"),
-  0x02eb9: (179, "BlockContextMap"),
-  0x02f11: (179, "CatchContextMap"),
-  0x02f69: (179, "WithContextMap"),
-  0x02fc1: (179, "DebugEvaluateContextMap"),
-  0x03019: (179, "ScriptContextTableMap"),
-  0x03071: (179, "ArrayListMap"),
+  0x02d59: (180, "NativeContextMap"),
+  0x02db1: (180, "ModuleContextMap"),
+  0x02e09: (180, "EvalContextMap"),
+  0x02e61: (180, "ScriptContextMap"),
+  0x02eb9: (180, "BlockContextMap"),
+  0x02f11: (180, "CatchContextMap"),
+  0x02f69: (180, "WithContextMap"),
+  0x02fc1: (180, "DebugEvaluateContextMap"),
+  0x03019: (180, "ScriptContextTableMap"),
+  0x03071: (180, "ArrayListMap"),
   0x030c9: (150, "FixedDoubleArrayMap"),
   0x03121: (134, "MutableHeapNumberMap"),
-  0x03179: (181, "OrderedHashMapMap"),
-  0x031d1: (181, "OrderedHashSetMap"),
-  0x03229: (181, "NameDictionaryMap"),
-  0x03281: (181, "GlobalDictionaryMap"),
-  0x032d9: (181, "NumberDictionaryMap"),
-  0x03331: (181, "SimpleNumberDictionaryMap"),
-  0x03389: (181, "StringTableMap"),
-  0x033e1: (181, "WeakHashTableMap"),
-  0x03439: (179, "SloppyArgumentsElementsMap"),
-  0x03491: (192, "SmallOrderedHashMapMap"),
-  0x034e9: (193, "SmallOrderedHashSetMap"),
-  0x03541: (185, "CodeDataContainerMap"),
+  0x03179: (182, "OrderedHashMapMap"),
+  0x031d1: (182, "OrderedHashSetMap"),
+  0x03229: (182, "NameDictionaryMap"),
+  0x03281: (182, "GlobalDictionaryMap"),
+  0x032d9: (182, "NumberDictionaryMap"),
+  0x03331: (182, "SimpleNumberDictionaryMap"),
+  0x03389: (182, "StringTableMap"),
+  0x033e1: (182, "WeakHashTableMap"),
+  0x03439: (180, "SloppyArgumentsElementsMap"),
+  0x03491: (193, "SmallOrderedHashMapMap"),
+  0x034e9: (194, "SmallOrderedHashSetMap"),
+  0x03541: (186, "CodeDataContainerMap"),
   0x03599: (1071, "JSMessageObjectMap"),
   0x035f1: (1057, "ExternalMap"),
   0x03649: (137, "BytecodeArrayMap"),
-  0x036a1: (179, "ModuleInfoMap"),
-  0x036f9: (186, "NoClosuresCellMap"),
-  0x03751: (186, "OneClosureCellMap"),
-  0x037a9: (186, "ManyClosuresCellMap"),
-  0x03801: (189, "PropertyArrayMap"),
+  0x036a1: (180, "ModuleInfoMap"),
+  0x036f9: (187, "NoClosuresCellMap"),
+  0x03751: (187, "OneClosureCellMap"),
+  0x037a9: (187, "ManyClosuresCellMap"),
+  0x03801: (190, "PropertyArrayMap"),
   0x03859: (130, "BigIntMap"),
   0x038b1: (106, "NativeSourceStringMap"),
   0x03909: (64, "StringMap"),
@@ -298,11 +299,12 @@ KNOWN_MAPS = {
   0x04a39: (170, "StackFrameInfoMap"),
   0x04a91: (172, "Tuple3Map"),
   0x04ae9: (173, "WasmDebugInfoMap"),
-  0x04b41: (174, "CallableTaskMap"),
-  0x04b99: (175, "CallbackTaskMap"),
-  0x04bf1: (176, "PromiseFulfillReactionJobTaskMap"),
-  0x04c49: (177, "PromiseRejectReactionJobTaskMap"),
-  0x04ca1: (178, "PromiseResolveThenableJobTaskMap"),
+  0x04b41: (174, "WasmSharedModuleDataMap"),
+  0x04b99: (175, "CallableTaskMap"),
+  0x04bf1: (176, "CallbackTaskMap"),
+  0x04c49: (177, "PromiseFulfillReactionJobTaskMap"),
+  0x04ca1: (178, "PromiseRejectReactionJobTaskMap"),
+  0x04cf9: (179, "PromiseResolveThenableJobTaskMap"),
 }
 
 # List of known V8 objects.