[dict] Specialize SmallOrderedHashTable for Name dictionary

Bug: v8:6443, v8:7569
Change-Id: Iee039eddd07a7bbc38c8e9f7deca00d5183e702a
Reviewed-on: https://chromium-review.googlesource.com/c/1329697Reviewed-by: Camillo Bruni <cbruni@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57438}

src/compiler/types.cc

@@ -344,6 +344,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) {
     case STACK_FRAME_INFO_TYPE:
     case SMALL_ORDERED_HASH_MAP_TYPE:
     case SMALL_ORDERED_HASH_SET_TYPE:
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
     case PROTOTYPE_INFO_TYPE:
     case INTERPRETER_DATA_TYPE:
     case TUPLE2_TYPE:

src/heap/factory.cc

@@ -517,34 +517,36 @@ Handle<FrameArray> Factory::NewFrameArray(int number_of_frames,
   return Handle<FrameArray>::cast(result);
 }
 
-Handle<SmallOrderedHashSet> Factory::NewSmallOrderedHashSet(
-    int capacity, PretenureFlag pretenure) {
+template <typename T>
+Handle<T> Factory::AllocateSmallOrderedHashTable(Handle<Map> map, int capacity,
+                                                 PretenureFlag pretenure) {
   DCHECK_LE(0, capacity);
-  CHECK_LE(capacity, SmallOrderedHashSet::kMaxCapacity);
-  DCHECK_EQ(0, capacity % SmallOrderedHashSet::kLoadFactor);
+  CHECK_LE(capacity, T::kMaxCapacity);
+  DCHECK_EQ(0, capacity % T::kLoadFactor);
 
-  int size = SmallOrderedHashSet::SizeFor(capacity);
-  Map* map = *small_ordered_hash_set_map();
-  HeapObject* result = AllocateRawWithImmortalMap(size, pretenure, map);
-  Handle<SmallOrderedHashSet> table(SmallOrderedHashSet::cast(result),
-                                    isolate());
+  int size = T::SizeFor(capacity);
+  HeapObject* result = AllocateRawWithImmortalMap(size, pretenure, *map);
+  Handle<T> table(T::cast(result), isolate());
   table->Initialize(isolate(), capacity);
   return table;
 }
 
+Handle<SmallOrderedHashSet> Factory::NewSmallOrderedHashSet(
+    int capacity, PretenureFlag pretenure) {
+  return AllocateSmallOrderedHashTable<SmallOrderedHashSet>(
+      small_ordered_hash_set_map(), capacity, pretenure);
+}
+
 Handle<SmallOrderedHashMap> Factory::NewSmallOrderedHashMap(
     int capacity, PretenureFlag pretenure) {
-  DCHECK_LE(0, capacity);
-  CHECK_LE(capacity, SmallOrderedHashMap::kMaxCapacity);
-  DCHECK_EQ(0, capacity % SmallOrderedHashMap::kLoadFactor);
+  return AllocateSmallOrderedHashTable<SmallOrderedHashMap>(
+      small_ordered_hash_map_map(), capacity, pretenure);
+}
 
-  int size = SmallOrderedHashMap::SizeFor(capacity);
-  Map* map = *small_ordered_hash_map_map();
-  HeapObject* result = AllocateRawWithImmortalMap(size, pretenure, map);
-  Handle<SmallOrderedHashMap> table(SmallOrderedHashMap::cast(result),
-                                    isolate());
-  table->Initialize(isolate(), capacity);
-  return table;
+Handle<SmallOrderedNameDictionary> Factory::NewSmallOrderedNameDictionary(
+    int capacity, PretenureFlag pretenure) {
+  return AllocateSmallOrderedHashTable<SmallOrderedNameDictionary>(
+      small_ordered_name_dictionary_map(), capacity, pretenure);
 }
 
 Handle<OrderedHashSet> Factory::NewOrderedHashSet() {

src/heap/factory.h

@@ -185,6 +185,9 @@ class V8_EXPORT_PRIVATE Factory {
   Handle<SmallOrderedHashMap> NewSmallOrderedHashMap(
       int capacity = SmallOrderedHashMap::kMinCapacity,
       PretenureFlag pretenure = NOT_TENURED);
+  Handle<SmallOrderedNameDictionary> NewSmallOrderedNameDictionary(
+      int capacity = SmallOrderedHashMap::kMinCapacity,
+      PretenureFlag pretenure = NOT_TENURED);
 
   // Create a new PrototypeInfo struct.
   Handle<PrototypeInfo> NewPrototypeInfo();
@@ -942,6 +945,10 @@ class V8_EXPORT_PRIVATE Factory {
                                              int length, Object* filler,
                                              PretenureFlag pretenure);
 
+  template <typename T>
+  Handle<T> AllocateSmallOrderedHashTable(Handle<Map> map, int capacity,
+                                          PretenureFlag pretenure);
+
   // Creates a heap object based on the map. The fields of the heap object are
   // not initialized, it's the responsibility of the caller to do that.
   HeapObject* New(Handle<Map> map, PretenureFlag pretenure);

src/heap/objects-visiting.h

@@ -64,6 +64,7 @@ class WasmInstanceObject;
   V(SlicedString, SlicedString*)                                               \
   V(SmallOrderedHashMap, SmallOrderedHashMap*)                                 \
   V(SmallOrderedHashSet, SmallOrderedHashSet*)                                 \
+  V(SmallOrderedNameDictionary, SmallOrderedNameDictionary*)                   \
   V(Symbol, Symbol*)                                                           \
   V(ThinString, ThinString*)                                                   \
   V(TransitionArray, TransitionArray*)                                         \

src/heap/setup-heap-internal.cc

@@ -413,6 +413,8 @@ bool Heap::CreateInitialMaps() {
     ALLOCATE_VARSIZE_MAP(PROPERTY_ARRAY_TYPE, property_array)
     ALLOCATE_VARSIZE_MAP(SMALL_ORDERED_HASH_MAP_TYPE, small_ordered_hash_map)
     ALLOCATE_VARSIZE_MAP(SMALL_ORDERED_HASH_SET_TYPE, small_ordered_hash_set)
+    ALLOCATE_VARSIZE_MAP(SMALL_ORDERED_NAME_DICTIONARY_TYPE,
+                         small_ordered_name_dictionary)
 
 #define ALLOCATE_FIXED_TYPED_ARRAY_MAP(Type, type, TYPE, ctype) \
   ALLOCATE_VARSIZE_MAP(FIXED_##TYPE##_ARRAY_TYPE, fixed_##type##_array)

src/objects-body-descriptors-inl.h

@@ -889,6 +889,10 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
       return Op::template apply<
           SmallOrderedHashTable<SmallOrderedHashMap>::BodyDescriptor>(p1, p2,
                                                                       p3, p4);
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
+      return Op::template apply<
+          SmallOrderedHashTable<SmallOrderedNameDictionary>::BodyDescriptor>(
+          p1, p2, p3, p4);
     case CODE_DATA_CONTAINER_TYPE:
       return Op::template apply<CodeDataContainer::BodyDescriptor>(p1, p2, p3,
                                                                    p4);

src/objects-debug.cc

@@ -379,6 +379,10 @@ void HeapObject::HeapObjectVerify(Isolate* isolate) {
     case SMALL_ORDERED_HASH_MAP_TYPE:
       SmallOrderedHashMap::cast(this)->SmallOrderedHashTableVerify(isolate);
       break;
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
+      SmallOrderedNameDictionary::cast(this)->SmallOrderedHashTableVerify(
+          isolate);
+      break;
     case CODE_DATA_CONTAINER_TYPE:
       CodeDataContainer::cast(this)->CodeDataContainerVerify(isolate);
       break;
@@ -1484,6 +1488,8 @@ template void SmallOrderedHashTable<
     SmallOrderedHashMap>::SmallOrderedHashTableVerify(Isolate* isolate);
 template void SmallOrderedHashTable<
     SmallOrderedHashSet>::SmallOrderedHashTableVerify(Isolate* isolate);
+template void SmallOrderedHashTable<
+    SmallOrderedNameDictionary>::SmallOrderedHashTableVerify(Isolate* isolate);
 
 void JSRegExp::JSRegExpVerify(Isolate* isolate) {
   JSObjectVerify(isolate);

src/objects-definitions.h

@@ -168,6 +168,7 @@ namespace internal {
   V(SHARED_FUNCTION_INFO_TYPE)                                     \
   V(SMALL_ORDERED_HASH_MAP_TYPE)                                   \
   V(SMALL_ORDERED_HASH_SET_TYPE)                                   \
+  V(SMALL_ORDERED_NAME_DICTIONARY_TYPE)                            \
   V(STORE_HANDLER_TYPE)                                            \
   V(UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE)                 \
   V(UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE)                    \

src/objects-inl.h

@@ -401,7 +401,8 @@ bool HeapObject::IsMapCache() const { return IsHashTable(); }
 bool HeapObject::IsObjectHashTable() const { return IsHashTable(); }
 
 bool Object::IsSmallOrderedHashTable() const {
-  return IsSmallOrderedHashSet() || IsSmallOrderedHashMap();
+  return IsSmallOrderedHashSet() || IsSmallOrderedHashMap() ||
+         IsSmallOrderedNameDictionary();
 }
 
 bool Object::IsPrimitive() const {
@@ -499,6 +500,7 @@ CAST_ACCESSOR(ScopeInfo)
 CAST_ACCESSOR(SimpleNumberDictionary)
 CAST_ACCESSOR(SmallOrderedHashMap)
 CAST_ACCESSOR(SmallOrderedHashSet)
+CAST_ACCESSOR(SmallOrderedNameDictionary)
 CAST_ACCESSOR(StringSet)
 CAST_ACCESSOR(StringTable)
 CAST_ACCESSOR(Struct)
@@ -1080,6 +1082,7 @@ bool HeapObject::NeedsRehashing() const {
     case HASH_TABLE_TYPE:
     case SMALL_ORDERED_HASH_MAP_TYPE:
     case SMALL_ORDERED_HASH_SET_TYPE:
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
       return true;
     default:
       return false;
@@ -1549,14 +1552,18 @@ int HeapObject::SizeFromMap(Map* map) const {
     return SmallOrderedHashSet::SizeFor(
         reinterpret_cast<const SmallOrderedHashSet*>(this)->Capacity());
   }
-  if (instance_type == PROPERTY_ARRAY_TYPE) {
-    return PropertyArray::SizeFor(
-        PropertyArray::cast(this)->synchronized_length());
-  }
   if (instance_type == SMALL_ORDERED_HASH_MAP_TYPE) {
     return SmallOrderedHashMap::SizeFor(
         reinterpret_cast<const SmallOrderedHashMap*>(this)->Capacity());
   }
+  if (instance_type == SMALL_ORDERED_NAME_DICTIONARY_TYPE) {
+    return SmallOrderedNameDictionary::SizeFor(
+        reinterpret_cast<const SmallOrderedNameDictionary*>(this)->Capacity());
+  }
+  if (instance_type == PROPERTY_ARRAY_TYPE) {
+    return PropertyArray::SizeFor(
+        PropertyArray::cast(this)->synchronized_length());
+  }
   if (instance_type == FEEDBACK_VECTOR_TYPE) {
     return FeedbackVector::SizeFor(
         reinterpret_cast<const FeedbackVector*>(this)->length());

src/objects-printer.cc

@@ -430,6 +430,7 @@ void HeapObject::HeapObjectPrint(std::ostream& os) {  // NOLINT
     case UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
     case SMALL_ORDERED_HASH_MAP_TYPE:
     case SMALL_ORDERED_HASH_SET_TYPE:
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
     case JS_ASYNC_FROM_SYNC_ITERATOR_TYPE:
     case JS_STRING_ITERATOR_TYPE:
       // TODO(all): Handle these types too.

src/objects.cc

@@ -3197,6 +3197,9 @@ VisitorId Map::GetVisitorId(Map* map) {
     case SMALL_ORDERED_HASH_SET_TYPE:
       return kVisitSmallOrderedHashSet;
 
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
+      return kVisitSmallOrderedNameDictionary;
+
     case CODE_DATA_CONTAINER_TYPE:
       return kVisitCodeDataContainer;
 
@@ -3848,6 +3851,8 @@ bool HeapObject::CanBeRehashed() const {
       return SmallOrderedHashMap::cast(this)->NumberOfElements() == 0;
     case SMALL_ORDERED_HASH_SET_TYPE:
       return SmallOrderedHashMap::cast(this)->NumberOfElements() == 0;
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
+      return SmallOrderedNameDictionary::cast(this)->NumberOfElements() == 0;
     default:
       return false;
   }
@@ -3887,6 +3892,9 @@ void HeapObject::RehashBasedOnMap(Isolate* isolate) {
     case SMALL_ORDERED_HASH_SET_TYPE:
       DCHECK_EQ(0, SmallOrderedHashSet::cast(this)->NumberOfElements());
       break;
+    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
+      DCHECK_EQ(0, SmallOrderedNameDictionary::cast(this)->NumberOfElements());
+      break;
     default:
       break;
   }

src/objects.h

@@ -464,6 +464,7 @@ enum InstanceType : uint16_t {
   SHARED_FUNCTION_INFO_TYPE,
   SMALL_ORDERED_HASH_MAP_TYPE,
   SMALL_ORDERED_HASH_SET_TYPE,
+  SMALL_ORDERED_NAME_DICTIONARY_TYPE,
   STORE_HANDLER_TYPE,
   UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE,
   UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE,
@@ -835,6 +836,7 @@ class ZoneForwardList;
   V(SloppyArgumentsElements)                   \
   V(SmallOrderedHashMap)                       \
   V(SmallOrderedHashSet)                       \
+  V(SmallOrderedNameDictionary)                \
   V(SourcePositionTableWithFrameCache)         \
   V(StoreHandler)                              \
   V(String)                                    \
@@ -977,6 +979,7 @@ class ZoneForwardList;
   V(SimpleNumberDictionary, SIMPLE_NUMBER_DICTIONARY_TYPE)               \
   V(SmallOrderedHashMap, SMALL_ORDERED_HASH_MAP_TYPE)                    \
   V(SmallOrderedHashSet, SMALL_ORDERED_HASH_SET_TYPE)                    \
+  V(SmallOrderedNameDictionary, SMALL_ORDERED_NAME_DICTIONARY_TYPE)      \
   V(SourcePositionTableWithFrameCache, TUPLE2_TYPE)                      \
   V(StoreHandler, STORE_HANDLER_TYPE)                                    \
   V(StringTable, STRING_TABLE_TYPE)                                      \

src/objects/map.h

@@ -57,6 +57,7 @@ namespace internal {
   V(SlicedString)                        \
   V(SmallOrderedHashMap)                 \
   V(SmallOrderedHashSet)                 \
+  V(SmallOrderedNameDictionary)          \
   V(Struct)                              \
   V(Symbol)                              \
   V(ThinString)                          \

src/objects/ordered-hash-table-inl.h

@@ -25,6 +25,10 @@ RootIndex OrderedNameDictionary::GetMapRootIndex() {
   return RootIndex::kOrderedNameDictionaryMap;
 }
 
+RootIndex SmallOrderedNameDictionary::GetMapRootIndex() {
+  return RootIndex::kSmallOrderedNameDictionaryMap;
+}
+
 RootIndex SmallOrderedHashMap::GetMapRootIndex() {
   return RootIndex::kSmallOrderedHashMapMap;
 }

src/objects/ordered-hash-table.cc

@@ -438,6 +438,13 @@ SmallOrderedHashTable<SmallOrderedHashMap>::Allocate(Isolate* isolate,
   return isolate->factory()->NewSmallOrderedHashMap(capacity, pretenure);
 }
 
+template <>
+Handle<SmallOrderedNameDictionary>
+SmallOrderedHashTable<SmallOrderedNameDictionary>::Allocate(
+    Isolate* isolate, int capacity, PretenureFlag pretenure) {
+  return isolate->factory()->NewSmallOrderedNameDictionary(capacity, pretenure);
+}
+
 template <class Derived>
 void SmallOrderedHashTable<Derived>::Initialize(Isolate* isolate,
                                                 int capacity) {
@@ -548,6 +555,47 @@ MaybeHandle<SmallOrderedHashMap> SmallOrderedHashMap::Add(
   return table;
 }
 
+MaybeHandle<SmallOrderedNameDictionary> SmallOrderedNameDictionary::Add(
+    Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
+    Handle<Name> key, Handle<Object> value, PropertyDetails details) {
+  DCHECK(!table->HasKey(isolate, key));
+
+  if (table->UsedCapacity() >= table->Capacity()) {
+    MaybeHandle<SmallOrderedNameDictionary> new_table =
+        SmallOrderedNameDictionary::Grow(isolate, table);
+    if (!new_table.ToHandle(&table)) {
+      return MaybeHandle<SmallOrderedNameDictionary>();
+    }
+  }
+
+  int hash = key->GetOrCreateHash(isolate)->value();
+  int nof = table->NumberOfElements();
+
+  // Read the existing bucket values.
+  int bucket = table->HashToBucket(hash);
+  int previous_entry = table->HashToFirstEntry(hash);
+
+  // Insert a new entry at the end,
+  int new_entry = nof + table->NumberOfDeletedElements();
+
+  table->SetDataEntry(new_entry, SmallOrderedNameDictionary::kValueIndex,
+                      *value);
+  table->SetDataEntry(new_entry, SmallOrderedNameDictionary::kKeyIndex, *key);
+
+  // TODO(gsathya): PropertyDetails should be stored as part of the
+  // data table to save more memory.
+  table->SetDataEntry(new_entry,
+                      SmallOrderedNameDictionary::kPropertyDetailsIndex,
+                      details.AsSmi());
+  table->SetFirstEntry(bucket, new_entry);
+  table->SetNextEntry(new_entry, previous_entry);
+
+  // and update book keeping.
+  table->SetNumberOfElements(nof + 1);
+
+  return table;
+}
+
 template <class Derived>
 bool SmallOrderedHashTable<Derived>::HasKey(Isolate* isolate,
                                             Handle<Object> key) {
@@ -668,6 +716,11 @@ template bool SmallOrderedHashTable<SmallOrderedHashMap>::Delete(
 template bool SmallOrderedHashTable<SmallOrderedHashSet>::Delete(
     Isolate* isolate, SmallOrderedHashSet* table, Object* key);
 
+template void SmallOrderedHashTable<SmallOrderedNameDictionary>::Initialize(
+    Isolate* isolate, int capacity);
+template bool SmallOrderedHashTable<SmallOrderedNameDictionary>::HasKey(
+    Isolate* isolate, Handle<Object> key);
+
 template <class SmallTable, class LargeTable>
 Handle<HeapObject> OrderedHashTableHandler<SmallTable, LargeTable>::Allocate(
     Isolate* isolate, int capacity) {

src/objects/ordered-hash-table.h

@@ -620,6 +620,27 @@ class OrderedNameDictionary
   static const int kPropertyDetailsOffset = 2;
 };
 
+class SmallOrderedNameDictionary
+    : public SmallOrderedHashTable<SmallOrderedNameDictionary> {
+ public:
+  DECL_CAST(SmallOrderedNameDictionary)
+
+  DECL_PRINTER(SmallOrderedNameDictionary)
+
+  static const int kKeyIndex = 0;
+  static const int kValueIndex = 1;
+  static const int kPropertyDetailsIndex = 2;
+  static const int kEntrySize = 3;
+
+  // Adds |value| to |table|, if the capacity isn't enough, a new
+  // table is created. The original |table| is returned if there is
+  // capacity to store |value| otherwise the new table is returned.
+  static MaybeHandle<SmallOrderedNameDictionary> Add(
+      Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
+      Handle<Name> key, Handle<Object> value, PropertyDetails details);
+  static inline RootIndex GetMapRootIndex();
+};
+
 class JSCollectionIterator : public JSObject {
  public:
   // [table]: the backing hash table mapping keys to values.

src/roots.h

@@ -111,6 +111,7 @@ class RootVisitor;
   V(Map*, sloppy_arguments_elements_map, SloppyArgumentsElementsMap)           \
   V(Map*, small_ordered_hash_map_map, SmallOrderedHashMapMap)                  \
   V(Map*, small_ordered_hash_set_map, SmallOrderedHashSetMap)                  \
+  V(Map*, small_ordered_name_dictionary_map, SmallOrderedNameDictionaryMap)    \
   V(Map*, string_table_map, StringTableMap)                                    \
   V(Map*, uncompiled_data_without_pre_parsed_scope_map,                        \
     UncompiledDataWithoutPreParsedScopeMap)                                    \

test/cctest/test-orderedhashtable.cc

@@ -1468,6 +1468,40 @@ TEST(OrderedNameDictionaryDetailsAtAndDetailsAtPut) {
   CHECK_EQ(other.AsSmi(), found.AsSmi());
 }
 
+TEST(SmallOrderedNameDictionaryInsertion) {
+  LocalContext context;
+  Isolate* isolate = GetIsolateFrom(&context);
+  Factory* factory = isolate->factory();
+  HandleScope scope(isolate);
+
+  Handle<SmallOrderedNameDictionary> dict =
+      factory->NewSmallOrderedNameDictionary();
+  Verify(isolate, dict);
+  CHECK_EQ(2, dict->NumberOfBuckets());
+  CHECK_EQ(0, dict->NumberOfElements());
+
+  Handle<String> key1 = isolate->factory()->InternalizeUtf8String("foo");
+  Handle<String> value = isolate->factory()->InternalizeUtf8String("foo");
+  CHECK(!dict->HasKey(isolate, key1));
+  PropertyDetails details = PropertyDetails::Empty();
+  dict = SmallOrderedNameDictionary::Add(isolate, dict, key1, value, details)
+             .ToHandleChecked();
+  Verify(isolate, dict);
+  CHECK_EQ(2, dict->NumberOfBuckets());
+  CHECK_EQ(1, dict->NumberOfElements());
+  CHECK(dict->HasKey(isolate, key1));
+
+  Handle<Symbol> key2 = factory->NewSymbol();
+  CHECK(!dict->HasKey(isolate, key2));
+  dict = SmallOrderedNameDictionary::Add(isolate, dict, key2, value, details)
+             .ToHandleChecked();
+  Verify(isolate, dict);
+  CHECK_EQ(2, dict->NumberOfBuckets());
+  CHECK_EQ(2, dict->NumberOfElements());
+  CHECK(dict->HasKey(isolate, key1));
+  CHECK(dict->HasKey(isolate, key2));
+}
+
 }  // namespace test_orderedhashtable
 }  // namespace internal
 }  // namespace v8

tools/v8heapconst.py

@@ -124,10 +124,11 @@ INSTANCE_TYPES = {
   220: "SHARED_FUNCTION_INFO_TYPE",
   221: "SMALL_ORDERED_HASH_MAP_TYPE",
   222: "SMALL_ORDERED_HASH_SET_TYPE",
-  223: "STORE_HANDLER_TYPE",
-  224: "UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE",
-  225: "UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE",
-  226: "WEAK_ARRAY_LIST_TYPE",
+  223: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
+  224: "STORE_HANDLER_TYPE",
+  225: "UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE",
+  226: "UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE",
+  227: "WEAK_ARRAY_LIST_TYPE",
   1024: "JS_PROXY_TYPE",
   1025: "JS_GLOBAL_OBJECT_TYPE",
   1026: "JS_GLOBAL_PROXY_TYPE",
@@ -259,83 +260,84 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x01a01): (184, "SloppyArgumentsElementsMap"),
   ("RO_SPACE", 0x01a51): (221, "SmallOrderedHashMapMap"),
   ("RO_SPACE", 0x01aa1): (222, "SmallOrderedHashSetMap"),
-  ("RO_SPACE", 0x01af1): (194, "StringTableMap"),
-  ("RO_SPACE", 0x01b41): (224, "UncompiledDataWithoutPreParsedScopeMap"),
-  ("RO_SPACE", 0x01b91): (225, "UncompiledDataWithPreParsedScopeMap"),
-  ("RO_SPACE", 0x01be1): (226, "WeakArrayListMap"),
-  ("RO_SPACE", 0x01c31): (195, "EphemeronHashTableMap"),
-  ("RO_SPACE", 0x01c81): (106, "NativeSourceStringMap"),
-  ("RO_SPACE", 0x01cd1): (64, "StringMap"),
-  ("RO_SPACE", 0x01d21): (73, "ConsOneByteStringMap"),
-  ("RO_SPACE", 0x01d71): (65, "ConsStringMap"),
-  ("RO_SPACE", 0x01dc1): (77, "ThinOneByteStringMap"),
-  ("RO_SPACE", 0x01e11): (69, "ThinStringMap"),
-  ("RO_SPACE", 0x01e61): (67, "SlicedStringMap"),
-  ("RO_SPACE", 0x01eb1): (75, "SlicedOneByteStringMap"),
-  ("RO_SPACE", 0x01f01): (66, "ExternalStringMap"),
-  ("RO_SPACE", 0x01f51): (82, "ExternalStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x01fa1): (74, "ExternalOneByteStringMap"),
-  ("RO_SPACE", 0x01ff1): (98, "UncachedExternalStringMap"),
-  ("RO_SPACE", 0x02041): (114, "UncachedExternalStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x02091): (0, "InternalizedStringMap"),
-  ("RO_SPACE", 0x020e1): (2, "ExternalInternalizedStringMap"),
-  ("RO_SPACE", 0x02131): (18, "ExternalInternalizedStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x02181): (10, "ExternalOneByteInternalizedStringMap"),
-  ("RO_SPACE", 0x021d1): (34, "UncachedExternalInternalizedStringMap"),
-  ("RO_SPACE", 0x02221): (50, "UncachedExternalInternalizedStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x02271): (42, "UncachedExternalOneByteInternalizedStringMap"),
-  ("RO_SPACE", 0x022c1): (106, "UncachedExternalOneByteStringMap"),
-  ("RO_SPACE", 0x02311): (140, "FixedUint8ArrayMap"),
-  ("RO_SPACE", 0x02361): (139, "FixedInt8ArrayMap"),
-  ("RO_SPACE", 0x023b1): (142, "FixedUint16ArrayMap"),
-  ("RO_SPACE", 0x02401): (141, "FixedInt16ArrayMap"),
-  ("RO_SPACE", 0x02451): (144, "FixedUint32ArrayMap"),
-  ("RO_SPACE", 0x024a1): (143, "FixedInt32ArrayMap"),
-  ("RO_SPACE", 0x024f1): (145, "FixedFloat32ArrayMap"),
-  ("RO_SPACE", 0x02541): (146, "FixedFloat64ArrayMap"),
-  ("RO_SPACE", 0x02591): (147, "FixedUint8ClampedArrayMap"),
-  ("RO_SPACE", 0x025e1): (149, "FixedBigUint64ArrayMap"),
-  ("RO_SPACE", 0x02631): (148, "FixedBigInt64ArrayMap"),
-  ("RO_SPACE", 0x02681): (131, "SelfReferenceMarkerMap"),
-  ("RO_SPACE", 0x026e9): (171, "Tuple2Map"),
-  ("RO_SPACE", 0x02789): (173, "ArrayBoilerplateDescriptionMap"),
-  ("RO_SPACE", 0x02ac9): (161, "InterceptorInfoMap"),
-  ("RO_SPACE", 0x04f51): (153, "AccessCheckInfoMap"),
-  ("RO_SPACE", 0x04fa1): (154, "AccessorInfoMap"),
-  ("RO_SPACE", 0x04ff1): (155, "AccessorPairMap"),
-  ("RO_SPACE", 0x05041): (156, "AliasedArgumentsEntryMap"),
-  ("RO_SPACE", 0x05091): (157, "AllocationMementoMap"),
-  ("RO_SPACE", 0x050e1): (158, "AsyncGeneratorRequestMap"),
-  ("RO_SPACE", 0x05131): (159, "DebugInfoMap"),
-  ("RO_SPACE", 0x05181): (160, "FunctionTemplateInfoMap"),
-  ("RO_SPACE", 0x051d1): (162, "InterpreterDataMap"),
-  ("RO_SPACE", 0x05221): (163, "ModuleInfoEntryMap"),
-  ("RO_SPACE", 0x05271): (164, "ModuleMap"),
-  ("RO_SPACE", 0x052c1): (165, "ObjectTemplateInfoMap"),
-  ("RO_SPACE", 0x05311): (166, "PromiseCapabilityMap"),
-  ("RO_SPACE", 0x05361): (167, "PromiseReactionMap"),
-  ("RO_SPACE", 0x053b1): (168, "PrototypeInfoMap"),
-  ("RO_SPACE", 0x05401): (169, "ScriptMap"),
-  ("RO_SPACE", 0x05451): (170, "StackFrameInfoMap"),
-  ("RO_SPACE", 0x054a1): (172, "Tuple3Map"),
-  ("RO_SPACE", 0x054f1): (174, "WasmDebugInfoMap"),
-  ("RO_SPACE", 0x05541): (175, "WasmExportedFunctionDataMap"),
-  ("RO_SPACE", 0x05591): (176, "CallableTaskMap"),
-  ("RO_SPACE", 0x055e1): (177, "CallbackTaskMap"),
-  ("RO_SPACE", 0x05631): (178, "PromiseFulfillReactionJobTaskMap"),
-  ("RO_SPACE", 0x05681): (179, "PromiseRejectReactionJobTaskMap"),
-  ("RO_SPACE", 0x056d1): (180, "PromiseResolveThenableJobTaskMap"),
-  ("RO_SPACE", 0x05721): (181, "WeakFactoryCleanupJobTaskMap"),
-  ("RO_SPACE", 0x05771): (182, "MicrotaskQueueMap"),
-  ("RO_SPACE", 0x057c1): (183, "AllocationSiteWithWeakNextMap"),
-  ("RO_SPACE", 0x05811): (183, "AllocationSiteWithoutWeakNextMap"),
-  ("RO_SPACE", 0x05861): (216, "LoadHandler1Map"),
-  ("RO_SPACE", 0x058b1): (216, "LoadHandler2Map"),
-  ("RO_SPACE", 0x05901): (216, "LoadHandler3Map"),
-  ("RO_SPACE", 0x05951): (223, "StoreHandler0Map"),
-  ("RO_SPACE", 0x059a1): (223, "StoreHandler1Map"),
-  ("RO_SPACE", 0x059f1): (223, "StoreHandler2Map"),
-  ("RO_SPACE", 0x05a41): (223, "StoreHandler3Map"),
+  ("RO_SPACE", 0x01af1): (223, "SmallOrderedNameDictionaryMap"),
+  ("RO_SPACE", 0x01b41): (194, "StringTableMap"),
+  ("RO_SPACE", 0x01b91): (225, "UncompiledDataWithoutPreParsedScopeMap"),
+  ("RO_SPACE", 0x01be1): (226, "UncompiledDataWithPreParsedScopeMap"),
+  ("RO_SPACE", 0x01c31): (227, "WeakArrayListMap"),
+  ("RO_SPACE", 0x01c81): (195, "EphemeronHashTableMap"),
+  ("RO_SPACE", 0x01cd1): (106, "NativeSourceStringMap"),
+  ("RO_SPACE", 0x01d21): (64, "StringMap"),
+  ("RO_SPACE", 0x01d71): (73, "ConsOneByteStringMap"),
+  ("RO_SPACE", 0x01dc1): (65, "ConsStringMap"),
+  ("RO_SPACE", 0x01e11): (77, "ThinOneByteStringMap"),
+  ("RO_SPACE", 0x01e61): (69, "ThinStringMap"),
+  ("RO_SPACE", 0x01eb1): (67, "SlicedStringMap"),
+  ("RO_SPACE", 0x01f01): (75, "SlicedOneByteStringMap"),
+  ("RO_SPACE", 0x01f51): (66, "ExternalStringMap"),
+  ("RO_SPACE", 0x01fa1): (82, "ExternalStringWithOneByteDataMap"),
+  ("RO_SPACE", 0x01ff1): (74, "ExternalOneByteStringMap"),
+  ("RO_SPACE", 0x02041): (98, "UncachedExternalStringMap"),
+  ("RO_SPACE", 0x02091): (114, "UncachedExternalStringWithOneByteDataMap"),
+  ("RO_SPACE", 0x020e1): (0, "InternalizedStringMap"),
+  ("RO_SPACE", 0x02131): (2, "ExternalInternalizedStringMap"),
+  ("RO_SPACE", 0x02181): (18, "ExternalInternalizedStringWithOneByteDataMap"),
+  ("RO_SPACE", 0x021d1): (10, "ExternalOneByteInternalizedStringMap"),
+  ("RO_SPACE", 0x02221): (34, "UncachedExternalInternalizedStringMap"),
+  ("RO_SPACE", 0x02271): (50, "UncachedExternalInternalizedStringWithOneByteDataMap"),
+  ("RO_SPACE", 0x022c1): (42, "UncachedExternalOneByteInternalizedStringMap"),
+  ("RO_SPACE", 0x02311): (106, "UncachedExternalOneByteStringMap"),
+  ("RO_SPACE", 0x02361): (140, "FixedUint8ArrayMap"),
+  ("RO_SPACE", 0x023b1): (139, "FixedInt8ArrayMap"),
+  ("RO_SPACE", 0x02401): (142, "FixedUint16ArrayMap"),
+  ("RO_SPACE", 0x02451): (141, "FixedInt16ArrayMap"),
+  ("RO_SPACE", 0x024a1): (144, "FixedUint32ArrayMap"),
+  ("RO_SPACE", 0x024f1): (143, "FixedInt32ArrayMap"),
+  ("RO_SPACE", 0x02541): (145, "FixedFloat32ArrayMap"),
+  ("RO_SPACE", 0x02591): (146, "FixedFloat64ArrayMap"),
+  ("RO_SPACE", 0x025e1): (147, "FixedUint8ClampedArrayMap"),
+  ("RO_SPACE", 0x02631): (149, "FixedBigUint64ArrayMap"),
+  ("RO_SPACE", 0x02681): (148, "FixedBigInt64ArrayMap"),
+  ("RO_SPACE", 0x026d1): (131, "SelfReferenceMarkerMap"),
+  ("RO_SPACE", 0x02739): (171, "Tuple2Map"),
+  ("RO_SPACE", 0x027d9): (173, "ArrayBoilerplateDescriptionMap"),
+  ("RO_SPACE", 0x02b19): (161, "InterceptorInfoMap"),
+  ("RO_SPACE", 0x04fa1): (153, "AccessCheckInfoMap"),
+  ("RO_SPACE", 0x04ff1): (154, "AccessorInfoMap"),
+  ("RO_SPACE", 0x05041): (155, "AccessorPairMap"),
+  ("RO_SPACE", 0x05091): (156, "AliasedArgumentsEntryMap"),
+  ("RO_SPACE", 0x050e1): (157, "AllocationMementoMap"),
+  ("RO_SPACE", 0x05131): (158, "AsyncGeneratorRequestMap"),
+  ("RO_SPACE", 0x05181): (159, "DebugInfoMap"),
+  ("RO_SPACE", 0x051d1): (160, "FunctionTemplateInfoMap"),
+  ("RO_SPACE", 0x05221): (162, "InterpreterDataMap"),
+  ("RO_SPACE", 0x05271): (163, "ModuleInfoEntryMap"),
+  ("RO_SPACE", 0x052c1): (164, "ModuleMap"),
+  ("RO_SPACE", 0x05311): (165, "ObjectTemplateInfoMap"),
+  ("RO_SPACE", 0x05361): (166, "PromiseCapabilityMap"),
+  ("RO_SPACE", 0x053b1): (167, "PromiseReactionMap"),
+  ("RO_SPACE", 0x05401): (168, "PrototypeInfoMap"),
+  ("RO_SPACE", 0x05451): (169, "ScriptMap"),
+  ("RO_SPACE", 0x054a1): (170, "StackFrameInfoMap"),
+  ("RO_SPACE", 0x054f1): (172, "Tuple3Map"),
+  ("RO_SPACE", 0x05541): (174, "WasmDebugInfoMap"),
+  ("RO_SPACE", 0x05591): (175, "WasmExportedFunctionDataMap"),
+  ("RO_SPACE", 0x055e1): (176, "CallableTaskMap"),
+  ("RO_SPACE", 0x05631): (177, "CallbackTaskMap"),
+  ("RO_SPACE", 0x05681): (178, "PromiseFulfillReactionJobTaskMap"),
+  ("RO_SPACE", 0x056d1): (179, "PromiseRejectReactionJobTaskMap"),
+  ("RO_SPACE", 0x05721): (180, "PromiseResolveThenableJobTaskMap"),
+  ("RO_SPACE", 0x05771): (181, "WeakFactoryCleanupJobTaskMap"),
+  ("RO_SPACE", 0x057c1): (182, "MicrotaskQueueMap"),
+  ("RO_SPACE", 0x05811): (183, "AllocationSiteWithWeakNextMap"),
+  ("RO_SPACE", 0x05861): (183, "AllocationSiteWithoutWeakNextMap"),
+  ("RO_SPACE", 0x058b1): (216, "LoadHandler1Map"),
+  ("RO_SPACE", 0x05901): (216, "LoadHandler2Map"),
+  ("RO_SPACE", 0x05951): (216, "LoadHandler3Map"),
+  ("RO_SPACE", 0x059a1): (224, "StoreHandler0Map"),
+  ("RO_SPACE", 0x059f1): (224, "StoreHandler1Map"),
+  ("RO_SPACE", 0x05a41): (224, "StoreHandler2Map"),
+  ("RO_SPACE", 0x05a91): (224, "StoreHandler3Map"),
   ("MAP_SPACE", 0x00139): (1057, "ExternalMap"),
   ("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"),
 }
@@ -360,37 +362,37 @@ KNOWN_OBJECTS = {
   ("RO_SPACE", 0x00d79): "TerminationException",
   ("RO_SPACE", 0x00e21): "OptimizedOut",
   ("RO_SPACE", 0x00ec1): "StaleRegister",
-  ("RO_SPACE", 0x026d1): "EmptyEnumCache",
-  ("RO_SPACE", 0x02739): "EmptyPropertyArray",
-  ("RO_SPACE", 0x02749): "EmptyByteArray",
-  ("RO_SPACE", 0x02759): "EmptyObjectBoilerplateDescription",
-  ("RO_SPACE", 0x02771): "EmptyArrayBoilerplateDescription",
-  ("RO_SPACE", 0x027d9): "EmptyFixedUint8Array",
-  ("RO_SPACE", 0x027f9): "EmptyFixedInt8Array",
-  ("RO_SPACE", 0x02819): "EmptyFixedUint16Array",
-  ("RO_SPACE", 0x02839): "EmptyFixedInt16Array",
-  ("RO_SPACE", 0x02859): "EmptyFixedUint32Array",
-  ("RO_SPACE", 0x02879): "EmptyFixedInt32Array",
-  ("RO_SPACE", 0x02899): "EmptyFixedFloat32Array",
-  ("RO_SPACE", 0x028b9): "EmptyFixedFloat64Array",
-  ("RO_SPACE", 0x028d9): "EmptyFixedUint8ClampedArray",
-  ("RO_SPACE", 0x028f9): "EmptyFixedBigUint64Array",
-  ("RO_SPACE", 0x02919): "EmptyFixedBigInt64Array",
-  ("RO_SPACE", 0x02939): "EmptySloppyArgumentsElements",
-  ("RO_SPACE", 0x02959): "EmptySlowElementDictionary",
-  ("RO_SPACE", 0x029a1): "EmptyOrderedHashMap",
-  ("RO_SPACE", 0x029c9): "EmptyOrderedHashSet",
-  ("RO_SPACE", 0x029f1): "EmptyFeedbackMetadata",
-  ("RO_SPACE", 0x02a01): "EmptyPropertyCell",
-  ("RO_SPACE", 0x02a29): "EmptyPropertyDictionary",
-  ("RO_SPACE", 0x02a79): "NoOpInterceptorInfo",
-  ("RO_SPACE", 0x02b19): "EmptyWeakArrayList",
-  ("RO_SPACE", 0x02b31): "InfinityValue",
-  ("RO_SPACE", 0x02b41): "MinusZeroValue",
-  ("RO_SPACE", 0x02b51): "MinusInfinityValue",
-  ("RO_SPACE", 0x02b61): "SelfReferenceMarker",
-  ("RO_SPACE", 0x02bb9): "OffHeapTrampolineRelocationInfo",
-  ("RO_SPACE", 0x02bd1): "HashSeed",
+  ("RO_SPACE", 0x02721): "EmptyEnumCache",
+  ("RO_SPACE", 0x02789): "EmptyPropertyArray",
+  ("RO_SPACE", 0x02799): "EmptyByteArray",
+  ("RO_SPACE", 0x027a9): "EmptyObjectBoilerplateDescription",
+  ("RO_SPACE", 0x027c1): "EmptyArrayBoilerplateDescription",
+  ("RO_SPACE", 0x02829): "EmptyFixedUint8Array",
+  ("RO_SPACE", 0x02849): "EmptyFixedInt8Array",
+  ("RO_SPACE", 0x02869): "EmptyFixedUint16Array",
+  ("RO_SPACE", 0x02889): "EmptyFixedInt16Array",
+  ("RO_SPACE", 0x028a9): "EmptyFixedUint32Array",
+  ("RO_SPACE", 0x028c9): "EmptyFixedInt32Array",
+  ("RO_SPACE", 0x028e9): "EmptyFixedFloat32Array",
+  ("RO_SPACE", 0x02909): "EmptyFixedFloat64Array",
+  ("RO_SPACE", 0x02929): "EmptyFixedUint8ClampedArray",
+  ("RO_SPACE", 0x02949): "EmptyFixedBigUint64Array",
+  ("RO_SPACE", 0x02969): "EmptyFixedBigInt64Array",
+  ("RO_SPACE", 0x02989): "EmptySloppyArgumentsElements",
+  ("RO_SPACE", 0x029a9): "EmptySlowElementDictionary",
+  ("RO_SPACE", 0x029f1): "EmptyOrderedHashMap",
+  ("RO_SPACE", 0x02a19): "EmptyOrderedHashSet",
+  ("RO_SPACE", 0x02a41): "EmptyFeedbackMetadata",
+  ("RO_SPACE", 0x02a51): "EmptyPropertyCell",
+  ("RO_SPACE", 0x02a79): "EmptyPropertyDictionary",
+  ("RO_SPACE", 0x02ac9): "NoOpInterceptorInfo",
+  ("RO_SPACE", 0x02b69): "EmptyWeakArrayList",
+  ("RO_SPACE", 0x02b81): "InfinityValue",
+  ("RO_SPACE", 0x02b91): "MinusZeroValue",
+  ("RO_SPACE", 0x02ba1): "MinusInfinityValue",
+  ("RO_SPACE", 0x02bb1): "SelfReferenceMarker",
+  ("RO_SPACE", 0x02c09): "OffHeapTrampolineRelocationInfo",
+  ("RO_SPACE", 0x02c21): "HashSeed",
   ("OLD_SPACE", 0x00139): "ArgumentsIteratorAccessor",
   ("OLD_SPACE", 0x001a9): "ArrayLengthAccessor",
   ("OLD_SPACE", 0x00219): "BoundFunctionLengthAccessor",