[runtime] Adds a hashtable object (name => index)

In preparation to use the hash table in the scope_info, we
setup a hashtable from name to indices.

Bug: v8:12315
Change-Id: I77f1eb40191c2fb2d40127e1e84dbc41ca2e4b70
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3386804Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Commit-Queue: Victor Gomes <victorgomes@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78646}

src/builtins/base.tq

@@ -209,6 +209,7 @@ extern class HashTable extends FixedArray generates 'TNode<FixedArray>';
 extern class OrderedHashMap extends HashTable;
 extern class OrderedHashSet extends HashTable;
 extern class OrderedNameDictionary extends HashTable;
+extern class NameToIndexHashTable extends HashTable;
 extern class NameDictionary extends HashTable;
 extern class GlobalDictionary extends HashTable;
 extern class SimpleNumberDictionary extends HashTable;

src/diagnostics/objects-debug.cc

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

src/diagnostics/objects-printer.cc

@@ -138,6 +138,9 @@ void HeapObject::HeapObjectPrint(std::ostream& os) {
     case HASH_TABLE_TYPE:
       ObjectHashTable::cast(*this).ObjectHashTablePrint(os);
       break;
+    case NAME_TO_INDEX_HASH_TABLE_TYPE:
+      NameToIndexHashTable::cast(*this).NameToIndexHashTablePrint(os);
+      break;
     case ORDERED_HASH_MAP_TYPE:
       OrderedHashMap::cast(*this).OrderedHashMapPrint(os);
       break;
@@ -961,6 +964,11 @@ void ObjectHashTable::ObjectHashTablePrint(std::ostream& os) {
   PrintHashMapContentsFull(os, *this);
 }
 
+void NameToIndexHashTable::NameToIndexHashTablePrint(std::ostream& os) {
+  PrintHashTableHeader(os, *this, "NameToIndexHashTable");
+  PrintHashMapContentsFull(os, *this);
+}
+
 void NumberDictionary::NumberDictionaryPrint(std::ostream& os) {
   PrintHashTableHeader(os, *this, "NumberDictionary");
   PrintDictionaryContentsFull(os, *this);

src/heap/setup-heap-internal.cc

@@ -476,6 +476,8 @@ bool Heap::CreateInitialMaps() {
     ALLOCATE_VARSIZE_MAP(NUMBER_DICTIONARY_TYPE, number_dictionary)
     ALLOCATE_VARSIZE_MAP(SIMPLE_NUMBER_DICTIONARY_TYPE,
                          simple_number_dictionary)
+    ALLOCATE_VARSIZE_MAP(NAME_TO_INDEX_HASH_TABLE_TYPE,
+                         name_to_index_hash_table)
 
     ALLOCATE_VARSIZE_MAP(EMBEDDER_DATA_ARRAY_TYPE, embedder_data_array)
     ALLOCATE_VARSIZE_MAP(EPHEMERON_HASH_TABLE_TYPE, ephemeron_hash_table)

src/objects/hash-table-inl.h

@@ -45,9 +45,15 @@ ObjectHashSet::ObjectHashSet(Address ptr)
   SLOW_DCHECK(IsObjectHashSet());
 }
 
+NameToIndexHashTable::NameToIndexHashTable(Address ptr)
+    : HashTable<NameToIndexHashTable, NameToIndexShape>(ptr) {
+  SLOW_DCHECK(IsNameToIndexHashTable());
+}
+
 CAST_ACCESSOR(ObjectHashTable)
 CAST_ACCESSOR(EphemeronHashTable)
 CAST_ACCESSOR(ObjectHashSet)
+CAST_ACCESSOR(NameToIndexHashTable)
 
 void EphemeronHashTable::set_key(int index, Object value) {
   DCHECK_NE(GetReadOnlyRoots().fixed_cow_array_map(), map());
@@ -124,6 +130,11 @@ Handle<Map> HashTable<Derived, Shape>::GetMap(ReadOnlyRoots roots) {
   return roots.hash_table_map_handle();
 }
 
+// static
+Handle<Map> NameToIndexHashTable::GetMap(ReadOnlyRoots roots) {
+  return roots.name_to_index_hash_table_map_handle();
+}
+
 // static
 Handle<Map> EphemeronHashTable::GetMap(ReadOnlyRoots roots) {
   return roots.ephemeron_hash_table_map_handle();
@@ -247,6 +258,18 @@ bool ObjectHashTableShape::IsMatch(Handle<Object> key, Object other) {
   return key->SameValue(other);
 }
 
+bool NameToIndexShape::IsMatch(Handle<Name> key, Object other) {
+  return *key == other;
+}
+
+uint32_t NameToIndexShape::HashForObject(ReadOnlyRoots roots, Object other) {
+  return Name::cast(other).hash();
+}
+
+uint32_t NameToIndexShape::Hash(ReadOnlyRoots roots, Handle<Name> key) {
+  return key->hash();
+}
+
 uint32_t ObjectHashTableShape::Hash(ReadOnlyRoots roots, Handle<Object> key) {
   return Smi::ToInt(key->GetHash());
 }

src/objects/hash-table.h

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

src/objects/map.cc

@@ -129,6 +129,7 @@ VisitorId Map::GetVisitorId(Map map) {
       return kVisitEmbedderDataArray;
 
     case OBJECT_BOILERPLATE_DESCRIPTION_TYPE:
+    case NAME_TO_INDEX_HASH_TABLE_TYPE:
     case CLOSURE_FEEDBACK_CELL_ARRAY_TYPE:
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:

src/objects/object-list-macros.h

@@ -183,6 +183,7 @@ class ZoneForwardList;
   V(Microtask)                                 \
   V(Name)                                      \
   V(NameDictionary)                            \
+  V(NameToIndexHashTable)                      \
   V(NativeContext)                             \
   V(NormalizedMapCache)                        \
   V(NumberDictionary)                          \

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

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

src/objects/objects.cc

@@ -2326,6 +2326,7 @@ bool HeapObject::NeedsRehashing(InstanceType instance_type) const {
     case ORDERED_HASH_SET_TYPE:
       return false;  // We'll rehash from the JSMap or JSSet referencing them.
     case NAME_DICTIONARY_TYPE:
+    case NAME_TO_INDEX_HASH_TABLE_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:
@@ -2354,6 +2355,7 @@ bool HeapObject::CanBeRehashed(PtrComprCageBase cage_base) const {
     case ORDERED_NAME_DICTIONARY_TYPE:
       return false;
     case NAME_DICTIONARY_TYPE:
+    case NAME_TO_INDEX_HASH_TABLE_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:
@@ -2383,6 +2385,9 @@ void HeapObject::RehashBasedOnMap(IsolateT* isolate) {
     case NAME_DICTIONARY_TYPE:
       NameDictionary::cast(*this).Rehash(isolate);
       break;
+    case NAME_TO_INDEX_HASH_TABLE_TYPE:
+      NameToIndexHashTable::cast(*this).Rehash(isolate);
+      break;
     case SWISS_NAME_DICTIONARY_TYPE:
       SwissNameDictionary::cast(*this).Rehash(isolate);
       break;
@@ -6235,6 +6240,33 @@ Object ObjectHashTableBase<Derived, Shape>::Lookup(PtrComprCageBase cage_base,
   return this->get(Derived::EntryToIndex(entry) + 1);
 }
 
+int32_t NameToIndexHashTable::Lookup(Handle<Name> key) {
+  DisallowGarbageCollection no_gc;
+  PtrComprCageBase cage_base = GetPtrComprCageBase(*this);
+  ReadOnlyRoots roots = this->GetReadOnlyRoots(cage_base);
+
+  InternalIndex entry = this->FindEntry(cage_base, roots, key, key->hash());
+  if (entry.is_not_found()) return -1;
+  return Smi::cast(this->get(EntryToValueIndex(entry))).value();
+}
+
+Handle<NameToIndexHashTable> NameToIndexHashTable::Add(
+    Isolate* isolate, Handle<NameToIndexHashTable> table, Handle<Name> key,
+    int32_t index) {
+  DCHECK_GE(index, 0);
+  // Validate that the key is absent.
+  SLOW_DCHECK(table->FindEntry(isolate, key).is_not_found());
+  // Check whether the dictionary should be extended.
+  table = EnsureCapacity(isolate, table);
+
+  // Compute the key object.
+  InternalIndex entry = table->FindInsertionEntry(isolate, key->hash());
+  table->set(EntryToIndex(entry), *key);
+  table->set(EntryToValueIndex(entry), Smi::FromInt(index));
+  table->ElementAdded();
+  return table;
+}
+
 template <typename Derived, typename Shape>
 Object ObjectHashTableBase<Derived, Shape>::Lookup(Handle<Object> key) {
   DisallowGarbageCollection no_gc;
@@ -6262,6 +6294,10 @@ Object ObjectHashTableBase<Derived, Shape>::ValueAt(InternalIndex entry) {
   return this->get(EntryToValueIndex(entry));
 }
 
+Object NameToIndexHashTable::ValueAt(InternalIndex entry) {
+  return this->get(EntryToValueIndex(entry));
+}
+
 template <typename Derived, typename Shape>
 Handle<Derived> ObjectHashTableBase<Derived, Shape>::Put(Handle<Derived> table,
                                                          Handle<Object> key,
@@ -6836,6 +6872,7 @@ Address Smi::LexicographicCompare(Isolate* isolate, Smi x, Smi y) {
 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_OBJECT_BASE_HASH_TABLE(ObjectHashTable, ObjectHashTableShape)
 EXTERN_DEFINE_OBJECT_BASE_HASH_TABLE(EphemeronHashTable, ObjectHashTableShape)

src/roots/roots.h

@@ -96,6 +96,7 @@ class Symbol;
   V(Map, one_closure_cell_map, OneClosureCellMap)                              \
   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, ordered_name_dictionary_map, OrderedNameDictionaryMap)                \
   V(Map, preparse_data_map, PreparseDataMap)                                   \
   V(Map, property_array_map, PropertyArrayMap)                                 \

tools/v8heapconst.py

@@ -84,27 +84,27 @@ INSTANCE_TYPES = {
   180: "EPHEMERON_HASH_TABLE_TYPE",
   181: "GLOBAL_DICTIONARY_TYPE",
   182: "NAME_DICTIONARY_TYPE",
-  183: "NUMBER_DICTIONARY_TYPE",
-  184: "ORDERED_HASH_MAP_TYPE",
-  185: "ORDERED_HASH_SET_TYPE",
-  186: "ORDERED_NAME_DICTIONARY_TYPE",
-  187: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  188: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
-  189: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  190: "SCRIPT_CONTEXT_TABLE_TYPE",
-  191: "BYTE_ARRAY_TYPE",
-  192: "BYTECODE_ARRAY_TYPE",
-  193: "FIXED_DOUBLE_ARRAY_TYPE",
-  194: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
-  195: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
-  196: "TURBOFAN_BITSET_TYPE_TYPE",
-  197: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
-  198: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
-  199: "TURBOFAN_RANGE_TYPE_TYPE",
-  200: "TURBOFAN_UNION_TYPE_TYPE",
-  201: "EXPORTED_SUB_CLASS_BASE_TYPE",
-  202: "EXPORTED_SUB_CLASS_TYPE",
-  203: "EXPORTED_SUB_CLASS2_TYPE",
+  183: "NAME_TO_INDEX_HASH_TABLE_TYPE",
+  184: "NUMBER_DICTIONARY_TYPE",
+  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",
   204: "FOREIGN_TYPE",
   205: "WASM_INTERNAL_FUNCTION_TYPE",
   206: "WASM_TYPE_INFO_TYPE",
@@ -126,50 +126,51 @@ INSTANCE_TYPES = {
   222: "WASM_CAPI_FUNCTION_DATA_TYPE",
   223: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
   224: "WASM_JS_FUNCTION_DATA_TYPE",
-  225: "SMALL_ORDERED_HASH_MAP_TYPE",
-  226: "SMALL_ORDERED_HASH_SET_TYPE",
-  227: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
-  228: "ABSTRACT_INTERNAL_CLASS_SUBCLASS1_TYPE",
-  229: "ABSTRACT_INTERNAL_CLASS_SUBCLASS2_TYPE",
-  230: "DESCRIPTOR_ARRAY_TYPE",
-  231: "STRONG_DESCRIPTOR_ARRAY_TYPE",
-  232: "SOURCE_TEXT_MODULE_TYPE",
-  233: "SYNTHETIC_MODULE_TYPE",
-  234: "WEAK_FIXED_ARRAY_TYPE",
-  235: "TRANSITION_ARRAY_TYPE",
-  236: "CELL_TYPE",
-  237: "CODE_TYPE",
-  238: "CODE_DATA_CONTAINER_TYPE",
-  239: "COVERAGE_INFO_TYPE",
-  240: "EMBEDDER_DATA_ARRAY_TYPE",
-  241: "FEEDBACK_METADATA_TYPE",
-  242: "FEEDBACK_VECTOR_TYPE",
-  243: "FILLER_TYPE",
-  244: "FREE_SPACE_TYPE",
-  245: "INTERNAL_CLASS_TYPE",
-  246: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
-  247: "MAP_TYPE",
-  248: "MEGA_DOM_HANDLER_TYPE",
-  249: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
-  250: "PREPARSE_DATA_TYPE",
-  251: "PROPERTY_ARRAY_TYPE",
-  252: "PROPERTY_CELL_TYPE",
-  253: "SCOPE_INFO_TYPE",
-  254: "SHARED_FUNCTION_INFO_TYPE",
-  255: "SMI_BOX_TYPE",
-  256: "SMI_PAIR_TYPE",
-  257: "SORT_STATE_TYPE",
-  258: "SWISS_NAME_DICTIONARY_TYPE",
-  259: "WASM_API_FUNCTION_REF_TYPE",
-  260: "WEAK_ARRAY_LIST_TYPE",
-  261: "WEAK_CELL_TYPE",
-  262: "WASM_ARRAY_TYPE",
-  263: "WASM_STRUCT_TYPE",
-  264: "JS_PROXY_TYPE",
+  225: "EXPORTED_SUB_CLASS_BASE_TYPE",
+  226: "EXPORTED_SUB_CLASS_TYPE",
+  227: "EXPORTED_SUB_CLASS2_TYPE",
+  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: "WEAK_ARRAY_LIST_TYPE",
+  262: "WEAK_CELL_TYPE",
+  263: "WASM_ARRAY_TYPE",
+  264: "WASM_STRUCT_TYPE",
+  265: "JS_PROXY_TYPE",
   1057: "JS_OBJECT_TYPE",
-  265: "JS_GLOBAL_OBJECT_TYPE",
-  266: "JS_GLOBAL_PROXY_TYPE",
-  267: "JS_MODULE_NAMESPACE_TYPE",
+  266: "JS_GLOBAL_OBJECT_TYPE",
+  267: "JS_GLOBAL_PROXY_TYPE",
+  268: "JS_MODULE_NAMESPACE_TYPE",
   1040: "JS_SPECIAL_API_OBJECT_TYPE",
   1041: "JS_PRIMITIVE_WRAPPER_TYPE",
   1058: "JS_API_OBJECT_TYPE",
@@ -264,178 +265,179 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-  ("read_only_space", 0x02131): (247, "MetaMap"),
+  ("read_only_space", 0x02131): (248, "MetaMap"),
   ("read_only_space", 0x02159): (131, "NullMap"),
-  ("read_only_space", 0x02181): (231, "StrongDescriptorArrayMap"),
-  ("read_only_space", 0x021a9): (260, "WeakArrayListMap"),
+  ("read_only_space", 0x02181): (232, "StrongDescriptorArrayMap"),
+  ("read_only_space", 0x021a9): (261, "WeakArrayListMap"),
   ("read_only_space", 0x021ed): (157, "EnumCacheMap"),
   ("read_only_space", 0x02221): (178, "FixedArrayMap"),
   ("read_only_space", 0x0226d): (8, "OneByteInternalizedStringMap"),
-  ("read_only_space", 0x022b9): (244, "FreeSpaceMap"),
-  ("read_only_space", 0x022e1): (243, "OnePointerFillerMap"),
-  ("read_only_space", 0x02309): (243, "TwoPointerFillerMap"),
+  ("read_only_space", 0x022b9): (245, "FreeSpaceMap"),
+  ("read_only_space", 0x022e1): (244, "OnePointerFillerMap"),
+  ("read_only_space", 0x02309): (244, "TwoPointerFillerMap"),
   ("read_only_space", 0x02331): (131, "UninitializedMap"),
   ("read_only_space", 0x023a9): (131, "UndefinedMap"),
   ("read_only_space", 0x023ed): (130, "HeapNumberMap"),
   ("read_only_space", 0x02421): (131, "TheHoleMap"),
   ("read_only_space", 0x02481): (131, "BooleanMap"),
-  ("read_only_space", 0x02525): (191, "ByteArrayMap"),
+  ("read_only_space", 0x02525): (192, "ByteArrayMap"),
   ("read_only_space", 0x0254d): (178, "FixedCOWArrayMap"),
   ("read_only_space", 0x02575): (179, "HashTableMap"),
   ("read_only_space", 0x0259d): (128, "SymbolMap"),
   ("read_only_space", 0x025c5): (40, "OneByteStringMap"),
-  ("read_only_space", 0x025ed): (253, "ScopeInfoMap"),
-  ("read_only_space", 0x02615): (254, "SharedFunctionInfoMap"),
-  ("read_only_space", 0x0263d): (237, "CodeMap"),
-  ("read_only_space", 0x02665): (236, "CellMap"),
-  ("read_only_space", 0x0268d): (252, "GlobalPropertyCellMap"),
+  ("read_only_space", 0x025ed): (254, "ScopeInfoMap"),
+  ("read_only_space", 0x02615): (255, "SharedFunctionInfoMap"),
+  ("read_only_space", 0x0263d): (238, "CodeMap"),
+  ("read_only_space", 0x02665): (237, "CellMap"),
+  ("read_only_space", 0x0268d): (253, "GlobalPropertyCellMap"),
   ("read_only_space", 0x026b5): (204, "ForeignMap"),
-  ("read_only_space", 0x026dd): (235, "TransitionArrayMap"),
+  ("read_only_space", 0x026dd): (236, "TransitionArrayMap"),
   ("read_only_space", 0x02705): (45, "ThinOneByteStringMap"),
-  ("read_only_space", 0x0272d): (242, "FeedbackVectorMap"),
+  ("read_only_space", 0x0272d): (243, "FeedbackVectorMap"),
   ("read_only_space", 0x02765): (131, "ArgumentsMarkerMap"),
   ("read_only_space", 0x027c5): (131, "ExceptionMap"),
   ("read_only_space", 0x02821): (131, "TerminationExceptionMap"),
   ("read_only_space", 0x02889): (131, "OptimizedOutMap"),
   ("read_only_space", 0x028e9): (131, "StaleRegisterMap"),
-  ("read_only_space", 0x02949): (190, "ScriptContextTableMap"),
-  ("read_only_space", 0x02971): (188, "ClosureFeedbackCellArrayMap"),
-  ("read_only_space", 0x02999): (241, "FeedbackMetadataArrayMap"),
+  ("read_only_space", 0x02949): (191, "ScriptContextTableMap"),
+  ("read_only_space", 0x02971): (189, "ClosureFeedbackCellArrayMap"),
+  ("read_only_space", 0x02999): (242, "FeedbackMetadataArrayMap"),
   ("read_only_space", 0x029c1): (178, "ArrayListMap"),
   ("read_only_space", 0x029e9): (129, "BigIntMap"),
-  ("read_only_space", 0x02a11): (189, "ObjectBoilerplateDescriptionMap"),
-  ("read_only_space", 0x02a39): (192, "BytecodeArrayMap"),
-  ("read_only_space", 0x02a61): (238, "CodeDataContainerMap"),
-  ("read_only_space", 0x02a89): (239, "CoverageInfoMap"),
-  ("read_only_space", 0x02ab1): (193, "FixedDoubleArrayMap"),
+  ("read_only_space", 0x02a11): (190, "ObjectBoilerplateDescriptionMap"),
+  ("read_only_space", 0x02a39): (193, "BytecodeArrayMap"),
+  ("read_only_space", 0x02a61): (239, "CodeDataContainerMap"),
+  ("read_only_space", 0x02a89): (240, "CoverageInfoMap"),
+  ("read_only_space", 0x02ab1): (194, "FixedDoubleArrayMap"),
   ("read_only_space", 0x02ad9): (181, "GlobalDictionaryMap"),
   ("read_only_space", 0x02b01): (159, "ManyClosuresCellMap"),
-  ("read_only_space", 0x02b29): (248, "MegaDomHandlerMap"),
+  ("read_only_space", 0x02b29): (249, "MegaDomHandlerMap"),
   ("read_only_space", 0x02b51): (178, "ModuleInfoMap"),
   ("read_only_space", 0x02b79): (182, "NameDictionaryMap"),
   ("read_only_space", 0x02ba1): (159, "NoClosuresCellMap"),
-  ("read_only_space", 0x02bc9): (183, "NumberDictionaryMap"),
+  ("read_only_space", 0x02bc9): (184, "NumberDictionaryMap"),
   ("read_only_space", 0x02bf1): (159, "OneClosureCellMap"),
-  ("read_only_space", 0x02c19): (184, "OrderedHashMapMap"),
-  ("read_only_space", 0x02c41): (185, "OrderedHashSetMap"),
-  ("read_only_space", 0x02c69): (186, "OrderedNameDictionaryMap"),
-  ("read_only_space", 0x02c91): (250, "PreparseDataMap"),
-  ("read_only_space", 0x02cb9): (251, "PropertyArrayMap"),
-  ("read_only_space", 0x02ce1): (153, "SideEffectCallHandlerInfoMap"),
-  ("read_only_space", 0x02d09): (153, "SideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x02d31): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x02d59): (187, "SimpleNumberDictionaryMap"),
-  ("read_only_space", 0x02d81): (225, "SmallOrderedHashMapMap"),
-  ("read_only_space", 0x02da9): (226, "SmallOrderedHashSetMap"),
-  ("read_only_space", 0x02dd1): (227, "SmallOrderedNameDictionaryMap"),
-  ("read_only_space", 0x02df9): (232, "SourceTextModuleMap"),
-  ("read_only_space", 0x02e21): (258, "SwissNameDictionaryMap"),
-  ("read_only_space", 0x02e49): (233, "SyntheticModuleMap"),
-  ("read_only_space", 0x02e71): (259, "WasmApiFunctionRefMap"),
-  ("read_only_space", 0x02e99): (222, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x02ec1): (223, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x02ee9): (205, "WasmInternalFunctionMap"),
-  ("read_only_space", 0x02f11): (224, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x02f39): (206, "WasmTypeInfoMap"),
-  ("read_only_space", 0x02f61): (234, "WeakFixedArrayMap"),
-  ("read_only_space", 0x02f89): (180, "EphemeronHashTableMap"),
-  ("read_only_space", 0x02fb1): (240, "EmbedderDataArrayMap"),
-  ("read_only_space", 0x02fd9): (261, "WeakCellMap"),
-  ("read_only_space", 0x03001): (32, "StringMap"),
-  ("read_only_space", 0x03029): (41, "ConsOneByteStringMap"),
-  ("read_only_space", 0x03051): (33, "ConsStringMap"),
-  ("read_only_space", 0x03079): (37, "ThinStringMap"),
-  ("read_only_space", 0x030a1): (35, "SlicedStringMap"),
-  ("read_only_space", 0x030c9): (43, "SlicedOneByteStringMap"),
-  ("read_only_space", 0x030f1): (34, "ExternalStringMap"),
-  ("read_only_space", 0x03119): (42, "ExternalOneByteStringMap"),
-  ("read_only_space", 0x03141): (50, "UncachedExternalStringMap"),
-  ("read_only_space", 0x03169): (0, "InternalizedStringMap"),
-  ("read_only_space", 0x03191): (2, "ExternalInternalizedStringMap"),
-  ("read_only_space", 0x031b9): (10, "ExternalOneByteInternalizedStringMap"),
-  ("read_only_space", 0x031e1): (18, "UncachedExternalInternalizedStringMap"),
-  ("read_only_space", 0x03209): (26, "UncachedExternalOneByteInternalizedStringMap"),
-  ("read_only_space", 0x03231): (58, "UncachedExternalOneByteStringMap"),
-  ("read_only_space", 0x03259): (104, "SharedOneByteStringMap"),
-  ("read_only_space", 0x03281): (96, "SharedStringMap"),
-  ("read_only_space", 0x032a9): (109, "SharedThinOneByteStringMap"),
-  ("read_only_space", 0x032d1): (101, "SharedThinStringMap"),
-  ("read_only_space", 0x032f9): (96, "TwoByteSeqStringMigrationSentinelMap"),
-  ("read_only_space", 0x03321): (104, "OneByteSeqStringMigrationSentinelMap"),
-  ("read_only_space", 0x03349): (131, "SelfReferenceMarkerMap"),
-  ("read_only_space", 0x03371): (131, "BasicBlockCountersMarkerMap"),
-  ("read_only_space", 0x033b5): (147, "ArrayBoilerplateDescriptionMap"),
-  ("read_only_space", 0x034b5): (161, "InterceptorInfoMap"),
-  ("read_only_space", 0x05dbd): (132, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x05de5): (133, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x05e0d): (134, "CallableTaskMap"),
-  ("read_only_space", 0x05e35): (135, "CallbackTaskMap"),
-  ("read_only_space", 0x05e5d): (136, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x05e85): (139, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x05ead): (140, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x05ed5): (141, "AccessCheckInfoMap"),
-  ("read_only_space", 0x05efd): (142, "AccessorInfoMap"),
-  ("read_only_space", 0x05f25): (143, "AccessorPairMap"),
-  ("read_only_space", 0x05f4d): (144, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x05f75): (145, "AllocationMementoMap"),
-  ("read_only_space", 0x05f9d): (148, "AsmWasmDataMap"),
-  ("read_only_space", 0x05fc5): (149, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x05fed): (150, "BreakPointMap"),
-  ("read_only_space", 0x06015): (151, "BreakPointInfoMap"),
-  ("read_only_space", 0x0603d): (152, "CachedTemplateObjectMap"),
-  ("read_only_space", 0x06065): (154, "CallSiteInfoMap"),
-  ("read_only_space", 0x0608d): (155, "ClassPositionsMap"),
-  ("read_only_space", 0x060b5): (156, "DebugInfoMap"),
-  ("read_only_space", 0x060dd): (158, "ErrorStackDataMap"),
-  ("read_only_space", 0x06105): (160, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x0612d): (162, "InterpreterDataMap"),
-  ("read_only_space", 0x06155): (163, "ModuleRequestMap"),
-  ("read_only_space", 0x0617d): (164, "PromiseCapabilityMap"),
-  ("read_only_space", 0x061a5): (165, "PromiseReactionMap"),
-  ("read_only_space", 0x061cd): (166, "PropertyDescriptorObjectMap"),
-  ("read_only_space", 0x061f5): (167, "PrototypeInfoMap"),
-  ("read_only_space", 0x0621d): (168, "RegExpBoilerplateDescriptionMap"),
-  ("read_only_space", 0x06245): (169, "ScriptMap"),
-  ("read_only_space", 0x0626d): (170, "ScriptOrModuleMap"),
-  ("read_only_space", 0x06295): (171, "SourceTextModuleInfoEntryMap"),
-  ("read_only_space", 0x062bd): (172, "StackFrameInfoMap"),
-  ("read_only_space", 0x062e5): (173, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x0630d): (174, "Tuple2Map"),
-  ("read_only_space", 0x06335): (175, "WasmContinuationObjectMap"),
-  ("read_only_space", 0x0635d): (176, "WasmExceptionTagMap"),
-  ("read_only_space", 0x06385): (177, "WasmIndirectFunctionTableMap"),
-  ("read_only_space", 0x063ad): (195, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x063d5): (230, "DescriptorArrayMap"),
-  ("read_only_space", 0x063fd): (219, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x06425): (217, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x0644d): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
-  ("read_only_space", 0x06475): (218, "UncompiledDataWithPreparseDataAndJobMap"),
-  ("read_only_space", 0x0649d): (249, "OnHeapBasicBlockProfilerDataMap"),
-  ("read_only_space", 0x064c5): (196, "TurbofanBitsetTypeMap"),
-  ("read_only_space", 0x064ed): (200, "TurbofanUnionTypeMap"),
-  ("read_only_space", 0x06515): (199, "TurbofanRangeTypeMap"),
-  ("read_only_space", 0x0653d): (197, "TurbofanHeapConstantTypeMap"),
-  ("read_only_space", 0x06565): (198, "TurbofanOtherNumberConstantTypeMap"),
-  ("read_only_space", 0x0658d): (245, "InternalClassMap"),
-  ("read_only_space", 0x065b5): (256, "SmiPairMap"),
-  ("read_only_space", 0x065dd): (255, "SmiBoxMap"),
-  ("read_only_space", 0x06605): (201, "ExportedSubClassBaseMap"),
-  ("read_only_space", 0x0662d): (202, "ExportedSubClassMap"),
-  ("read_only_space", 0x06655): (228, "AbstractInternalClassSubclass1Map"),
-  ("read_only_space", 0x0667d): (229, "AbstractInternalClassSubclass2Map"),
-  ("read_only_space", 0x066a5): (194, "InternalClassWithSmiElementsMap"),
-  ("read_only_space", 0x066cd): (246, "InternalClassWithStructElementsMap"),
-  ("read_only_space", 0x066f5): (203, "ExportedSubClass2Map"),
-  ("read_only_space", 0x0671d): (257, "SortStateMap"),
-  ("read_only_space", 0x06745): (146, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x0676d): (146, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x06795): (137, "LoadHandler1Map"),
-  ("read_only_space", 0x067bd): (137, "LoadHandler2Map"),
-  ("read_only_space", 0x067e5): (137, "LoadHandler3Map"),
-  ("read_only_space", 0x0680d): (138, "StoreHandler0Map"),
-  ("read_only_space", 0x06835): (138, "StoreHandler1Map"),
-  ("read_only_space", 0x0685d): (138, "StoreHandler2Map"),
-  ("read_only_space", 0x06885): (138, "StoreHandler3Map"),
+  ("read_only_space", 0x02c19): (185, "OrderedHashMapMap"),
+  ("read_only_space", 0x02c41): (186, "OrderedHashSetMap"),
+  ("read_only_space", 0x02c69): (183, "NameToIndexHashTableMap"),
+  ("read_only_space", 0x02c91): (187, "OrderedNameDictionaryMap"),
+  ("read_only_space", 0x02cb9): (251, "PreparseDataMap"),
+  ("read_only_space", 0x02ce1): (252, "PropertyArrayMap"),
+  ("read_only_space", 0x02d09): (153, "SideEffectCallHandlerInfoMap"),
+  ("read_only_space", 0x02d31): (153, "SideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x02d59): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
+  ("read_only_space", 0x02d81): (188, "SimpleNumberDictionaryMap"),
+  ("read_only_space", 0x02da9): (228, "SmallOrderedHashMapMap"),
+  ("read_only_space", 0x02dd1): (229, "SmallOrderedHashSetMap"),
+  ("read_only_space", 0x02df9): (230, "SmallOrderedNameDictionaryMap"),
+  ("read_only_space", 0x02e21): (233, "SourceTextModuleMap"),
+  ("read_only_space", 0x02e49): (259, "SwissNameDictionaryMap"),
+  ("read_only_space", 0x02e71): (234, "SyntheticModuleMap"),
+  ("read_only_space", 0x02e99): (260, "WasmApiFunctionRefMap"),
+  ("read_only_space", 0x02ec1): (222, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x02ee9): (223, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x02f11): (205, "WasmInternalFunctionMap"),
+  ("read_only_space", 0x02f39): (224, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x02f61): (206, "WasmTypeInfoMap"),
+  ("read_only_space", 0x02f89): (235, "WeakFixedArrayMap"),
+  ("read_only_space", 0x02fb1): (180, "EphemeronHashTableMap"),
+  ("read_only_space", 0x02fd9): (241, "EmbedderDataArrayMap"),
+  ("read_only_space", 0x03001): (262, "WeakCellMap"),
+  ("read_only_space", 0x03029): (32, "StringMap"),
+  ("read_only_space", 0x03051): (41, "ConsOneByteStringMap"),
+  ("read_only_space", 0x03079): (33, "ConsStringMap"),
+  ("read_only_space", 0x030a1): (37, "ThinStringMap"),
+  ("read_only_space", 0x030c9): (35, "SlicedStringMap"),
+  ("read_only_space", 0x030f1): (43, "SlicedOneByteStringMap"),
+  ("read_only_space", 0x03119): (34, "ExternalStringMap"),
+  ("read_only_space", 0x03141): (42, "ExternalOneByteStringMap"),
+  ("read_only_space", 0x03169): (50, "UncachedExternalStringMap"),
+  ("read_only_space", 0x03191): (0, "InternalizedStringMap"),
+  ("read_only_space", 0x031b9): (2, "ExternalInternalizedStringMap"),
+  ("read_only_space", 0x031e1): (10, "ExternalOneByteInternalizedStringMap"),
+  ("read_only_space", 0x03209): (18, "UncachedExternalInternalizedStringMap"),
+  ("read_only_space", 0x03231): (26, "UncachedExternalOneByteInternalizedStringMap"),
+  ("read_only_space", 0x03259): (58, "UncachedExternalOneByteStringMap"),
+  ("read_only_space", 0x03281): (104, "SharedOneByteStringMap"),
+  ("read_only_space", 0x032a9): (96, "SharedStringMap"),
+  ("read_only_space", 0x032d1): (109, "SharedThinOneByteStringMap"),
+  ("read_only_space", 0x032f9): (101, "SharedThinStringMap"),
+  ("read_only_space", 0x03321): (96, "TwoByteSeqStringMigrationSentinelMap"),
+  ("read_only_space", 0x03349): (104, "OneByteSeqStringMigrationSentinelMap"),
+  ("read_only_space", 0x03371): (131, "SelfReferenceMarkerMap"),
+  ("read_only_space", 0x03399): (131, "BasicBlockCountersMarkerMap"),
+  ("read_only_space", 0x033dd): (147, "ArrayBoilerplateDescriptionMap"),
+  ("read_only_space", 0x034dd): (161, "InterceptorInfoMap"),
+  ("read_only_space", 0x05de5): (132, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x05e0d): (133, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x05e35): (134, "CallableTaskMap"),
+  ("read_only_space", 0x05e5d): (135, "CallbackTaskMap"),
+  ("read_only_space", 0x05e85): (136, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x05ead): (139, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x05ed5): (140, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x05efd): (141, "AccessCheckInfoMap"),
+  ("read_only_space", 0x05f25): (142, "AccessorInfoMap"),
+  ("read_only_space", 0x05f4d): (143, "AccessorPairMap"),
+  ("read_only_space", 0x05f75): (144, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x05f9d): (145, "AllocationMementoMap"),
+  ("read_only_space", 0x05fc5): (148, "AsmWasmDataMap"),
+  ("read_only_space", 0x05fed): (149, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x06015): (150, "BreakPointMap"),
+  ("read_only_space", 0x0603d): (151, "BreakPointInfoMap"),
+  ("read_only_space", 0x06065): (152, "CachedTemplateObjectMap"),
+  ("read_only_space", 0x0608d): (154, "CallSiteInfoMap"),
+  ("read_only_space", 0x060b5): (155, "ClassPositionsMap"),
+  ("read_only_space", 0x060dd): (156, "DebugInfoMap"),
+  ("read_only_space", 0x06105): (158, "ErrorStackDataMap"),
+  ("read_only_space", 0x0612d): (160, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x06155): (162, "InterpreterDataMap"),
+  ("read_only_space", 0x0617d): (163, "ModuleRequestMap"),
+  ("read_only_space", 0x061a5): (164, "PromiseCapabilityMap"),
+  ("read_only_space", 0x061cd): (165, "PromiseReactionMap"),
+  ("read_only_space", 0x061f5): (166, "PropertyDescriptorObjectMap"),
+  ("read_only_space", 0x0621d): (167, "PrototypeInfoMap"),
+  ("read_only_space", 0x06245): (168, "RegExpBoilerplateDescriptionMap"),
+  ("read_only_space", 0x0626d): (169, "ScriptMap"),
+  ("read_only_space", 0x06295): (170, "ScriptOrModuleMap"),
+  ("read_only_space", 0x062bd): (171, "SourceTextModuleInfoEntryMap"),
+  ("read_only_space", 0x062e5): (172, "StackFrameInfoMap"),
+  ("read_only_space", 0x0630d): (173, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x06335): (174, "Tuple2Map"),
+  ("read_only_space", 0x0635d): (175, "WasmContinuationObjectMap"),
+  ("read_only_space", 0x06385): (176, "WasmExceptionTagMap"),
+  ("read_only_space", 0x063ad): (177, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x063d5): (196, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x063fd): (231, "DescriptorArrayMap"),
+  ("read_only_space", 0x06425): (219, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x0644d): (217, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x06475): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
+  ("read_only_space", 0x0649d): (218, "UncompiledDataWithPreparseDataAndJobMap"),
+  ("read_only_space", 0x064c5): (250, "OnHeapBasicBlockProfilerDataMap"),
+  ("read_only_space", 0x064ed): (197, "TurbofanBitsetTypeMap"),
+  ("read_only_space", 0x06515): (201, "TurbofanUnionTypeMap"),
+  ("read_only_space", 0x0653d): (200, "TurbofanRangeTypeMap"),
+  ("read_only_space", 0x06565): (198, "TurbofanHeapConstantTypeMap"),
+  ("read_only_space", 0x0658d): (199, "TurbofanOtherNumberConstantTypeMap"),
+  ("read_only_space", 0x065b5): (246, "InternalClassMap"),
+  ("read_only_space", 0x065dd): (257, "SmiPairMap"),
+  ("read_only_space", 0x06605): (256, "SmiBoxMap"),
+  ("read_only_space", 0x0662d): (225, "ExportedSubClassBaseMap"),
+  ("read_only_space", 0x06655): (226, "ExportedSubClassMap"),
+  ("read_only_space", 0x0667d): (202, "AbstractInternalClassSubclass1Map"),
+  ("read_only_space", 0x066a5): (203, "AbstractInternalClassSubclass2Map"),
+  ("read_only_space", 0x066cd): (195, "InternalClassWithSmiElementsMap"),
+  ("read_only_space", 0x066f5): (247, "InternalClassWithStructElementsMap"),
+  ("read_only_space", 0x0671d): (227, "ExportedSubClass2Map"),
+  ("read_only_space", 0x06745): (258, "SortStateMap"),
+  ("read_only_space", 0x0676d): (146, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x06795): (146, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x067bd): (137, "LoadHandler1Map"),
+  ("read_only_space", 0x067e5): (137, "LoadHandler2Map"),
+  ("read_only_space", 0x0680d): (137, "LoadHandler3Map"),
+  ("read_only_space", 0x06835): (138, "StoreHandler0Map"),
+  ("read_only_space", 0x0685d): (138, "StoreHandler1Map"),
+  ("read_only_space", 0x06885): (138, "StoreHandler2Map"),
+  ("read_only_space", 0x068ad): (138, "StoreHandler3Map"),
   ("map_space", 0x02131): (1057, "ExternalMap"),
   ("map_space", 0x02159): (2114, "JSMessageObjectMap"),
 }
@@ -461,32 +463,32 @@ KNOWN_OBJECTS = {
   ("read_only_space", 0x02849): "TerminationException",
   ("read_only_space", 0x028b1): "OptimizedOut",
   ("read_only_space", 0x02911): "StaleRegister",
-  ("read_only_space", 0x03399): "EmptyPropertyArray",
-  ("read_only_space", 0x033a1): "EmptyByteArray",
-  ("read_only_space", 0x033a9): "EmptyObjectBoilerplateDescription",
-  ("read_only_space", 0x033dd): "EmptyArrayBoilerplateDescription",
-  ("read_only_space", 0x033e9): "EmptyClosureFeedbackCellArray",
-  ("read_only_space", 0x033f1): "EmptySlowElementDictionary",
-  ("read_only_space", 0x03415): "EmptyOrderedHashMap",
-  ("read_only_space", 0x03429): "EmptyOrderedHashSet",
-  ("read_only_space", 0x0343d): "EmptyFeedbackMetadata",
-  ("read_only_space", 0x03449): "EmptyPropertyDictionary",
-  ("read_only_space", 0x03471): "EmptyOrderedPropertyDictionary",
-  ("read_only_space", 0x03489): "EmptySwissPropertyDictionary",
-  ("read_only_space", 0x034dd): "NoOpInterceptorInfo",
-  ("read_only_space", 0x03505): "EmptyWeakFixedArray",
-  ("read_only_space", 0x0350d): "InfinityValue",
-  ("read_only_space", 0x03519): "MinusZeroValue",
-  ("read_only_space", 0x03525): "MinusInfinityValue",
-  ("read_only_space", 0x03531): "SelfReferenceMarker",
-  ("read_only_space", 0x03571): "BasicBlockCountersMarker",
-  ("read_only_space", 0x035b5): "OffHeapTrampolineRelocationInfo",
-  ("read_only_space", 0x035c1): "TrampolineTrivialCodeDataContainer",
-  ("read_only_space", 0x035cd): "TrampolinePromiseRejectionCodeDataContainer",
-  ("read_only_space", 0x035d9): "GlobalThisBindingScopeInfo",
-  ("read_only_space", 0x03609): "EmptyFunctionScopeInfo",
-  ("read_only_space", 0x0362d): "NativeScopeInfo",
-  ("read_only_space", 0x03645): "HashSeed",
+  ("read_only_space", 0x033c1): "EmptyPropertyArray",
+  ("read_only_space", 0x033c9): "EmptyByteArray",
+  ("read_only_space", 0x033d1): "EmptyObjectBoilerplateDescription",
+  ("read_only_space", 0x03405): "EmptyArrayBoilerplateDescription",
+  ("read_only_space", 0x03411): "EmptyClosureFeedbackCellArray",
+  ("read_only_space", 0x03419): "EmptySlowElementDictionary",
+  ("read_only_space", 0x0343d): "EmptyOrderedHashMap",
+  ("read_only_space", 0x03451): "EmptyOrderedHashSet",
+  ("read_only_space", 0x03465): "EmptyFeedbackMetadata",
+  ("read_only_space", 0x03471): "EmptyPropertyDictionary",
+  ("read_only_space", 0x03499): "EmptyOrderedPropertyDictionary",
+  ("read_only_space", 0x034b1): "EmptySwissPropertyDictionary",
+  ("read_only_space", 0x03505): "NoOpInterceptorInfo",
+  ("read_only_space", 0x0352d): "EmptyWeakFixedArray",
+  ("read_only_space", 0x03535): "InfinityValue",
+  ("read_only_space", 0x03541): "MinusZeroValue",
+  ("read_only_space", 0x0354d): "MinusInfinityValue",
+  ("read_only_space", 0x03559): "SelfReferenceMarker",
+  ("read_only_space", 0x03599): "BasicBlockCountersMarker",
+  ("read_only_space", 0x035dd): "OffHeapTrampolineRelocationInfo",
+  ("read_only_space", 0x035e9): "TrampolineTrivialCodeDataContainer",
+  ("read_only_space", 0x035f5): "TrampolinePromiseRejectionCodeDataContainer",
+  ("read_only_space", 0x03601): "GlobalThisBindingScopeInfo",
+  ("read_only_space", 0x03631): "EmptyFunctionScopeInfo",
+  ("read_only_space", 0x03655): "NativeScopeInfo",
+  ("read_only_space", 0x0366d): "HashSeed",
   ("old_space", 0x04229): "ArgumentsIteratorAccessor",
   ("old_space", 0x0426d): "ArrayLengthAccessor",
   ("old_space", 0x042b1): "BoundFunctionLengthAccessor",