[dict] Add ordered name dictionary type

This is the larger dictionary specialized for Name. To be used as a
property backing store.

More methods and tests will be added in the future as it reaches
parity with NameDictionary.


Bug: v8:6443, v8:7569
Change-Id: I8f5d88b2f6f4e14d4851548566ffa9f59535358b
Reviewed-on: https://chromium-review.googlesource.com/c/1329204Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57430}

src/compiler/types.cc

@@ -277,6 +277,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) {
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:
     case ORDERED_HASH_SET_TYPE:
+    case ORDERED_NAME_DICTIONARY_TYPE:
     case NAME_DICTIONARY_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:

src/heap/factory.cc

@@ -555,6 +555,11 @@ Handle<OrderedHashMap> Factory::NewOrderedHashMap() {
   return OrderedHashMap::Allocate(isolate(), OrderedHashMap::kMinCapacity);
 }
 
+Handle<OrderedNameDictionary> Factory::NewOrderedNameDictionary() {
+  return OrderedNameDictionary::Allocate(isolate(),
+                                         OrderedNameDictionary::kMinCapacity);
+}
+
 Handle<AccessorPair> Factory::NewAccessorPair() {
   Handle<AccessorPair> accessors =
       Handle<AccessorPair>::cast(NewStruct(ACCESSOR_PAIR_TYPE, TENURED));

src/heap/factory.h

@@ -177,6 +177,7 @@ class V8_EXPORT_PRIVATE Factory {
 
   Handle<OrderedHashSet> NewOrderedHashSet();
   Handle<OrderedHashMap> NewOrderedHashMap();
+  Handle<OrderedNameDictionary> NewOrderedNameDictionary();
 
   Handle<SmallOrderedHashSet> NewSmallOrderedHashSet(
       int capacity = SmallOrderedHashSet::kMinCapacity,

src/heap/setup-heap-internal.cc

@@ -452,6 +452,7 @@ bool Heap::CreateInitialMaps() {
     ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, hash_table)
     ALLOCATE_VARSIZE_MAP(ORDERED_HASH_MAP_TYPE, ordered_hash_map)
     ALLOCATE_VARSIZE_MAP(ORDERED_HASH_SET_TYPE, ordered_hash_set)
+    ALLOCATE_VARSIZE_MAP(ORDERED_NAME_DICTIONARY_TYPE, ordered_name_dictionary)
     ALLOCATE_VARSIZE_MAP(NAME_DICTIONARY_TYPE, name_dictionary)
     ALLOCATE_VARSIZE_MAP(GLOBAL_DICTIONARY_TYPE, global_dictionary)
     ALLOCATE_VARSIZE_MAP(NUMBER_DICTIONARY_TYPE, number_dictionary)

src/objects-body-descriptors-inl.h

@@ -754,6 +754,7 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:
     case ORDERED_HASH_SET_TYPE:
+    case ORDERED_NAME_DICTIONARY_TYPE:
     case NAME_DICTIONARY_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:

src/objects-debug.cc

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

src/objects-definitions.h

@@ -131,6 +131,7 @@ namespace internal {
   V(HASH_TABLE_TYPE)                                               \
   V(ORDERED_HASH_MAP_TYPE)                                         \
   V(ORDERED_HASH_SET_TYPE)                                         \
+  V(ORDERED_NAME_DICTIONARY_TYPE)                                  \
   V(NAME_DICTIONARY_TYPE)                                          \
   V(GLOBAL_DICTIONARY_TYPE)                                        \
   V(NUMBER_DICTIONARY_TYPE)                                        \

src/objects-inl.h

@@ -483,6 +483,7 @@ CAST_ACCESSOR(HeapObject)
 CAST_ACCESSOR(HeapNumber)
 CAST_ACCESSOR(LayoutDescriptor)
 CAST_ACCESSOR(MutableHeapNumber)
+CAST_ACCESSOR(OrderedNameDictionary)
 CAST_ACCESSOR(NameDictionary)
 CAST_ACCESSOR(NormalizedMapCache)
 CAST_ACCESSOR(NumberDictionary)

src/objects-printer.cc

@@ -151,6 +151,7 @@ void HeapObject::HeapObjectPrint(std::ostream& os) {  // NOLINT
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:
     case ORDERED_HASH_SET_TYPE:
+    case ORDERED_NAME_DICTIONARY_TYPE:
     case NAME_DICTIONARY_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:

src/objects.cc

@@ -3108,6 +3108,7 @@ VisitorId Map::GetVisitorId(Map* map) {
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:
     case ORDERED_HASH_SET_TYPE:
+    case ORDERED_NAME_DICTIONARY_TYPE:
     case NAME_DICTIONARY_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:
@@ -3483,6 +3484,10 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) {  // NOLINT
     case ORDERED_HASH_SET_TYPE:
       os << "<OrderedHashSet[" << FixedArray::cast(this)->length() << "]>";
       break;
+    case ORDERED_NAME_DICTIONARY_TYPE:
+      os << "<OrderedNameDictionary[" << FixedArray::cast(this)->length()
+         << "]>";
+      break;
     case NAME_DICTIONARY_TYPE:
       os << "<NameDictionary[" << FixedArray::cast(this)->length() << "]>";
       break;
@@ -3826,6 +3831,7 @@ bool HeapObject::CanBeRehashed() const {
   switch (map()->instance_type()) {
     case ORDERED_HASH_MAP_TYPE:
     case ORDERED_HASH_SET_TYPE:
+    case ORDERED_NAME_DICTIONARY_TYPE:
       // TODO(yangguo): actually support rehashing OrderedHash{Map,Set}.
       return false;
     case NAME_DICTIONARY_TYPE:
@@ -13185,6 +13191,7 @@ bool CanSubclassHaveInobjectProperties(InstanceType instance_type) {
     case HASH_TABLE_TYPE:
     case ORDERED_HASH_MAP_TYPE:
     case ORDERED_HASH_SET_TYPE:
+    case ORDERED_NAME_DICTIONARY_TYPE:
     case NAME_DICTIONARY_TYPE:
     case GLOBAL_DICTIONARY_TYPE:
     case NUMBER_DICTIONARY_TYPE:

src/objects.h

@@ -427,6 +427,7 @@ enum InstanceType : uint16_t {
   HASH_TABLE_TYPE,        // FIRST_HASH_TABLE_TYPE
   ORDERED_HASH_MAP_TYPE,  // FIRST_DICTIONARY_TYPE
   ORDERED_HASH_SET_TYPE,
+  ORDERED_NAME_DICTIONARY_TYPE,
   NAME_DICTIONARY_TYPE,
   GLOBAL_DICTIONARY_TYPE,
   NUMBER_DICTIONARY_TYPE,
@@ -815,6 +816,7 @@ class ZoneForwardList;
   V(Oddball)                                   \
   V(OrderedHashMap)                            \
   V(OrderedHashSet)                            \
+  V(OrderedNameDictionary)                     \
   V(PreParsedScopeData)                        \
   V(PromiseReactionJobTask)                    \
   V(PropertyArray)                             \
@@ -964,6 +966,7 @@ class ZoneForwardList;
   V(Oddball, ODDBALL_TYPE)                                               \
   V(OrderedHashMap, ORDERED_HASH_MAP_TYPE)                               \
   V(OrderedHashSet, ORDERED_HASH_SET_TYPE)                               \
+  V(OrderedNameDictionary, ORDERED_NAME_DICTIONARY_TYPE)                 \
   V(PreParsedScopeData, PRE_PARSED_SCOPE_DATA_TYPE)                      \
   V(PropertyArray, PROPERTY_ARRAY_TYPE)                                  \
   V(PropertyCell, PROPERTY_CELL_TYPE)                                    \

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

@@ -21,6 +21,10 @@ RootIndex OrderedHashMap::GetMapRootIndex() {
   return RootIndex::kOrderedHashMapMap;
 }
 
+RootIndex OrderedNameDictionary::GetMapRootIndex() {
+  return RootIndex::kOrderedNameDictionaryMap;
+}
+
 RootIndex SmallOrderedHashMap::GetMapRootIndex() {
   return RootIndex::kSmallOrderedHashMapMap;
 }

src/objects/ordered-hash-table.cc

@@ -83,7 +83,8 @@ template <class Derived, int entrysize>
 bool OrderedHashTable<Derived, entrysize>::HasKey(Isolate* isolate,
                                                   Derived* table, Object* key) {
   DCHECK((entrysize == 1 && table->IsOrderedHashSet()) ||
-         (entrysize == 2 && table->IsOrderedHashMap()));
+         (entrysize == 2 && table->IsOrderedHashMap()) ||
+         (entrysize == 3 && table->IsOrderedNameDictionary()));
   DisallowHeapAllocation no_gc;
   int entry = table->FindEntry(isolate, key);
   return entry != kNotFound;
@@ -265,6 +266,51 @@ Handle<OrderedHashMap> OrderedHashMap::Add(Isolate* isolate,
   return table;
 }
 
+Handle<OrderedNameDictionary> OrderedNameDictionary::Add(
+    Isolate* isolate, Handle<OrderedNameDictionary> table, Handle<Name> key,
+    Handle<Object> value, PropertyDetails details) {
+  int hash = key->Hash();
+
+#ifdef DEBUG
+  // Walk the chain of the bucket and try finding the key.
+  {
+    DisallowHeapAllocation no_gc;
+    int entry = table->HashToEntry(hash);
+    Object* raw_key = *key;
+    while (entry != kNotFound) {
+      Object* candidate_key = table->KeyAt(entry);
+
+      // Key should not exist already!
+      CHECK(!candidate_key->SameValueZero(raw_key));
+
+      entry = table->NextChainEntry(entry);
+    }
+  }
+#endif
+
+  table = OrderedNameDictionary::EnsureGrowable(isolate, table);
+  // Read the existing bucket values.
+  int bucket = table->HashToBucket(hash);
+  int previous_entry = table->HashToEntry(hash);
+  int nof = table->NumberOfElements();
+  // Insert a new entry at the end,
+  int new_entry = nof + table->NumberOfDeletedElements();
+  int new_index = table->EntryToIndex(new_entry);
+  table->set(new_index, *key);
+  table->set(new_index + kValueOffset, *value);
+
+  // TODO(gsathya): Optimize how PropertyDetails are stored in this
+  // dictionary to save memory (by reusing padding?) and performance
+  // (by not doing the Smi conversion).
+  table->set(new_index + kPropertyDetailsOffset, details.AsSmi());
+
+  table->set(new_index + kChainOffset, Smi::FromInt(previous_entry));
+  // and point the bucket to the new entry.
+  table->set(kHashTableStartIndex + bucket, Smi::FromInt(new_entry));
+  table->SetNumberOfElements(nof + 1);
+  return table;
+}
+
 template Handle<OrderedHashSet> OrderedHashTable<OrderedHashSet, 1>::Allocate(
     Isolate* isolate, int capacity, PretenureFlag pretenure);
 
@@ -307,6 +353,18 @@ template bool OrderedHashTable<OrderedHashMap, 2>::Delete(Isolate* isolate,
                                                           OrderedHashMap* table,
                                                           Object* key);
 
+template Handle<OrderedNameDictionary>
+OrderedHashTable<OrderedNameDictionary, 3>::Allocate(Isolate* isolate,
+                                                     int capacity,
+                                                     PretenureFlag pretenure);
+
+template bool OrderedHashTable<OrderedNameDictionary, 3>::HasKey(
+    Isolate* isolate, OrderedNameDictionary* table, Object* key);
+
+template Handle<OrderedNameDictionary>
+OrderedHashTable<OrderedNameDictionary, 3>::EnsureGrowable(
+    Isolate* isolate, Handle<OrderedNameDictionary> table);
+
 template <>
 Handle<SmallOrderedHashSet>
 SmallOrderedHashTable<SmallOrderedHashSet>::Allocate(Isolate* isolate,

src/objects/ordered-hash-table.h

@@ -614,6 +614,24 @@ class OrderedHashSetHandler
       Isolate* isolate, Handle<SmallOrderedHashSet> table);
 };
 
+class OrderedNameDictionary
+    : public OrderedHashTable<OrderedNameDictionary, 3> {
+ public:
+  DECL_CAST(OrderedNameDictionary)
+
+  static Handle<OrderedNameDictionary> Add(Isolate* isolate,
+                                           Handle<OrderedNameDictionary> table,
+                                           Handle<Name> key,
+                                           Handle<Object> value,
+                                           PropertyDetails details);
+
+  static HeapObject* GetEmpty(ReadOnlyRoots ro_roots);
+  static inline RootIndex GetMapRootIndex();
+
+  static const int kValueOffset = 1;
+  static const int kPropertyDetailsOffset = 2;
+};
+
 class JSCollectionIterator : public JSObject {
  public:
   // [table]: the backing hash table mapping keys to values.

src/roots.h

@@ -99,6 +99,7 @@ class RootVisitor;
   V(Map*, one_closure_cell_map, OneClosureCellMap)                             \
   V(Map*, ordered_hash_map_map, OrderedHashMapMap)                             \
   V(Map*, ordered_hash_set_map, OrderedHashSetMap)                             \
+  V(Map*, ordered_name_dictionary_map, OrderedNameDictionaryMap)               \
   V(Map*, pre_parsed_scope_data_map, PreParsedScopeDataMap)                    \
   V(Map*, property_array_map, PropertyArrayMap)                                \
   V(Map*, side_effect_call_handler_info_map, SideEffectCallHandlerInfoMap)     \

test/cctest/test-orderedhashtable.cc

@@ -1271,6 +1271,37 @@ TEST(OrderedHashMapHandlerInsertion) {
   CHECK(OrderedHashMap::Is(map));
 }
 
+TEST(OrderedNameDictionaryInsertion) {
+  LocalContext context;
+  Isolate* isolate = GetIsolateFrom(&context);
+  Factory* factory = isolate->factory();
+  HandleScope scope(isolate);
+
+  Handle<OrderedNameDictionary> dict = factory->NewOrderedNameDictionary();
+  Verify(isolate, dict);
+  CHECK_EQ(2, dict->NumberOfBuckets());
+  CHECK_EQ(0, dict->NumberOfElements());
+
+  Handle<String> key1 = factory->NewStringFromAsciiChecked("foo");
+  Handle<String> value = factory->NewStringFromAsciiChecked("foo");
+  CHECK(!OrderedNameDictionary::HasKey(isolate, *dict, *key1));
+  PropertyDetails details = PropertyDetails::Empty();
+  dict = OrderedNameDictionary::Add(isolate, dict, key1, value, details);
+  Verify(isolate, dict);
+  CHECK_EQ(2, dict->NumberOfBuckets());
+  CHECK_EQ(1, dict->NumberOfElements());
+  CHECK(OrderedNameDictionary::HasKey(isolate, *dict, *key1));
+
+  Handle<Symbol> key2 = factory->NewSymbol();
+  CHECK(!OrderedNameDictionary::HasKey(isolate, *dict, *key2));
+  dict = OrderedNameDictionary::Add(isolate, dict, key2, value, details);
+  Verify(isolate, dict);
+  CHECK_EQ(2, dict->NumberOfBuckets());
+  CHECK_EQ(2, dict->NumberOfElements());
+  CHECK(OrderedNameDictionary::HasKey(isolate, *dict, *key1));
+  CHECK(OrderedNameDictionary::HasKey(isolate, *dict, *key2));
+}
+
 }  // namespace test_orderedhashtable
 }  // namespace internal
 }  // namespace v8

tools/v8heapconst.py

@@ -90,43 +90,44 @@ INSTANCE_TYPES = {
   186: "HASH_TABLE_TYPE",
   187: "ORDERED_HASH_MAP_TYPE",
   188: "ORDERED_HASH_SET_TYPE",
-  189: "NAME_DICTIONARY_TYPE",
-  190: "GLOBAL_DICTIONARY_TYPE",
-  191: "NUMBER_DICTIONARY_TYPE",
-  192: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  193: "STRING_TABLE_TYPE",
-  194: "EPHEMERON_HASH_TABLE_TYPE",
-  195: "SCOPE_INFO_TYPE",
-  196: "SCRIPT_CONTEXT_TABLE_TYPE",
-  197: "AWAIT_CONTEXT_TYPE",
-  198: "BLOCK_CONTEXT_TYPE",
-  199: "CATCH_CONTEXT_TYPE",
-  200: "DEBUG_EVALUATE_CONTEXT_TYPE",
-  201: "EVAL_CONTEXT_TYPE",
-  202: "FUNCTION_CONTEXT_TYPE",
-  203: "MODULE_CONTEXT_TYPE",
-  204: "NATIVE_CONTEXT_TYPE",
-  205: "SCRIPT_CONTEXT_TYPE",
-  206: "WITH_CONTEXT_TYPE",
-  207: "WEAK_FIXED_ARRAY_TYPE",
-  208: "DESCRIPTOR_ARRAY_TYPE",
-  209: "TRANSITION_ARRAY_TYPE",
-  210: "CALL_HANDLER_INFO_TYPE",
-  211: "CELL_TYPE",
-  212: "CODE_DATA_CONTAINER_TYPE",
-  213: "FEEDBACK_CELL_TYPE",
-  214: "FEEDBACK_VECTOR_TYPE",
-  215: "LOAD_HANDLER_TYPE",
-  216: "PRE_PARSED_SCOPE_DATA_TYPE",
-  217: "PROPERTY_ARRAY_TYPE",
-  218: "PROPERTY_CELL_TYPE",
-  219: "SHARED_FUNCTION_INFO_TYPE",
-  220: "SMALL_ORDERED_HASH_MAP_TYPE",
-  221: "SMALL_ORDERED_HASH_SET_TYPE",
-  222: "STORE_HANDLER_TYPE",
-  223: "UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE",
-  224: "UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE",
-  225: "WEAK_ARRAY_LIST_TYPE",
+  189: "ORDERED_NAME_DICTIONARY_TYPE",
+  190: "NAME_DICTIONARY_TYPE",
+  191: "GLOBAL_DICTIONARY_TYPE",
+  192: "NUMBER_DICTIONARY_TYPE",
+  193: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  194: "STRING_TABLE_TYPE",
+  195: "EPHEMERON_HASH_TABLE_TYPE",
+  196: "SCOPE_INFO_TYPE",
+  197: "SCRIPT_CONTEXT_TABLE_TYPE",
+  198: "AWAIT_CONTEXT_TYPE",
+  199: "BLOCK_CONTEXT_TYPE",
+  200: "CATCH_CONTEXT_TYPE",
+  201: "DEBUG_EVALUATE_CONTEXT_TYPE",
+  202: "EVAL_CONTEXT_TYPE",
+  203: "FUNCTION_CONTEXT_TYPE",
+  204: "MODULE_CONTEXT_TYPE",
+  205: "NATIVE_CONTEXT_TYPE",
+  206: "SCRIPT_CONTEXT_TYPE",
+  207: "WITH_CONTEXT_TYPE",
+  208: "WEAK_FIXED_ARRAY_TYPE",
+  209: "DESCRIPTOR_ARRAY_TYPE",
+  210: "TRANSITION_ARRAY_TYPE",
+  211: "CALL_HANDLER_INFO_TYPE",
+  212: "CELL_TYPE",
+  213: "CODE_DATA_CONTAINER_TYPE",
+  214: "FEEDBACK_CELL_TYPE",
+  215: "FEEDBACK_VECTOR_TYPE",
+  216: "LOAD_HANDLER_TYPE",
+  217: "PRE_PARSED_SCOPE_DATA_TYPE",
+  218: "PROPERTY_ARRAY_TYPE",
+  219: "PROPERTY_CELL_TYPE",
+  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",
   1024: "JS_PROXY_TYPE",
   1025: "JS_GLOBAL_OBJECT_TYPE",
   1026: "JS_GLOBAL_PROXY_TYPE",
@@ -191,8 +192,8 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x00139): (138, "FreeSpaceMap"),
   ("RO_SPACE", 0x00189): (132, "MetaMap"),
   ("RO_SPACE", 0x00209): (131, "NullMap"),
-  ("RO_SPACE", 0x00279): (208, "DescriptorArrayMap"),
-  ("RO_SPACE", 0x002d9): (207, "WeakFixedArrayMap"),
+  ("RO_SPACE", 0x00279): (209, "DescriptorArrayMap"),
+  ("RO_SPACE", 0x002d9): (208, "WeakFixedArrayMap"),
   ("RO_SPACE", 0x00329): (152, "OnePointerFillerMap"),
   ("RO_SPACE", 0x00379): (152, "TwoPointerFillerMap"),
   ("RO_SPACE", 0x003f9): (131, "UninitializedMap"),
@@ -207,133 +208,134 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x00859): (186, "HashTableMap"),
   ("RO_SPACE", 0x008a9): (128, "SymbolMap"),
   ("RO_SPACE", 0x008f9): (72, "OneByteStringMap"),
-  ("RO_SPACE", 0x00949): (195, "ScopeInfoMap"),
-  ("RO_SPACE", 0x00999): (219, "SharedFunctionInfoMap"),
+  ("RO_SPACE", 0x00949): (196, "ScopeInfoMap"),
+  ("RO_SPACE", 0x00999): (220, "SharedFunctionInfoMap"),
   ("RO_SPACE", 0x009e9): (133, "CodeMap"),
-  ("RO_SPACE", 0x00a39): (202, "FunctionContextMap"),
-  ("RO_SPACE", 0x00a89): (211, "CellMap"),
-  ("RO_SPACE", 0x00ad9): (218, "GlobalPropertyCellMap"),
+  ("RO_SPACE", 0x00a39): (203, "FunctionContextMap"),
+  ("RO_SPACE", 0x00a89): (212, "CellMap"),
+  ("RO_SPACE", 0x00ad9): (219, "GlobalPropertyCellMap"),
   ("RO_SPACE", 0x00b29): (135, "ForeignMap"),
-  ("RO_SPACE", 0x00b79): (209, "TransitionArrayMap"),
-  ("RO_SPACE", 0x00bc9): (214, "FeedbackVectorMap"),
+  ("RO_SPACE", 0x00b79): (210, "TransitionArrayMap"),
+  ("RO_SPACE", 0x00bc9): (215, "FeedbackVectorMap"),
   ("RO_SPACE", 0x00c69): (131, "ArgumentsMarkerMap"),
   ("RO_SPACE", 0x00d09): (131, "ExceptionMap"),
   ("RO_SPACE", 0x00da9): (131, "TerminationExceptionMap"),
   ("RO_SPACE", 0x00e51): (131, "OptimizedOutMap"),
   ("RO_SPACE", 0x00ef1): (131, "StaleRegisterMap"),
-  ("RO_SPACE", 0x00f61): (204, "NativeContextMap"),
-  ("RO_SPACE", 0x00fb1): (203, "ModuleContextMap"),
-  ("RO_SPACE", 0x01001): (201, "EvalContextMap"),
-  ("RO_SPACE", 0x01051): (205, "ScriptContextMap"),
-  ("RO_SPACE", 0x010a1): (197, "AwaitContextMap"),
-  ("RO_SPACE", 0x010f1): (198, "BlockContextMap"),
-  ("RO_SPACE", 0x01141): (199, "CatchContextMap"),
-  ("RO_SPACE", 0x01191): (206, "WithContextMap"),
-  ("RO_SPACE", 0x011e1): (200, "DebugEvaluateContextMap"),
-  ("RO_SPACE", 0x01231): (196, "ScriptContextTableMap"),
+  ("RO_SPACE", 0x00f61): (205, "NativeContextMap"),
+  ("RO_SPACE", 0x00fb1): (204, "ModuleContextMap"),
+  ("RO_SPACE", 0x01001): (202, "EvalContextMap"),
+  ("RO_SPACE", 0x01051): (206, "ScriptContextMap"),
+  ("RO_SPACE", 0x010a1): (198, "AwaitContextMap"),
+  ("RO_SPACE", 0x010f1): (199, "BlockContextMap"),
+  ("RO_SPACE", 0x01141): (200, "CatchContextMap"),
+  ("RO_SPACE", 0x01191): (207, "WithContextMap"),
+  ("RO_SPACE", 0x011e1): (201, "DebugEvaluateContextMap"),
+  ("RO_SPACE", 0x01231): (197, "ScriptContextTableMap"),
   ("RO_SPACE", 0x01281): (151, "FeedbackMetadataArrayMap"),
   ("RO_SPACE", 0x012d1): (184, "ArrayListMap"),
   ("RO_SPACE", 0x01321): (130, "BigIntMap"),
   ("RO_SPACE", 0x01371): (185, "ObjectBoilerplateDescriptionMap"),
   ("RO_SPACE", 0x013c1): (137, "BytecodeArrayMap"),
-  ("RO_SPACE", 0x01411): (212, "CodeDataContainerMap"),
+  ("RO_SPACE", 0x01411): (213, "CodeDataContainerMap"),
   ("RO_SPACE", 0x01461): (150, "FixedDoubleArrayMap"),
-  ("RO_SPACE", 0x014b1): (190, "GlobalDictionaryMap"),
-  ("RO_SPACE", 0x01501): (213, "ManyClosuresCellMap"),
+  ("RO_SPACE", 0x014b1): (191, "GlobalDictionaryMap"),
+  ("RO_SPACE", 0x01501): (214, "ManyClosuresCellMap"),
   ("RO_SPACE", 0x01551): (184, "ModuleInfoMap"),
   ("RO_SPACE", 0x015a1): (134, "MutableHeapNumberMap"),
-  ("RO_SPACE", 0x015f1): (189, "NameDictionaryMap"),
-  ("RO_SPACE", 0x01641): (213, "NoClosuresCellMap"),
-  ("RO_SPACE", 0x01691): (191, "NumberDictionaryMap"),
-  ("RO_SPACE", 0x016e1): (213, "OneClosureCellMap"),
+  ("RO_SPACE", 0x015f1): (190, "NameDictionaryMap"),
+  ("RO_SPACE", 0x01641): (214, "NoClosuresCellMap"),
+  ("RO_SPACE", 0x01691): (192, "NumberDictionaryMap"),
+  ("RO_SPACE", 0x016e1): (214, "OneClosureCellMap"),
   ("RO_SPACE", 0x01731): (187, "OrderedHashMapMap"),
   ("RO_SPACE", 0x01781): (188, "OrderedHashSetMap"),
-  ("RO_SPACE", 0x017d1): (216, "PreParsedScopeDataMap"),
-  ("RO_SPACE", 0x01821): (217, "PropertyArrayMap"),
-  ("RO_SPACE", 0x01871): (210, "SideEffectCallHandlerInfoMap"),
-  ("RO_SPACE", 0x018c1): (210, "SideEffectFreeCallHandlerInfoMap"),
-  ("RO_SPACE", 0x01911): (210, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("RO_SPACE", 0x01961): (192, "SimpleNumberDictionaryMap"),
-  ("RO_SPACE", 0x019b1): (184, "SloppyArgumentsElementsMap"),
-  ("RO_SPACE", 0x01a01): (220, "SmallOrderedHashMapMap"),
-  ("RO_SPACE", 0x01a51): (221, "SmallOrderedHashSetMap"),
-  ("RO_SPACE", 0x01aa1): (193, "StringTableMap"),
-  ("RO_SPACE", 0x01af1): (223, "UncompiledDataWithoutPreParsedScopeMap"),
-  ("RO_SPACE", 0x01b41): (224, "UncompiledDataWithPreParsedScopeMap"),
-  ("RO_SPACE", 0x01b91): (225, "WeakArrayListMap"),
-  ("RO_SPACE", 0x01be1): (194, "EphemeronHashTableMap"),
-  ("RO_SPACE", 0x01c31): (106, "NativeSourceStringMap"),
-  ("RO_SPACE", 0x01c81): (64, "StringMap"),
-  ("RO_SPACE", 0x01cd1): (73, "ConsOneByteStringMap"),
-  ("RO_SPACE", 0x01d21): (65, "ConsStringMap"),
-  ("RO_SPACE", 0x01d71): (77, "ThinOneByteStringMap"),
-  ("RO_SPACE", 0x01dc1): (69, "ThinStringMap"),
-  ("RO_SPACE", 0x01e11): (67, "SlicedStringMap"),
-  ("RO_SPACE", 0x01e61): (75, "SlicedOneByteStringMap"),
-  ("RO_SPACE", 0x01eb1): (66, "ExternalStringMap"),
-  ("RO_SPACE", 0x01f01): (82, "ExternalStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x01f51): (74, "ExternalOneByteStringMap"),
-  ("RO_SPACE", 0x01fa1): (98, "UncachedExternalStringMap"),
-  ("RO_SPACE", 0x01ff1): (114, "UncachedExternalStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x02041): (0, "InternalizedStringMap"),
-  ("RO_SPACE", 0x02091): (2, "ExternalInternalizedStringMap"),
-  ("RO_SPACE", 0x020e1): (18, "ExternalInternalizedStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x02131): (10, "ExternalOneByteInternalizedStringMap"),
-  ("RO_SPACE", 0x02181): (34, "UncachedExternalInternalizedStringMap"),
-  ("RO_SPACE", 0x021d1): (50, "UncachedExternalInternalizedStringWithOneByteDataMap"),
-  ("RO_SPACE", 0x02221): (42, "UncachedExternalOneByteInternalizedStringMap"),
-  ("RO_SPACE", 0x02271): (106, "UncachedExternalOneByteStringMap"),
-  ("RO_SPACE", 0x022c1): (140, "FixedUint8ArrayMap"),
-  ("RO_SPACE", 0x02311): (139, "FixedInt8ArrayMap"),
-  ("RO_SPACE", 0x02361): (142, "FixedUint16ArrayMap"),
-  ("RO_SPACE", 0x023b1): (141, "FixedInt16ArrayMap"),
-  ("RO_SPACE", 0x02401): (144, "FixedUint32ArrayMap"),
-  ("RO_SPACE", 0x02451): (143, "FixedInt32ArrayMap"),
-  ("RO_SPACE", 0x024a1): (145, "FixedFloat32ArrayMap"),
-  ("RO_SPACE", 0x024f1): (146, "FixedFloat64ArrayMap"),
-  ("RO_SPACE", 0x02541): (147, "FixedUint8ClampedArrayMap"),
-  ("RO_SPACE", 0x02591): (149, "FixedBigUint64ArrayMap"),
-  ("RO_SPACE", 0x025e1): (148, "FixedBigInt64ArrayMap"),
-  ("RO_SPACE", 0x02631): (131, "SelfReferenceMarkerMap"),
-  ("RO_SPACE", 0x02699): (171, "Tuple2Map"),
-  ("RO_SPACE", 0x02739): (173, "ArrayBoilerplateDescriptionMap"),
-  ("RO_SPACE", 0x02a79): (161, "InterceptorInfoMap"),
-  ("RO_SPACE", 0x04f01): (153, "AccessCheckInfoMap"),
-  ("RO_SPACE", 0x04f51): (154, "AccessorInfoMap"),
-  ("RO_SPACE", 0x04fa1): (155, "AccessorPairMap"),
-  ("RO_SPACE", 0x04ff1): (156, "AliasedArgumentsEntryMap"),
-  ("RO_SPACE", 0x05041): (157, "AllocationMementoMap"),
-  ("RO_SPACE", 0x05091): (158, "AsyncGeneratorRequestMap"),
-  ("RO_SPACE", 0x050e1): (159, "DebugInfoMap"),
-  ("RO_SPACE", 0x05131): (160, "FunctionTemplateInfoMap"),
-  ("RO_SPACE", 0x05181): (162, "InterpreterDataMap"),
-  ("RO_SPACE", 0x051d1): (163, "ModuleInfoEntryMap"),
-  ("RO_SPACE", 0x05221): (164, "ModuleMap"),
-  ("RO_SPACE", 0x05271): (165, "ObjectTemplateInfoMap"),
-  ("RO_SPACE", 0x052c1): (166, "PromiseCapabilityMap"),
-  ("RO_SPACE", 0x05311): (167, "PromiseReactionMap"),
-  ("RO_SPACE", 0x05361): (168, "PrototypeInfoMap"),
-  ("RO_SPACE", 0x053b1): (169, "ScriptMap"),
-  ("RO_SPACE", 0x05401): (170, "StackFrameInfoMap"),
-  ("RO_SPACE", 0x05451): (172, "Tuple3Map"),
-  ("RO_SPACE", 0x054a1): (174, "WasmDebugInfoMap"),
-  ("RO_SPACE", 0x054f1): (175, "WasmExportedFunctionDataMap"),
-  ("RO_SPACE", 0x05541): (176, "CallableTaskMap"),
-  ("RO_SPACE", 0x05591): (177, "CallbackTaskMap"),
-  ("RO_SPACE", 0x055e1): (178, "PromiseFulfillReactionJobTaskMap"),
-  ("RO_SPACE", 0x05631): (179, "PromiseRejectReactionJobTaskMap"),
-  ("RO_SPACE", 0x05681): (180, "PromiseResolveThenableJobTaskMap"),
-  ("RO_SPACE", 0x056d1): (181, "WeakFactoryCleanupJobTaskMap"),
-  ("RO_SPACE", 0x05721): (182, "MicrotaskQueueMap"),
-  ("RO_SPACE", 0x05771): (183, "AllocationSiteWithWeakNextMap"),
-  ("RO_SPACE", 0x057c1): (183, "AllocationSiteWithoutWeakNextMap"),
-  ("RO_SPACE", 0x05811): (215, "LoadHandler1Map"),
-  ("RO_SPACE", 0x05861): (215, "LoadHandler2Map"),
-  ("RO_SPACE", 0x058b1): (215, "LoadHandler3Map"),
-  ("RO_SPACE", 0x05901): (222, "StoreHandler0Map"),
-  ("RO_SPACE", 0x05951): (222, "StoreHandler1Map"),
-  ("RO_SPACE", 0x059a1): (222, "StoreHandler2Map"),
-  ("RO_SPACE", 0x059f1): (222, "StoreHandler3Map"),
+  ("RO_SPACE", 0x017d1): (189, "OrderedNameDictionaryMap"),
+  ("RO_SPACE", 0x01821): (217, "PreParsedScopeDataMap"),
+  ("RO_SPACE", 0x01871): (218, "PropertyArrayMap"),
+  ("RO_SPACE", 0x018c1): (211, "SideEffectCallHandlerInfoMap"),
+  ("RO_SPACE", 0x01911): (211, "SideEffectFreeCallHandlerInfoMap"),
+  ("RO_SPACE", 0x01961): (211, "NextCallSideEffectFreeCallHandlerInfoMap"),
+  ("RO_SPACE", 0x019b1): (193, "SimpleNumberDictionaryMap"),
+  ("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"),
   ("MAP_SPACE", 0x00139): (1057, "ExternalMap"),
   ("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"),
 }
@@ -358,37 +360,37 @@ KNOWN_OBJECTS = {
   ("RO_SPACE", 0x00d79): "TerminationException",
   ("RO_SPACE", 0x00e21): "OptimizedOut",
   ("RO_SPACE", 0x00ec1): "StaleRegister",
-  ("RO_SPACE", 0x02681): "EmptyEnumCache",
-  ("RO_SPACE", 0x026e9): "EmptyPropertyArray",
-  ("RO_SPACE", 0x026f9): "EmptyByteArray",
-  ("RO_SPACE", 0x02709): "EmptyObjectBoilerplateDescription",
-  ("RO_SPACE", 0x02721): "EmptyArrayBoilerplateDescription",
-  ("RO_SPACE", 0x02789): "EmptyFixedUint8Array",
-  ("RO_SPACE", 0x027a9): "EmptyFixedInt8Array",
-  ("RO_SPACE", 0x027c9): "EmptyFixedUint16Array",
-  ("RO_SPACE", 0x027e9): "EmptyFixedInt16Array",
-  ("RO_SPACE", 0x02809): "EmptyFixedUint32Array",
-  ("RO_SPACE", 0x02829): "EmptyFixedInt32Array",
-  ("RO_SPACE", 0x02849): "EmptyFixedFloat32Array",
-  ("RO_SPACE", 0x02869): "EmptyFixedFloat64Array",
-  ("RO_SPACE", 0x02889): "EmptyFixedUint8ClampedArray",
-  ("RO_SPACE", 0x028a9): "EmptyFixedBigUint64Array",
-  ("RO_SPACE", 0x028c9): "EmptyFixedBigInt64Array",
-  ("RO_SPACE", 0x028e9): "EmptySloppyArgumentsElements",
-  ("RO_SPACE", 0x02909): "EmptySlowElementDictionary",
-  ("RO_SPACE", 0x02951): "EmptyOrderedHashMap",
-  ("RO_SPACE", 0x02979): "EmptyOrderedHashSet",
-  ("RO_SPACE", 0x029a1): "EmptyFeedbackMetadata",
-  ("RO_SPACE", 0x029b1): "EmptyPropertyCell",
-  ("RO_SPACE", 0x029d9): "EmptyPropertyDictionary",
-  ("RO_SPACE", 0x02a29): "NoOpInterceptorInfo",
-  ("RO_SPACE", 0x02ac9): "EmptyWeakArrayList",
-  ("RO_SPACE", 0x02ae1): "InfinityValue",
-  ("RO_SPACE", 0x02af1): "MinusZeroValue",
-  ("RO_SPACE", 0x02b01): "MinusInfinityValue",
-  ("RO_SPACE", 0x02b11): "SelfReferenceMarker",
-  ("RO_SPACE", 0x02b69): "OffHeapTrampolineRelocationInfo",
-  ("RO_SPACE", 0x02b81): "HashSeed",
+  ("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",
   ("OLD_SPACE", 0x00139): "ArgumentsIteratorAccessor",
   ("OLD_SPACE", 0x001a9): "ArrayLengthAccessor",
   ("OLD_SPACE", 0x00219): "BoundFunctionLengthAccessor",