[symbol table] use plain hash table to implement symbol table in isolate

The per-Isolate Symbol tables are implemented using NameDictionary
before, which has additional property details overhead
And NameDictionary is limited to 2^23, which limits the Symbol
tables to be a maximum of 2^23.

- replace NameDictionary with SymbolTable in isolate

Bug: v8:12575
Change-Id: Ica4f05aac3494f7dfa3a074c240d4ba25df814e9
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3476897Reviewed-by: Shu-yu Guo <syg@chromium.org>
Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/main@{#79285}

BUILD.bazel

@@ -1751,6 +1751,7 @@ filegroup(
         "src/objects/string-set.h",
         "src/objects/string-table-inl.h",
         "src/objects/string-table.cc",
+        "src/objects/symbol-table.cc",
         "src/objects/string-table.h",
         "src/objects/string.cc",
         "src/objects/string.h",

BUILD.gn

@@ -4348,6 +4348,7 @@ v8_source_set("v8_base_without_compiler") {
     "src/objects/string-table.cc",
     "src/objects/string.cc",
     "src/objects/swiss-name-dictionary.cc",
+    "src/objects/symbol-table.cc",
     "src/objects/synthetic-module.cc",
     "src/objects/tagged-impl.cc",
     "src/objects/template-objects.cc",

src/builtins/base.tq

@@ -214,6 +214,7 @@ extern class OrderedHashMap extends HashTable;
 extern class OrderedHashSet extends HashTable;
 extern class OrderedNameDictionary extends HashTable;
 extern class NameToIndexHashTable extends HashTable;
+extern class RegisteredSymbolTable extends HashTable;
 extern class NameDictionary extends HashTable;
 extern class GlobalDictionary extends HashTable;
 extern class SimpleNumberDictionary extends HashTable;

src/diagnostics/objects-debug.cc

@@ -205,6 +205,7 @@ void HeapObject::HeapObjectVerify(Isolate* isolate) {
     case ORDERED_HASH_SET_TYPE:
     case ORDERED_NAME_DICTIONARY_TYPE:
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
+    case REGISTERED_SYMBOL_TABLE_TYPE:
     case NAME_DICTIONARY_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:

src/diagnostics/objects-printer.cc

@@ -141,6 +141,9 @@ void HeapObject::HeapObjectPrint(std::ostream& os) {
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
       NameToIndexHashTable::cast(*this).NameToIndexHashTablePrint(os);
       break;
+    case REGISTERED_SYMBOL_TABLE_TYPE:
+      RegisteredSymbolTable::cast(*this).RegisteredSymbolTablePrint(os);
+      break;
     case ORDERED_HASH_MAP_TYPE:
       OrderedHashMap::cast(*this).OrderedHashMapPrint(os);
       break;
@@ -969,6 +972,11 @@ void NameToIndexHashTable::NameToIndexHashTablePrint(std::ostream& os) {
   PrintHashMapContentsFull(os, *this);
 }
 
+void RegisteredSymbolTable::RegisteredSymbolTablePrint(std::ostream& os) {
+  PrintHashTableHeader(os, *this, "RegisteredSymbolTable");
+  PrintHashMapContentsFull(os, *this);
+}
+
 void NumberDictionary::NumberDictionaryPrint(std::ostream& os) {
   PrintHashTableHeader(os, *this, "NumberDictionary");
   PrintDictionaryContentsFull(os, *this);

src/execution/isolate.cc

@@ -4477,16 +4477,16 @@ ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 Handle<Symbol> Isolate::SymbolFor(RootIndex dictionary_index,
                                   Handle<String> name, bool private_symbol) {
   Handle<String> key = factory()->InternalizeString(name);
-  Handle<NameDictionary> dictionary =
-      Handle<NameDictionary>::cast(root_handle(dictionary_index));
+  Handle<RegisteredSymbolTable> dictionary =
+      Handle<RegisteredSymbolTable>::cast(root_handle(dictionary_index));
   InternalIndex entry = dictionary->FindEntry(this, key);
   Handle<Symbol> symbol;
   if (entry.is_not_found()) {
     symbol =
         private_symbol ? factory()->NewPrivateSymbol() : factory()->NewSymbol();
     symbol->set_description(*key);
-    dictionary = NameDictionary::Add(this, dictionary, key, symbol,
-                                     PropertyDetails::Empty(), &entry);
+    dictionary = RegisteredSymbolTable::Add(this, dictionary, key, symbol);
+
     switch (dictionary_index) {
       case RootIndex::kPublicSymbolTable:
         symbol->set_is_in_public_symbol_table(true);

src/heap/setup-heap-internal.cc

@@ -477,6 +477,7 @@ bool Heap::CreateInitialMaps() {
                          simple_number_dictionary)
     ALLOCATE_VARSIZE_MAP(NAME_TO_INDEX_HASH_TABLE_TYPE,
                          name_to_index_hash_table)
+    ALLOCATE_VARSIZE_MAP(REGISTERED_SYMBOL_TABLE_TYPE, registered_symbol_table)
 
     ALLOCATE_VARSIZE_MAP(EMBEDDER_DATA_ARRAY_TYPE, embedder_data_array)
     ALLOCATE_VARSIZE_MAP(EPHEMERON_HASH_TABLE_TYPE, ephemeron_hash_table)
@@ -796,9 +797,12 @@ void Heap::CreateInitialObjects() {
 
   set_empty_property_dictionary(*empty_property_dictionary);
 
-  set_public_symbol_table(*empty_property_dictionary);
-  set_api_symbol_table(*empty_property_dictionary);
-  set_api_private_symbol_table(*empty_property_dictionary);
+  Handle<RegisteredSymbolTable> empty_symbol_table = RegisteredSymbolTable::New(
+      isolate(), 1, AllocationType::kReadOnly, USE_CUSTOM_MINIMUM_CAPACITY);
+  DCHECK(!empty_symbol_table->HasSufficientCapacityToAdd(1));
+  set_public_symbol_table(*empty_symbol_table);
+  set_api_symbol_table(*empty_symbol_table);
+  set_api_private_symbol_table(*empty_symbol_table);
 
   set_number_string_cache(*factory->NewFixedArray(
       kInitialNumberStringCacheSize * 2, AllocationType::kOld));

src/objects/hash-table-inl.h

@@ -35,6 +35,11 @@ ObjectHashTable::ObjectHashTable(Address ptr)
   SLOW_DCHECK(IsObjectHashTable());
 }
 
+RegisteredSymbolTable::RegisteredSymbolTable(Address ptr)
+    : HashTable<RegisteredSymbolTable, RegisteredSymbolTableShape>(ptr) {
+  SLOW_DCHECK(IsRegisteredSymbolTable());
+}
+
 EphemeronHashTable::EphemeronHashTable(Address ptr)
     : ObjectHashTableBase<EphemeronHashTable, ObjectHashTableShape>(ptr) {
   SLOW_DCHECK(IsEphemeronHashTable());
@@ -51,6 +56,7 @@ NameToIndexHashTable::NameToIndexHashTable(Address ptr)
 }
 
 CAST_ACCESSOR(ObjectHashTable)
+CAST_ACCESSOR(RegisteredSymbolTable)
 CAST_ACCESSOR(EphemeronHashTable)
 CAST_ACCESSOR(ObjectHashSet)
 CAST_ACCESSOR(NameToIndexHashTable)
@@ -135,6 +141,11 @@ Handle<Map> NameToIndexHashTable::GetMap(ReadOnlyRoots roots) {
   return roots.name_to_index_hash_table_map_handle();
 }
 
+// static
+Handle<Map> RegisteredSymbolTable::GetMap(ReadOnlyRoots roots) {
+  return roots.registered_symbol_table_map_handle();
+}
+
 // static
 Handle<Map> EphemeronHashTable::GetMap(ReadOnlyRoots roots) {
   return roots.ephemeron_hash_table_map_handle();
@@ -265,6 +276,21 @@ bool ObjectHashTableShape::IsMatch(Handle<Object> key, Object other) {
   return key->SameValue(other);
 }
 
+bool RegisteredSymbolTableShape::IsMatch(Handle<String> key, Object value) {
+  DCHECK(value.IsString());
+  return key->Equals(String::cast(value));
+}
+
+uint32_t RegisteredSymbolTableShape::Hash(ReadOnlyRoots roots,
+                                          Handle<String> key) {
+  return key->EnsureHash();
+}
+
+uint32_t RegisteredSymbolTableShape::HashForObject(ReadOnlyRoots roots,
+                                                   Object object) {
+  return String::cast(object).EnsureHash();
+}
+
 bool NameToIndexShape::IsMatch(Handle<Name> key, Object other) {
   return *key == other;
 }

src/objects/hash-table.h

@@ -479,6 +479,43 @@ class V8_EXPORT_PRIVATE NameToIndexHashTable
   }
 };
 
+class RegisteredSymbolTableShape : public BaseShape<Handle<String>> {
+ public:
+  static inline bool IsMatch(Handle<String> key, Object other);
+  static inline uint32_t Hash(ReadOnlyRoots roots, Handle<String> key);
+  static inline uint32_t HashForObject(ReadOnlyRoots roots, Object object);
+  static const int kPrefixSize = 0;
+  static const int kEntryValueIndex = 1;
+  static const int kEntrySize = 2;
+  static const bool kMatchNeedsHoleCheck = false;
+};
+
+class RegisteredSymbolTable
+    : public HashTable<RegisteredSymbolTable, RegisteredSymbolTableShape> {
+ public:
+  Object SlowReverseLookup(Object value);
+
+  // Returns the value at entry.
+  Object ValueAt(InternalIndex entry);
+
+  inline static Handle<Map> GetMap(ReadOnlyRoots roots);
+
+  static Handle<RegisteredSymbolTable> Add(Isolate* isolate,
+                                           Handle<RegisteredSymbolTable> table,
+                                           Handle<String> key, Handle<Symbol>);
+
+  DECL_CAST(RegisteredSymbolTable)
+  DECL_PRINTER(RegisteredSymbolTable)
+  OBJECT_CONSTRUCTORS(
+      RegisteredSymbolTable,
+      HashTable<RegisteredSymbolTable, RegisteredSymbolTableShape>);
+
+ private:
+  static inline int EntryToValueIndex(InternalIndex entry) {
+    return EntryToIndex(entry) + RegisteredSymbolTableShape::kEntryValueIndex;
+  }
+};
+
 }  // namespace internal
 }  // namespace v8
 

src/objects/map.cc

@@ -130,6 +130,7 @@ VisitorId Map::GetVisitorId(Map map) {
 
     case OBJECT_BOILERPLATE_DESCRIPTION_TYPE:
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
+    case REGISTERED_SYMBOL_TABLE_TYPE:
     case CLOSURE_FEEDBACK_CELL_ARRAY_TYPE:
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:

src/objects/object-list-macros.h

@@ -220,6 +220,7 @@ class ZoneForwardList;
   V(StoreHandler)                              \
   V(String)                                    \
   V(StringSet)                                 \
+  V(RegisteredSymbolTable)                     \
   V(StringWrapper)                             \
   V(Struct)                                    \
   V(SwissNameDictionary)                       \

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

@@ -1070,6 +1070,7 @@ auto BodyDescriptorApply(InstanceType type, Args&&... args) {
     case NUMBER_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
+    case REGISTERED_SYMBOL_TABLE_TYPE:
     case SCRIPT_CONTEXT_TABLE_TYPE:
       return CALL_APPLY(FixedArray);
     case EPHEMERON_HASH_TABLE_TYPE:

src/objects/objects.cc

@@ -2330,6 +2330,7 @@ bool HeapObject::NeedsRehashing(InstanceType instance_type) const {
       return false;  // We'll rehash from the JSMap or JSSet referencing them.
     case NAME_DICTIONARY_TYPE:
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
+    case REGISTERED_SYMBOL_TABLE_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:
@@ -2359,6 +2360,7 @@ bool HeapObject::CanBeRehashed(PtrComprCageBase cage_base) const {
       return false;
     case NAME_DICTIONARY_TYPE:
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
+    case REGISTERED_SYMBOL_TABLE_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:
@@ -2391,6 +2393,9 @@ void HeapObject::RehashBasedOnMap(IsolateT* isolate) {
     case NAME_TO_INDEX_HASH_TABLE_TYPE:
       NameToIndexHashTable::cast(*this).Rehash(isolate);
       break;
+    case REGISTERED_SYMBOL_TABLE_TYPE:
+      RegisteredSymbolTable::cast(*this).Rehash(isolate);
+      break;
     case SWISS_NAME_DICTIONARY_TYPE:
       SwissNameDictionary::cast(*this).Rehash(isolate);
       break;
@@ -5993,6 +5998,21 @@ bool StringSet::Has(Isolate* isolate, Handle<String> name) {
   return FindEntry(isolate, *name).is_found();
 }
 
+Handle<RegisteredSymbolTable> RegisteredSymbolTable::Add(
+    Isolate* isolate, Handle<RegisteredSymbolTable> table, Handle<String> key,
+    Handle<Symbol> symbol) {
+  // Validate that the key is absent.
+  SLOW_DCHECK(table->FindEntry(isolate, key).is_not_found());
+
+  table = EnsureCapacity(isolate, table);
+  uint32_t hash = ShapeT::Hash(ReadOnlyRoots(isolate), key);
+  InternalIndex entry = table->FindInsertionEntry(isolate, hash);
+  table->set(EntryToIndex(entry), *key);
+  table->set(EntryToValueIndex(entry), *symbol);
+  table->ElementAdded();
+  return table;
+}
+
 Handle<ObjectHashSet> ObjectHashSet::Add(Isolate* isolate,
                                          Handle<ObjectHashSet> set,
                                          Handle<Object> key) {
@@ -6322,6 +6342,10 @@ Object ObjectHashTableBase<Derived, Shape>::ValueAt(InternalIndex entry) {
   return this->get(EntryToValueIndex(entry));
 }
 
+Object RegisteredSymbolTable::ValueAt(InternalIndex entry) {
+  return this->get(EntryToValueIndex(entry));
+}
+
 Object NameToIndexHashTable::ValueAt(InternalIndex entry) {
   return this->get(EntryToValueIndex(entry));
 }
@@ -6911,6 +6935,7 @@ EXTERN_DEFINE_HASH_TABLE(StringSet, StringSetShape)
 EXTERN_DEFINE_HASH_TABLE(CompilationCacheTable, CompilationCacheShape)
 EXTERN_DEFINE_HASH_TABLE(ObjectHashSet, ObjectHashSetShape)
 EXTERN_DEFINE_HASH_TABLE(NameToIndexHashTable, NameToIndexShape)
+EXTERN_DEFINE_HASH_TABLE(RegisteredSymbolTable, RegisteredSymbolTableShape)
 
 EXTERN_DEFINE_OBJECT_BASE_HASH_TABLE(ObjectHashTable, ObjectHashTableShape)
 EXTERN_DEFINE_OBJECT_BASE_HASH_TABLE(EphemeronHashTable, ObjectHashTableShape)

src/objects/symbol-table.cc

+// Copyright 2022 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/objects/hash-table-inl.h"
+
+namespace v8 {
+namespace internal {
+
+Object RegisteredSymbolTable::SlowReverseLookup(Object value) {
+  ReadOnlyRoots roots = this->GetReadOnlyRoots();
+  for (InternalIndex i : this->IterateEntries()) {
+    Object k;
+    if (!this->ToKey(roots, i, &k)) continue;
+    Object e = this->ValueAt(i);
+    if (e == value) return k;
+  }
+  return roots.undefined_value();
+}
+
+}  // namespace internal
+}  // namespace v8

src/roots/roots.h

@@ -97,6 +97,7 @@ class Symbol;
   V(Map, ordered_hash_map_map, OrderedHashMapMap)                              \
   V(Map, ordered_hash_set_map, OrderedHashSetMap)                              \
   V(Map, name_to_index_hash_table_map, NameToIndexHashTableMap)                \
+  V(Map, registered_symbol_table_map, RegisteredSymbolTableMap)                \
   V(Map, ordered_name_dictionary_map, OrderedNameDictionaryMap)                \
   V(Map, preparse_data_map, PreparseDataMap)                                   \
   V(Map, property_array_map, PropertyArrayMap)                                 \
@@ -294,34 +295,34 @@ class Symbol;
   V(SharedFunctionInfo, proxy_revoke_shared_fun, ProxyRevokeSharedFun)
 
 // These root references can be updated by the mutator.
-#define STRONG_MUTABLE_MOVABLE_ROOT_LIST(V)                                \
-  /* Caches */                                                             \
-  V(FixedArray, number_string_cache, NumberStringCache)                    \
-  /* Lists and dictionaries */                                             \
-  V(NameDictionary, public_symbol_table, PublicSymbolTable)                \
-  V(NameDictionary, api_symbol_table, ApiSymbolTable)                      \
-  V(NameDictionary, api_private_symbol_table, ApiPrivateSymbolTable)       \
-  V(WeakArrayList, script_list, ScriptList)                                \
-  V(FixedArray, materialized_objects, MaterializedObjects)                 \
-  V(WeakArrayList, detached_contexts, DetachedContexts)                    \
-  V(WeakArrayList, retaining_path_targets, RetainingPathTargets)           \
-  /* Feedback vectors that we need for code coverage or type profile */    \
-  V(Object, feedback_vectors_for_profiling_tools,                          \
-    FeedbackVectorsForProfilingTools)                                      \
-  V(FixedArray, serialized_objects, SerializedObjects)                     \
-  V(FixedArray, serialized_global_proxy_sizes, SerializedGlobalProxySizes) \
-  V(TemplateList, message_listeners, MessageListeners)                     \
-  /* Support for async stack traces */                                     \
-  V(HeapObject, current_microtask, CurrentMicrotask)                       \
-  /* KeepDuringJob set for JS WeakRefs */                                  \
-  V(HeapObject, weak_refs_keep_during_job, WeakRefsKeepDuringJob)          \
-  V(HeapObject, interpreter_entry_trampoline_for_profiling,                \
-    InterpreterEntryTrampolineForProfiling)                                \
-  V(Object, pending_optimize_for_test_bytecode,                            \
-    PendingOptimizeForTestBytecode)                                        \
-  V(ArrayList, basic_block_profiling_data, BasicBlockProfilingData)        \
-  V(WeakArrayList, shared_wasm_memories, SharedWasmMemories)               \
-  IF_WASM(V, HeapObject, active_continuation, ActiveContinuation)          \
+#define STRONG_MUTABLE_MOVABLE_ROOT_LIST(V)                                 \
+  /* Caches */                                                              \
+  V(FixedArray, number_string_cache, NumberStringCache)                     \
+  /* Lists and dictionaries */                                              \
+  V(RegisteredSymbolTable, public_symbol_table, PublicSymbolTable)          \
+  V(RegisteredSymbolTable, api_symbol_table, ApiSymbolTable)                \
+  V(RegisteredSymbolTable, api_private_symbol_table, ApiPrivateSymbolTable) \
+  V(WeakArrayList, script_list, ScriptList)                                 \
+  V(FixedArray, materialized_objects, MaterializedObjects)                  \
+  V(WeakArrayList, detached_contexts, DetachedContexts)                     \
+  V(WeakArrayList, retaining_path_targets, RetainingPathTargets)            \
+  /* Feedback vectors that we need for code coverage or type profile */     \
+  V(Object, feedback_vectors_for_profiling_tools,                           \
+    FeedbackVectorsForProfilingTools)                                       \
+  V(FixedArray, serialized_objects, SerializedObjects)                      \
+  V(FixedArray, serialized_global_proxy_sizes, SerializedGlobalProxySizes)  \
+  V(TemplateList, message_listeners, MessageListeners)                      \
+  /* Support for async stack traces */                                      \
+  V(HeapObject, current_microtask, CurrentMicrotask)                        \
+  /* KeepDuringJob set for JS WeakRefs */                                   \
+  V(HeapObject, weak_refs_keep_during_job, WeakRefsKeepDuringJob)           \
+  V(HeapObject, interpreter_entry_trampoline_for_profiling,                 \
+    InterpreterEntryTrampolineForProfiling)                                 \
+  V(Object, pending_optimize_for_test_bytecode,                             \
+    PendingOptimizeForTestBytecode)                                         \
+  V(ArrayList, basic_block_profiling_data, BasicBlockProfilingData)         \
+  V(WeakArrayList, shared_wasm_memories, SharedWasmMemories)                \
+  IF_WASM(V, HeapObject, active_continuation, ActiveContinuation)           \
   IF_WASM(V, HeapObject, active_suspender, ActiveSuspender)
 
 // Entries in this list are limited to Smis and are not visited during GC.

tools/v8heapconst.py

@@ -91,22 +91,22 @@ INSTANCE_TYPES = {
   185: "ORDERED_HASH_MAP_TYPE",
   186: "ORDERED_HASH_SET_TYPE",
   187: "ORDERED_NAME_DICTIONARY_TYPE",
-  188: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  189: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
-  190: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  191: "SCRIPT_CONTEXT_TABLE_TYPE",
-  192: "BYTE_ARRAY_TYPE",
-  193: "BYTECODE_ARRAY_TYPE",
-  194: "FIXED_DOUBLE_ARRAY_TYPE",
-  195: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
-  196: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
-  197: "TURBOFAN_BITSET_TYPE_TYPE",
-  198: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
-  199: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
-  200: "TURBOFAN_RANGE_TYPE_TYPE",
-  201: "TURBOFAN_UNION_TYPE_TYPE",
-  202: "ABSTRACT_INTERNAL_CLASS_SUBCLASS1_TYPE",
-  203: "ABSTRACT_INTERNAL_CLASS_SUBCLASS2_TYPE",
+  188: "REGISTERED_SYMBOL_TABLE_TYPE",
+  189: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  190: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
+  191: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
+  192: "SCRIPT_CONTEXT_TABLE_TYPE",
+  193: "BYTE_ARRAY_TYPE",
+  194: "BYTECODE_ARRAY_TYPE",
+  195: "FIXED_DOUBLE_ARRAY_TYPE",
+  196: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
+  197: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
+  198: "TURBOFAN_BITSET_TYPE_TYPE",
+  199: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
+  200: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
+  201: "TURBOFAN_RANGE_TYPE_TYPE",
+  202: "TURBOFAN_UNION_TYPE_TYPE",
+  203: "CELL_TYPE",
   204: "FOREIGN_TYPE",
   205: "WASM_INTERNAL_FUNCTION_TYPE",
   206: "WASM_TYPE_INFO_TYPE",
@@ -134,46 +134,47 @@ INSTANCE_TYPES = {
   228: "SMALL_ORDERED_HASH_MAP_TYPE",
   229: "SMALL_ORDERED_HASH_SET_TYPE",
   230: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
-  231: "DESCRIPTOR_ARRAY_TYPE",
-  232: "STRONG_DESCRIPTOR_ARRAY_TYPE",
-  233: "SOURCE_TEXT_MODULE_TYPE",
-  234: "SYNTHETIC_MODULE_TYPE",
-  235: "WEAK_FIXED_ARRAY_TYPE",
-  236: "TRANSITION_ARRAY_TYPE",
-  237: "CELL_TYPE",
-  238: "CODE_TYPE",
-  239: "CODE_DATA_CONTAINER_TYPE",
-  240: "COVERAGE_INFO_TYPE",
-  241: "EMBEDDER_DATA_ARRAY_TYPE",
-  242: "FEEDBACK_METADATA_TYPE",
-  243: "FEEDBACK_VECTOR_TYPE",
-  244: "FILLER_TYPE",
-  245: "FREE_SPACE_TYPE",
-  246: "INTERNAL_CLASS_TYPE",
-  247: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
-  248: "MAP_TYPE",
-  249: "MEGA_DOM_HANDLER_TYPE",
-  250: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
-  251: "PREPARSE_DATA_TYPE",
-  252: "PROPERTY_ARRAY_TYPE",
-  253: "PROPERTY_CELL_TYPE",
-  254: "SCOPE_INFO_TYPE",
-  255: "SHARED_FUNCTION_INFO_TYPE",
-  256: "SMI_BOX_TYPE",
-  257: "SMI_PAIR_TYPE",
-  258: "SORT_STATE_TYPE",
-  259: "SWISS_NAME_DICTIONARY_TYPE",
-  260: "WASM_API_FUNCTION_REF_TYPE",
-  261: "WASM_ON_FULFILLED_DATA_TYPE",
-  262: "WEAK_ARRAY_LIST_TYPE",
-  263: "WEAK_CELL_TYPE",
-  264: "WASM_ARRAY_TYPE",
-  265: "WASM_STRUCT_TYPE",
-  266: "JS_PROXY_TYPE",
+  231: "ABSTRACT_INTERNAL_CLASS_SUBCLASS1_TYPE",
+  232: "ABSTRACT_INTERNAL_CLASS_SUBCLASS2_TYPE",
+  233: "DESCRIPTOR_ARRAY_TYPE",
+  234: "STRONG_DESCRIPTOR_ARRAY_TYPE",
+  235: "SOURCE_TEXT_MODULE_TYPE",
+  236: "SYNTHETIC_MODULE_TYPE",
+  237: "WEAK_FIXED_ARRAY_TYPE",
+  238: "TRANSITION_ARRAY_TYPE",
+  239: "CODE_TYPE",
+  240: "CODE_DATA_CONTAINER_TYPE",
+  241: "COVERAGE_INFO_TYPE",
+  242: "EMBEDDER_DATA_ARRAY_TYPE",
+  243: "FEEDBACK_METADATA_TYPE",
+  244: "FEEDBACK_VECTOR_TYPE",
+  245: "FILLER_TYPE",
+  246: "FREE_SPACE_TYPE",
+  247: "INTERNAL_CLASS_TYPE",
+  248: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
+  249: "MAP_TYPE",
+  250: "MEGA_DOM_HANDLER_TYPE",
+  251: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
+  252: "PREPARSE_DATA_TYPE",
+  253: "PROPERTY_ARRAY_TYPE",
+  254: "PROPERTY_CELL_TYPE",
+  255: "SCOPE_INFO_TYPE",
+  256: "SHARED_FUNCTION_INFO_TYPE",
+  257: "SMI_BOX_TYPE",
+  258: "SMI_PAIR_TYPE",
+  259: "SORT_STATE_TYPE",
+  260: "SWISS_NAME_DICTIONARY_TYPE",
+  261: "WASM_API_FUNCTION_REF_TYPE",
+  262: "WASM_ON_FULFILLED_DATA_TYPE",
+  263: "WEAK_ARRAY_LIST_TYPE",
+  264: "WEAK_CELL_TYPE",
+  265: "WASM_ARRAY_TYPE",
+  266: "WASM_STRUCT_TYPE",
+  267: "JS_PROXY_TYPE",
   1057: "JS_OBJECT_TYPE",
-  267: "JS_GLOBAL_OBJECT_TYPE",
-  268: "JS_GLOBAL_PROXY_TYPE",
-  269: "JS_MODULE_NAMESPACE_TYPE",
+  268: "JS_GLOBAL_OBJECT_TYPE",
+  269: "JS_GLOBAL_PROXY_TYPE",
+  270: "JS_MODULE_NAMESPACE_TYPE",
   1040: "JS_SPECIAL_API_OBJECT_TYPE",
   1041: "JS_PRIMITIVE_WRAPPER_TYPE",
   1058: "JS_API_OBJECT_TYPE",
@@ -270,53 +271,53 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-    ("read_only_space", 0x02149): (248, "MetaMap"),
+    ("read_only_space", 0x02149): (249, "MetaMap"),
     ("read_only_space", 0x02171): (131, "NullMap"),
-    ("read_only_space", 0x02199): (232, "StrongDescriptorArrayMap"),
-    ("read_only_space", 0x021c1): (262, "WeakArrayListMap"),
+    ("read_only_space", 0x02199): (234, "StrongDescriptorArrayMap"),
+    ("read_only_space", 0x021c1): (263, "WeakArrayListMap"),
     ("read_only_space", 0x02205): (157, "EnumCacheMap"),
     ("read_only_space", 0x02239): (178, "FixedArrayMap"),
     ("read_only_space", 0x02285): (8, "OneByteInternalizedStringMap"),
-    ("read_only_space", 0x022d1): (245, "FreeSpaceMap"),
-    ("read_only_space", 0x022f9): (244, "OnePointerFillerMap"),
-    ("read_only_space", 0x02321): (244, "TwoPointerFillerMap"),
+    ("read_only_space", 0x022d1): (246, "FreeSpaceMap"),
+    ("read_only_space", 0x022f9): (245, "OnePointerFillerMap"),
+    ("read_only_space", 0x02321): (245, "TwoPointerFillerMap"),
     ("read_only_space", 0x02349): (131, "UninitializedMap"),
     ("read_only_space", 0x023c1): (131, "UndefinedMap"),
     ("read_only_space", 0x02405): (130, "HeapNumberMap"),
     ("read_only_space", 0x02439): (131, "TheHoleMap"),
     ("read_only_space", 0x02499): (131, "BooleanMap"),
-    ("read_only_space", 0x0253d): (192, "ByteArrayMap"),
+    ("read_only_space", 0x0253d): (193, "ByteArrayMap"),
     ("read_only_space", 0x02565): (178, "FixedCOWArrayMap"),
     ("read_only_space", 0x0258d): (179, "HashTableMap"),
     ("read_only_space", 0x025b5): (128, "SymbolMap"),
     ("read_only_space", 0x025dd): (40, "OneByteStringMap"),
-    ("read_only_space", 0x02605): (254, "ScopeInfoMap"),
-    ("read_only_space", 0x0262d): (255, "SharedFunctionInfoMap"),
-    ("read_only_space", 0x02655): (238, "CodeMap"),
-    ("read_only_space", 0x0267d): (237, "CellMap"),
-    ("read_only_space", 0x026a5): (253, "GlobalPropertyCellMap"),
+    ("read_only_space", 0x02605): (255, "ScopeInfoMap"),
+    ("read_only_space", 0x0262d): (256, "SharedFunctionInfoMap"),
+    ("read_only_space", 0x02655): (239, "CodeMap"),
+    ("read_only_space", 0x0267d): (203, "CellMap"),
+    ("read_only_space", 0x026a5): (254, "GlobalPropertyCellMap"),
     ("read_only_space", 0x026cd): (204, "ForeignMap"),
-    ("read_only_space", 0x026f5): (236, "TransitionArrayMap"),
+    ("read_only_space", 0x026f5): (238, "TransitionArrayMap"),
     ("read_only_space", 0x0271d): (45, "ThinOneByteStringMap"),
-    ("read_only_space", 0x02745): (243, "FeedbackVectorMap"),
+    ("read_only_space", 0x02745): (244, "FeedbackVectorMap"),
     ("read_only_space", 0x0277d): (131, "ArgumentsMarkerMap"),
     ("read_only_space", 0x027dd): (131, "ExceptionMap"),
     ("read_only_space", 0x02839): (131, "TerminationExceptionMap"),
     ("read_only_space", 0x028a1): (131, "OptimizedOutMap"),
     ("read_only_space", 0x02901): (131, "StaleRegisterMap"),
-    ("read_only_space", 0x02961): (191, "ScriptContextTableMap"),
-    ("read_only_space", 0x02989): (189, "ClosureFeedbackCellArrayMap"),
-    ("read_only_space", 0x029b1): (242, "FeedbackMetadataArrayMap"),
+    ("read_only_space", 0x02961): (192, "ScriptContextTableMap"),
+    ("read_only_space", 0x02989): (190, "ClosureFeedbackCellArrayMap"),
+    ("read_only_space", 0x029b1): (243, "FeedbackMetadataArrayMap"),
     ("read_only_space", 0x029d9): (178, "ArrayListMap"),
     ("read_only_space", 0x02a01): (129, "BigIntMap"),
-    ("read_only_space", 0x02a29): (190, "ObjectBoilerplateDescriptionMap"),
-    ("read_only_space", 0x02a51): (193, "BytecodeArrayMap"),
-    ("read_only_space", 0x02a79): (239, "CodeDataContainerMap"),
-    ("read_only_space", 0x02aa1): (240, "CoverageInfoMap"),
-    ("read_only_space", 0x02ac9): (194, "FixedDoubleArrayMap"),
+    ("read_only_space", 0x02a29): (191, "ObjectBoilerplateDescriptionMap"),
+    ("read_only_space", 0x02a51): (194, "BytecodeArrayMap"),
+    ("read_only_space", 0x02a79): (240, "CodeDataContainerMap"),
+    ("read_only_space", 0x02aa1): (241, "CoverageInfoMap"),
+    ("read_only_space", 0x02ac9): (195, "FixedDoubleArrayMap"),
     ("read_only_space", 0x02af1): (181, "GlobalDictionaryMap"),
     ("read_only_space", 0x02b19): (159, "ManyClosuresCellMap"),
-    ("read_only_space", 0x02b41): (249, "MegaDomHandlerMap"),
+    ("read_only_space", 0x02b41): (250, "MegaDomHandlerMap"),
     ("read_only_space", 0x02b69): (178, "ModuleInfoMap"),
     ("read_only_space", 0x02b91): (182, "NameDictionaryMap"),
     ("read_only_space", 0x02bb9): (159, "NoClosuresCellMap"),
@@ -325,125 +326,126 @@ KNOWN_MAPS = {
     ("read_only_space", 0x02c31): (185, "OrderedHashMapMap"),
     ("read_only_space", 0x02c59): (186, "OrderedHashSetMap"),
     ("read_only_space", 0x02c81): (183, "NameToIndexHashTableMap"),
-    ("read_only_space", 0x02ca9): (187, "OrderedNameDictionaryMap"),
-    ("read_only_space", 0x02cd1): (251, "PreparseDataMap"),
-    ("read_only_space", 0x02cf9): (252, "PropertyArrayMap"),
-    ("read_only_space", 0x02d21): (153, "SideEffectCallHandlerInfoMap"),
-    ("read_only_space", 0x02d49): (153, "SideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02d71): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02d99): (188, "SimpleNumberDictionaryMap"),
-    ("read_only_space", 0x02dc1): (228, "SmallOrderedHashMapMap"),
-    ("read_only_space", 0x02de9): (229, "SmallOrderedHashSetMap"),
-    ("read_only_space", 0x02e11): (230, "SmallOrderedNameDictionaryMap"),
-    ("read_only_space", 0x02e39): (233, "SourceTextModuleMap"),
-    ("read_only_space", 0x02e61): (259, "SwissNameDictionaryMap"),
-    ("read_only_space", 0x02e89): (234, "SyntheticModuleMap"),
-    ("read_only_space", 0x02eb1): (260, "WasmApiFunctionRefMap"),
-    ("read_only_space", 0x02ed9): (222, "WasmCapiFunctionDataMap"),
-    ("read_only_space", 0x02f01): (223, "WasmExportedFunctionDataMap"),
-    ("read_only_space", 0x02f29): (205, "WasmInternalFunctionMap"),
-    ("read_only_space", 0x02f51): (224, "WasmJSFunctionDataMap"),
-    ("read_only_space", 0x02f79): (261, "WasmOnFulfilledDataMap"),
-    ("read_only_space", 0x02fa1): (206, "WasmTypeInfoMap"),
-    ("read_only_space", 0x02fc9): (235, "WeakFixedArrayMap"),
-    ("read_only_space", 0x02ff1): (180, "EphemeronHashTableMap"),
-    ("read_only_space", 0x03019): (241, "EmbedderDataArrayMap"),
-    ("read_only_space", 0x03041): (263, "WeakCellMap"),
-    ("read_only_space", 0x03069): (32, "StringMap"),
-    ("read_only_space", 0x03091): (41, "ConsOneByteStringMap"),
-    ("read_only_space", 0x030b9): (33, "ConsStringMap"),
-    ("read_only_space", 0x030e1): (37, "ThinStringMap"),
-    ("read_only_space", 0x03109): (35, "SlicedStringMap"),
-    ("read_only_space", 0x03131): (43, "SlicedOneByteStringMap"),
-    ("read_only_space", 0x03159): (34, "ExternalStringMap"),
-    ("read_only_space", 0x03181): (42, "ExternalOneByteStringMap"),
-    ("read_only_space", 0x031a9): (50, "UncachedExternalStringMap"),
-    ("read_only_space", 0x031d1): (0, "InternalizedStringMap"),
-    ("read_only_space", 0x031f9): (2, "ExternalInternalizedStringMap"),
-    ("read_only_space", 0x03221): (10, "ExternalOneByteInternalizedStringMap"),
-    ("read_only_space", 0x03249): (18, "UncachedExternalInternalizedStringMap"),
-    ("read_only_space", 0x03271): (26, "UncachedExternalOneByteInternalizedStringMap"),
-    ("read_only_space", 0x03299): (58, "UncachedExternalOneByteStringMap"),
-    ("read_only_space", 0x032c1): (104, "SharedOneByteStringMap"),
-    ("read_only_space", 0x032e9): (96, "SharedStringMap"),
-    ("read_only_space", 0x03311): (109, "SharedThinOneByteStringMap"),
-    ("read_only_space", 0x03339): (101, "SharedThinStringMap"),
-    ("read_only_space", 0x03361): (96, "TwoByteSeqStringMigrationSentinelMap"),
-    ("read_only_space", 0x03389): (104, "OneByteSeqStringMigrationSentinelMap"),
-    ("read_only_space", 0x033b1): (131, "SelfReferenceMarkerMap"),
-    ("read_only_space", 0x033d9): (131, "BasicBlockCountersMarkerMap"),
-    ("read_only_space", 0x0341d): (147, "ArrayBoilerplateDescriptionMap"),
-    ("read_only_space", 0x0351d): (161, "InterceptorInfoMap"),
-    ("read_only_space", 0x05fdd): (132, "PromiseFulfillReactionJobTaskMap"),
-    ("read_only_space", 0x06005): (133, "PromiseRejectReactionJobTaskMap"),
-    ("read_only_space", 0x0602d): (134, "CallableTaskMap"),
-    ("read_only_space", 0x06055): (135, "CallbackTaskMap"),
-    ("read_only_space", 0x0607d): (136, "PromiseResolveThenableJobTaskMap"),
-    ("read_only_space", 0x060a5): (139, "FunctionTemplateInfoMap"),
-    ("read_only_space", 0x060cd): (140, "ObjectTemplateInfoMap"),
-    ("read_only_space", 0x060f5): (141, "AccessCheckInfoMap"),
-    ("read_only_space", 0x0611d): (142, "AccessorInfoMap"),
-    ("read_only_space", 0x06145): (143, "AccessorPairMap"),
-    ("read_only_space", 0x0616d): (144, "AliasedArgumentsEntryMap"),
-    ("read_only_space", 0x06195): (145, "AllocationMementoMap"),
-    ("read_only_space", 0x061bd): (148, "AsmWasmDataMap"),
-    ("read_only_space", 0x061e5): (149, "AsyncGeneratorRequestMap"),
-    ("read_only_space", 0x0620d): (150, "BreakPointMap"),
-    ("read_only_space", 0x06235): (151, "BreakPointInfoMap"),
-    ("read_only_space", 0x0625d): (152, "CachedTemplateObjectMap"),
-    ("read_only_space", 0x06285): (154, "CallSiteInfoMap"),
-    ("read_only_space", 0x062ad): (155, "ClassPositionsMap"),
-    ("read_only_space", 0x062d5): (156, "DebugInfoMap"),
-    ("read_only_space", 0x062fd): (158, "ErrorStackDataMap"),
-    ("read_only_space", 0x06325): (160, "FunctionTemplateRareDataMap"),
-    ("read_only_space", 0x0634d): (162, "InterpreterDataMap"),
-    ("read_only_space", 0x06375): (163, "ModuleRequestMap"),
-    ("read_only_space", 0x0639d): (164, "PromiseCapabilityMap"),
-    ("read_only_space", 0x063c5): (165, "PromiseReactionMap"),
-    ("read_only_space", 0x063ed): (166, "PropertyDescriptorObjectMap"),
-    ("read_only_space", 0x06415): (167, "PrototypeInfoMap"),
-    ("read_only_space", 0x0643d): (168, "RegExpBoilerplateDescriptionMap"),
-    ("read_only_space", 0x06465): (169, "ScriptMap"),
-    ("read_only_space", 0x0648d): (170, "ScriptOrModuleMap"),
-    ("read_only_space", 0x064b5): (171, "SourceTextModuleInfoEntryMap"),
-    ("read_only_space", 0x064dd): (172, "StackFrameInfoMap"),
-    ("read_only_space", 0x06505): (173, "TemplateObjectDescriptionMap"),
-    ("read_only_space", 0x0652d): (174, "Tuple2Map"),
-    ("read_only_space", 0x06555): (175, "WasmContinuationObjectMap"),
-    ("read_only_space", 0x0657d): (176, "WasmExceptionTagMap"),
-    ("read_only_space", 0x065a5): (177, "WasmIndirectFunctionTableMap"),
-    ("read_only_space", 0x065cd): (196, "SloppyArgumentsElementsMap"),
-    ("read_only_space", 0x065f5): (231, "DescriptorArrayMap"),
-    ("read_only_space", 0x0661d): (219, "UncompiledDataWithoutPreparseDataMap"),
-    ("read_only_space", 0x06645): (217, "UncompiledDataWithPreparseDataMap"),
-    ("read_only_space", 0x0666d): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
-    ("read_only_space", 0x06695): (218, "UncompiledDataWithPreparseDataAndJobMap"),
-    ("read_only_space", 0x066bd): (250, "OnHeapBasicBlockProfilerDataMap"),
-    ("read_only_space", 0x066e5): (197, "TurbofanBitsetTypeMap"),
-    ("read_only_space", 0x0670d): (201, "TurbofanUnionTypeMap"),
-    ("read_only_space", 0x06735): (200, "TurbofanRangeTypeMap"),
-    ("read_only_space", 0x0675d): (198, "TurbofanHeapConstantTypeMap"),
-    ("read_only_space", 0x06785): (199, "TurbofanOtherNumberConstantTypeMap"),
-    ("read_only_space", 0x067ad): (246, "InternalClassMap"),
-    ("read_only_space", 0x067d5): (257, "SmiPairMap"),
-    ("read_only_space", 0x067fd): (256, "SmiBoxMap"),
-    ("read_only_space", 0x06825): (225, "ExportedSubClassBaseMap"),
-    ("read_only_space", 0x0684d): (226, "ExportedSubClassMap"),
-    ("read_only_space", 0x06875): (202, "AbstractInternalClassSubclass1Map"),
-    ("read_only_space", 0x0689d): (203, "AbstractInternalClassSubclass2Map"),
-    ("read_only_space", 0x068c5): (195, "InternalClassWithSmiElementsMap"),
-    ("read_only_space", 0x068ed): (247, "InternalClassWithStructElementsMap"),
-    ("read_only_space", 0x06915): (227, "ExportedSubClass2Map"),
-    ("read_only_space", 0x0693d): (258, "SortStateMap"),
-    ("read_only_space", 0x06965): (146, "AllocationSiteWithWeakNextMap"),
-    ("read_only_space", 0x0698d): (146, "AllocationSiteWithoutWeakNextMap"),
-    ("read_only_space", 0x069b5): (137, "LoadHandler1Map"),
-    ("read_only_space", 0x069dd): (137, "LoadHandler2Map"),
-    ("read_only_space", 0x06a05): (137, "LoadHandler3Map"),
-    ("read_only_space", 0x06a2d): (138, "StoreHandler0Map"),
-    ("read_only_space", 0x06a55): (138, "StoreHandler1Map"),
-    ("read_only_space", 0x06a7d): (138, "StoreHandler2Map"),
-    ("read_only_space", 0x06aa5): (138, "StoreHandler3Map"),
+    ("read_only_space", 0x02ca9): (188, "RegisteredSymbolTableMap"),
+    ("read_only_space", 0x02cd1): (187, "OrderedNameDictionaryMap"),
+    ("read_only_space", 0x02cf9): (252, "PreparseDataMap"),
+    ("read_only_space", 0x02d21): (253, "PropertyArrayMap"),
+    ("read_only_space", 0x02d49): (153, "SideEffectCallHandlerInfoMap"),
+    ("read_only_space", 0x02d71): (153, "SideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02d99): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02dc1): (189, "SimpleNumberDictionaryMap"),
+    ("read_only_space", 0x02de9): (228, "SmallOrderedHashMapMap"),
+    ("read_only_space", 0x02e11): (229, "SmallOrderedHashSetMap"),
+    ("read_only_space", 0x02e39): (230, "SmallOrderedNameDictionaryMap"),
+    ("read_only_space", 0x02e61): (235, "SourceTextModuleMap"),
+    ("read_only_space", 0x02e89): (260, "SwissNameDictionaryMap"),
+    ("read_only_space", 0x02eb1): (236, "SyntheticModuleMap"),
+    ("read_only_space", 0x02ed9): (261, "WasmApiFunctionRefMap"),
+    ("read_only_space", 0x02f01): (222, "WasmCapiFunctionDataMap"),
+    ("read_only_space", 0x02f29): (223, "WasmExportedFunctionDataMap"),
+    ("read_only_space", 0x02f51): (205, "WasmInternalFunctionMap"),
+    ("read_only_space", 0x02f79): (224, "WasmJSFunctionDataMap"),
+    ("read_only_space", 0x02fa1): (262, "WasmOnFulfilledDataMap"),
+    ("read_only_space", 0x02fc9): (206, "WasmTypeInfoMap"),
+    ("read_only_space", 0x02ff1): (237, "WeakFixedArrayMap"),
+    ("read_only_space", 0x03019): (180, "EphemeronHashTableMap"),
+    ("read_only_space", 0x03041): (242, "EmbedderDataArrayMap"),
+    ("read_only_space", 0x03069): (264, "WeakCellMap"),
+    ("read_only_space", 0x03091): (32, "StringMap"),
+    ("read_only_space", 0x030b9): (41, "ConsOneByteStringMap"),
+    ("read_only_space", 0x030e1): (33, "ConsStringMap"),
+    ("read_only_space", 0x03109): (37, "ThinStringMap"),
+    ("read_only_space", 0x03131): (35, "SlicedStringMap"),
+    ("read_only_space", 0x03159): (43, "SlicedOneByteStringMap"),
+    ("read_only_space", 0x03181): (34, "ExternalStringMap"),
+    ("read_only_space", 0x031a9): (42, "ExternalOneByteStringMap"),
+    ("read_only_space", 0x031d1): (50, "UncachedExternalStringMap"),
+    ("read_only_space", 0x031f9): (0, "InternalizedStringMap"),
+    ("read_only_space", 0x03221): (2, "ExternalInternalizedStringMap"),
+    ("read_only_space", 0x03249): (10, "ExternalOneByteInternalizedStringMap"),
+    ("read_only_space", 0x03271): (18, "UncachedExternalInternalizedStringMap"),
+    ("read_only_space", 0x03299): (26, "UncachedExternalOneByteInternalizedStringMap"),
+    ("read_only_space", 0x032c1): (58, "UncachedExternalOneByteStringMap"),
+    ("read_only_space", 0x032e9): (104, "SharedOneByteStringMap"),
+    ("read_only_space", 0x03311): (96, "SharedStringMap"),
+    ("read_only_space", 0x03339): (109, "SharedThinOneByteStringMap"),
+    ("read_only_space", 0x03361): (101, "SharedThinStringMap"),
+    ("read_only_space", 0x03389): (96, "TwoByteSeqStringMigrationSentinelMap"),
+    ("read_only_space", 0x033b1): (104, "OneByteSeqStringMigrationSentinelMap"),
+    ("read_only_space", 0x033d9): (131, "SelfReferenceMarkerMap"),
+    ("read_only_space", 0x03401): (131, "BasicBlockCountersMarkerMap"),
+    ("read_only_space", 0x03445): (147, "ArrayBoilerplateDescriptionMap"),
+    ("read_only_space", 0x03545): (161, "InterceptorInfoMap"),
+    ("read_only_space", 0x06005): (132, "PromiseFulfillReactionJobTaskMap"),
+    ("read_only_space", 0x0602d): (133, "PromiseRejectReactionJobTaskMap"),
+    ("read_only_space", 0x06055): (134, "CallableTaskMap"),
+    ("read_only_space", 0x0607d): (135, "CallbackTaskMap"),
+    ("read_only_space", 0x060a5): (136, "PromiseResolveThenableJobTaskMap"),
+    ("read_only_space", 0x060cd): (139, "FunctionTemplateInfoMap"),
+    ("read_only_space", 0x060f5): (140, "ObjectTemplateInfoMap"),
+    ("read_only_space", 0x0611d): (141, "AccessCheckInfoMap"),
+    ("read_only_space", 0x06145): (142, "AccessorInfoMap"),
+    ("read_only_space", 0x0616d): (143, "AccessorPairMap"),
+    ("read_only_space", 0x06195): (144, "AliasedArgumentsEntryMap"),
+    ("read_only_space", 0x061bd): (145, "AllocationMementoMap"),
+    ("read_only_space", 0x061e5): (148, "AsmWasmDataMap"),
+    ("read_only_space", 0x0620d): (149, "AsyncGeneratorRequestMap"),
+    ("read_only_space", 0x06235): (150, "BreakPointMap"),
+    ("read_only_space", 0x0625d): (151, "BreakPointInfoMap"),
+    ("read_only_space", 0x06285): (152, "CachedTemplateObjectMap"),
+    ("read_only_space", 0x062ad): (154, "CallSiteInfoMap"),
+    ("read_only_space", 0x062d5): (155, "ClassPositionsMap"),
+    ("read_only_space", 0x062fd): (156, "DebugInfoMap"),
+    ("read_only_space", 0x06325): (158, "ErrorStackDataMap"),
+    ("read_only_space", 0x0634d): (160, "FunctionTemplateRareDataMap"),
+    ("read_only_space", 0x06375): (162, "InterpreterDataMap"),
+    ("read_only_space", 0x0639d): (163, "ModuleRequestMap"),
+    ("read_only_space", 0x063c5): (164, "PromiseCapabilityMap"),
+    ("read_only_space", 0x063ed): (165, "PromiseReactionMap"),
+    ("read_only_space", 0x06415): (166, "PropertyDescriptorObjectMap"),
+    ("read_only_space", 0x0643d): (167, "PrototypeInfoMap"),
+    ("read_only_space", 0x06465): (168, "RegExpBoilerplateDescriptionMap"),
+    ("read_only_space", 0x0648d): (169, "ScriptMap"),
+    ("read_only_space", 0x064b5): (170, "ScriptOrModuleMap"),
+    ("read_only_space", 0x064dd): (171, "SourceTextModuleInfoEntryMap"),
+    ("read_only_space", 0x06505): (172, "StackFrameInfoMap"),
+    ("read_only_space", 0x0652d): (173, "TemplateObjectDescriptionMap"),
+    ("read_only_space", 0x06555): (174, "Tuple2Map"),
+    ("read_only_space", 0x0657d): (175, "WasmContinuationObjectMap"),
+    ("read_only_space", 0x065a5): (176, "WasmExceptionTagMap"),
+    ("read_only_space", 0x065cd): (177, "WasmIndirectFunctionTableMap"),
+    ("read_only_space", 0x065f5): (197, "SloppyArgumentsElementsMap"),
+    ("read_only_space", 0x0661d): (233, "DescriptorArrayMap"),
+    ("read_only_space", 0x06645): (219, "UncompiledDataWithoutPreparseDataMap"),
+    ("read_only_space", 0x0666d): (217, "UncompiledDataWithPreparseDataMap"),
+    ("read_only_space", 0x06695): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
+    ("read_only_space", 0x066bd): (218, "UncompiledDataWithPreparseDataAndJobMap"),
+    ("read_only_space", 0x066e5): (251, "OnHeapBasicBlockProfilerDataMap"),
+    ("read_only_space", 0x0670d): (198, "TurbofanBitsetTypeMap"),
+    ("read_only_space", 0x06735): (202, "TurbofanUnionTypeMap"),
+    ("read_only_space", 0x0675d): (201, "TurbofanRangeTypeMap"),
+    ("read_only_space", 0x06785): (199, "TurbofanHeapConstantTypeMap"),
+    ("read_only_space", 0x067ad): (200, "TurbofanOtherNumberConstantTypeMap"),
+    ("read_only_space", 0x067d5): (247, "InternalClassMap"),
+    ("read_only_space", 0x067fd): (258, "SmiPairMap"),
+    ("read_only_space", 0x06825): (257, "SmiBoxMap"),
+    ("read_only_space", 0x0684d): (225, "ExportedSubClassBaseMap"),
+    ("read_only_space", 0x06875): (226, "ExportedSubClassMap"),
+    ("read_only_space", 0x0689d): (231, "AbstractInternalClassSubclass1Map"),
+    ("read_only_space", 0x068c5): (232, "AbstractInternalClassSubclass2Map"),
+    ("read_only_space", 0x068ed): (196, "InternalClassWithSmiElementsMap"),
+    ("read_only_space", 0x06915): (248, "InternalClassWithStructElementsMap"),
+    ("read_only_space", 0x0693d): (227, "ExportedSubClass2Map"),
+    ("read_only_space", 0x06965): (259, "SortStateMap"),
+    ("read_only_space", 0x0698d): (146, "AllocationSiteWithWeakNextMap"),
+    ("read_only_space", 0x069b5): (146, "AllocationSiteWithoutWeakNextMap"),
+    ("read_only_space", 0x069dd): (137, "LoadHandler1Map"),
+    ("read_only_space", 0x06a05): (137, "LoadHandler2Map"),
+    ("read_only_space", 0x06a2d): (137, "LoadHandler3Map"),
+    ("read_only_space", 0x06a55): (138, "StoreHandler0Map"),
+    ("read_only_space", 0x06a7d): (138, "StoreHandler1Map"),
+    ("read_only_space", 0x06aa5): (138, "StoreHandler2Map"),
+    ("read_only_space", 0x06acd): (138, "StoreHandler3Map"),
     ("map_space", 0x02149): (1057, "ExternalMap"),
     ("map_space", 0x02171): (2114, "JSMessageObjectMap"),
 }
@@ -469,31 +471,31 @@ KNOWN_OBJECTS = {
   ("read_only_space", 0x02861): "TerminationException",
   ("read_only_space", 0x028c9): "OptimizedOut",
   ("read_only_space", 0x02929): "StaleRegister",
-  ("read_only_space", 0x03401): "EmptyPropertyArray",
-  ("read_only_space", 0x03409): "EmptyByteArray",
-  ("read_only_space", 0x03411): "EmptyObjectBoilerplateDescription",
-  ("read_only_space", 0x03445): "EmptyArrayBoilerplateDescription",
-  ("read_only_space", 0x03451): "EmptyClosureFeedbackCellArray",
-  ("read_only_space", 0x03459): "EmptySlowElementDictionary",
-  ("read_only_space", 0x0347d): "EmptyOrderedHashMap",
-  ("read_only_space", 0x03491): "EmptyOrderedHashSet",
-  ("read_only_space", 0x034a5): "EmptyFeedbackMetadata",
-  ("read_only_space", 0x034b1): "EmptyPropertyDictionary",
-  ("read_only_space", 0x034d9): "EmptyOrderedPropertyDictionary",
-  ("read_only_space", 0x034f1): "EmptySwissPropertyDictionary",
-  ("read_only_space", 0x03545): "NoOpInterceptorInfo",
-  ("read_only_space", 0x0356d): "EmptyArrayList",
-  ("read_only_space", 0x03579): "EmptyWeakFixedArray",
-  ("read_only_space", 0x03581): "InfinityValue",
-  ("read_only_space", 0x0358d): "MinusZeroValue",
-  ("read_only_space", 0x03599): "MinusInfinityValue",
-  ("read_only_space", 0x035a5): "SelfReferenceMarker",
-  ("read_only_space", 0x035e5): "BasicBlockCountersMarker",
-  ("read_only_space", 0x03629): "OffHeapTrampolineRelocationInfo",
-  ("read_only_space", 0x03635): "GlobalThisBindingScopeInfo",
-  ("read_only_space", 0x03665): "EmptyFunctionScopeInfo",
-  ("read_only_space", 0x03689): "NativeScopeInfo",
-  ("read_only_space", 0x036a1): "HashSeed",
+  ("read_only_space", 0x03429): "EmptyPropertyArray",
+  ("read_only_space", 0x03431): "EmptyByteArray",
+  ("read_only_space", 0x03439): "EmptyObjectBoilerplateDescription",
+  ("read_only_space", 0x0346d): "EmptyArrayBoilerplateDescription",
+  ("read_only_space", 0x03479): "EmptyClosureFeedbackCellArray",
+  ("read_only_space", 0x03481): "EmptySlowElementDictionary",
+  ("read_only_space", 0x034a5): "EmptyOrderedHashMap",
+  ("read_only_space", 0x034b9): "EmptyOrderedHashSet",
+  ("read_only_space", 0x034cd): "EmptyFeedbackMetadata",
+  ("read_only_space", 0x034d9): "EmptyPropertyDictionary",
+  ("read_only_space", 0x03501): "EmptyOrderedPropertyDictionary",
+  ("read_only_space", 0x03519): "EmptySwissPropertyDictionary",
+  ("read_only_space", 0x0356d): "NoOpInterceptorInfo",
+  ("read_only_space", 0x03595): "EmptyArrayList",
+  ("read_only_space", 0x035a1): "EmptyWeakFixedArray",
+  ("read_only_space", 0x035a9): "InfinityValue",
+  ("read_only_space", 0x035b5): "MinusZeroValue",
+  ("read_only_space", 0x035c1): "MinusInfinityValue",
+  ("read_only_space", 0x035cd): "SelfReferenceMarker",
+  ("read_only_space", 0x0360d): "BasicBlockCountersMarker",
+  ("read_only_space", 0x03651): "OffHeapTrampolineRelocationInfo",
+  ("read_only_space", 0x0365d): "GlobalThisBindingScopeInfo",
+  ("read_only_space", 0x0368d): "EmptyFunctionScopeInfo",
+  ("read_only_space", 0x036b1): "NativeScopeInfo",
+  ("read_only_space", 0x036c9): "HashSeed",
   ("old_space", 0x041f5): "ArgumentsIteratorAccessor",
   ("old_space", 0x04239): "ArrayLengthAccessor",
   ("old_space", 0x0427d): "BoundFunctionLengthAccessor",