[cleanup] Make Hashtable Shapes return Map Handles

Make Hashtable Shapes return Map Handles (from the read-only roots)
instead of the root index of the Map, so that they can be used off
the main thread.

Bug: chromium:1011762
Change-Id: I4c0a8518dc1c6d490b5c04da05b5319081a6fae5
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2083298
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Auto-Submit: Leszek Swirski <leszeks@chromium.org>
Cr-Commit-Position: refs/heads/master@{#66569}

src/builtins/builtins-collections-gen.cc

@@ -14,6 +14,7 @@
 #include "src/objects/hash-table-inl.h"
 #include "src/objects/js-collection.h"
 #include "src/objects/ordered-hash-table.h"
+#include "src/roots/roots.h"
 
 namespace v8 {
 namespace internal {
@@ -2508,8 +2509,9 @@ TNode<HeapObject> WeakCollectionsBuiltinsAssembler::AllocateTable(
   TNode<FixedArray> table = CAST(
       AllocateFixedArray(HOLEY_ELEMENTS, length, kAllowLargeObjectAllocation));
 
-  RootIndex map_root_index = EphemeronHashTableShape::GetMapRootIndex();
-  StoreMapNoWriteBarrier(table, map_root_index);
+  TNode<Map> map =
+      HeapConstant(EphemeronHashTableShape::GetMap(ReadOnlyRoots(isolate())));
+  StoreMapNoWriteBarrier(table, map);
   StoreFixedArrayElement(table, EphemeronHashTable::kNumberOfElementsIndex,
                          SmiConstant(0), SKIP_WRITE_BARRIER);
   StoreFixedArrayElement(table,

src/codegen/code-stub-assembler.cc

@@ -23,6 +23,7 @@
 #include "src/objects/oddball.h"
 #include "src/objects/ordered-hash-table-inl.h"
 #include "src/objects/property-cell.h"
+#include "src/roots/roots.h"
 #include "src/wasm/wasm-objects.h"
 
 namespace v8 {
@@ -3374,7 +3375,6 @@ TNode<String> CodeStubAssembler::AllocateSlicedTwoByteString(
                               offset);
 }
 
-
 TNode<NameDictionary> CodeStubAssembler::AllocateNameDictionary(
     int at_least_space_for) {
   return AllocateNameDictionary(IntPtrConstant(at_least_space_for));
@@ -3479,7 +3479,7 @@ TNode<CollectionType> CodeStubAssembler::AllocateOrderedHashTable() {
   const ElementsKind elements_kind = HOLEY_ELEMENTS;
   TNode<IntPtrT> length_intptr = IntPtrConstant(kFixedArrayLength);
   TNode<Map> fixed_array_map =
-      CAST(LoadRoot(CollectionType::GetMapRootIndex()));
+      HeapConstant(CollectionType::GetMap(ReadOnlyRoots(isolate())));
   TNode<CollectionType> table =
       CAST(AllocateFixedArray(elements_kind, length_intptr,
                               kAllowLargeObjectAllocation, fixed_array_map));

src/heap/factory-base.cc

@@ -60,19 +60,19 @@ Handle<FixedArray> FactoryBase<Impl>::NewFixedArray(int length,
                                                     AllocationType allocation) {
   DCHECK_LE(0, length);
   if (length == 0) return impl()->empty_fixed_array();
-  return NewFixedArrayWithFiller(read_only_roots().fixed_array_map(), length,
-                                 read_only_roots().undefined_value(),
-                                 allocation);
+  return NewFixedArrayWithFiller(
+      read_only_roots().fixed_array_map_handle(), length,
+      read_only_roots().undefined_value_handle(), allocation);
 }
 
 template <typename Impl>
 Handle<FixedArray> FactoryBase<Impl>::NewFixedArrayWithMap(
-    Map map, int length, AllocationType allocation) {
+    Handle<Map> map, int length, AllocationType allocation) {
   // Zero-length case must be handled outside, where the knowledge about
   // the map is.
   DCHECK_LT(0, length);
   return NewFixedArrayWithFiller(
-      map, length, read_only_roots().undefined_value(), allocation);
+      map, length, read_only_roots().undefined_value_handle(), allocation);
 }
 
 template <typename Impl>
@@ -80,21 +80,22 @@ Handle<FixedArray> FactoryBase<Impl>::NewFixedArrayWithHoles(
     int length, AllocationType allocation) {
   DCHECK_LE(0, length);
   if (length == 0) return impl()->empty_fixed_array();
-  return NewFixedArrayWithFiller(read_only_roots().fixed_array_map(), length,
-                                 read_only_roots().the_hole_value(),
-                                 allocation);
+  return NewFixedArrayWithFiller(
+      read_only_roots().fixed_array_map_handle(), length,
+      read_only_roots().the_hole_value_handle(), allocation);
 }
 
 template <typename Impl>
 Handle<FixedArray> FactoryBase<Impl>::NewFixedArrayWithFiller(
-    Map map, int length, Oddball filler, AllocationType allocation) {
+    Handle<Map> map, int length, Handle<Oddball> filler,
+    AllocationType allocation) {
   HeapObject result = AllocateRawFixedArray(length, allocation);
-  DCHECK(ReadOnlyHeap::Contains(map));
-  DCHECK(ReadOnlyHeap::Contains(filler));
-  result.set_map_after_allocation(map, SKIP_WRITE_BARRIER);
+  DCHECK(ReadOnlyHeap::Contains(*map));
+  DCHECK(ReadOnlyHeap::Contains(*filler));
+  result.set_map_after_allocation(*map, SKIP_WRITE_BARRIER);
   Handle<FixedArray> array = handle(FixedArray::cast(result), isolate());
   array->set_length(length);
-  MemsetTagged(array->data_start(), filler, length);
+  MemsetTagged(array->data_start(), *filler, length);
   return array;
 }
 
@@ -352,7 +353,7 @@ FactoryBase<Impl>::NewObjectBoilerplateDescription(int boilerplate,
 
   Handle<ObjectBoilerplateDescription> description =
       Handle<ObjectBoilerplateDescription>::cast(NewFixedArrayWithMap(
-          read_only_roots().object_boilerplate_description_map(), size,
+          read_only_roots().object_boilerplate_description_map_handle(), size,
           AllocationType::kOld));
 
   if (has_different_size_backing_store) {
@@ -605,14 +606,14 @@ template <typename Impl>
 Handle<ScopeInfo> FactoryBase<Impl>::NewScopeInfo(int length,
                                                   AllocationType type) {
   DCHECK(type == AllocationType::kOld || type == AllocationType::kReadOnly);
-  return Handle<ScopeInfo>::cast(
-      NewFixedArrayWithMap(read_only_roots().scope_info_map(), length, type));
+  return Handle<ScopeInfo>::cast(NewFixedArrayWithMap(
+      read_only_roots().scope_info_map_handle(), length, type));
 }
 
 template <typename Impl>
 Handle<SourceTextModuleInfo> FactoryBase<Impl>::NewSourceTextModuleInfo() {
   return Handle<SourceTextModuleInfo>::cast(NewFixedArrayWithMap(
-      read_only_roots().module_info_map(), SourceTextModuleInfo::kLength,
+      read_only_roots().module_info_map_handle(), SourceTextModuleInfo::kLength,
       AllocationType::kOld));
 }
 

src/heap/factory-base.h

@@ -71,7 +71,8 @@ class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) FactoryBase {
   // Allocates a fixed array-like object with given map and initialized with
   // undefined values.
   Handle<FixedArray> NewFixedArrayWithMap(
-      Map map, int length, AllocationType allocation = AllocationType::kYoung);
+      Handle<Map> map, int length,
+      AllocationType allocation = AllocationType::kYoung);
 
   // Allocate a new fixed array with non-existing entries (the hole).
   Handle<FixedArray> NewFixedArrayWithHoles(
@@ -185,8 +186,8 @@ class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) FactoryBase {
       AllocationAlignment alignment = kWordAligned);
   HeapObject NewWithImmortalMap(Map map, AllocationType allocation);
 
-  Handle<FixedArray> NewFixedArrayWithFiller(Map map, int length,
-                                             Oddball filler,
+  Handle<FixedArray> NewFixedArrayWithFiller(Handle<Map> map, int length,
+                                             Handle<Oddball> filler,
                                              AllocationType allocation);
 
   Handle<SharedFunctionInfo> NewSharedFunctionInfo();

src/heap/factory.cc

@@ -334,12 +334,6 @@ Handle<PropertyArray> Factory::NewPropertyArray(int length) {
   return array;
 }
 
-Handle<FixedArray> Factory::NewFixedArrayWithMapRootIndex(
-    RootIndex map_root_index, int length, AllocationType allocation) {
-  return NewFixedArrayWithMap(Map::cast(isolate()->root(map_root_index)),
-                              length, allocation);
-}
-
 MaybeHandle<FixedArray> Factory::TryNewFixedArray(
     int length, AllocationType allocation_type) {
   DCHECK_LE(0, length);
@@ -371,8 +365,9 @@ Handle<FixedArray> Factory::NewUninitializedFixedArray(int length) {
   // TODO(ulan): As an experiment this temporarily returns an initialized fixed
   // array. After getting canary/performance coverage, either remove the
   // function or revert to returning uninitilized array.
-  return NewFixedArrayWithFiller(read_only_roots().fixed_array_map(), length,
-                                 *undefined_value(), AllocationType::kYoung);
+  return NewFixedArrayWithFiller(read_only_roots().fixed_array_map_handle(),
+                                 length, undefined_value(),
+                                 AllocationType::kYoung);
 }
 
 Handle<ClosureFeedbackCellArray> Factory::NewClosureFeedbackCellArray(
@@ -381,7 +376,7 @@ Handle<ClosureFeedbackCellArray> Factory::NewClosureFeedbackCellArray(
 
   Handle<ClosureFeedbackCellArray> feedback_cell_array =
       Handle<ClosureFeedbackCellArray>::cast(NewFixedArrayWithMap(
-          read_only_roots().closure_feedback_cell_array_map(), length,
+          read_only_roots().closure_feedback_cell_array_map_handle(), length,
           AllocationType::kOld));
 
   return feedback_cell_array;
@@ -1083,7 +1078,7 @@ Handle<Context> Factory::NewScriptContext(Handle<NativeContext> outer,
 
 Handle<ScriptContextTable> Factory::NewScriptContextTable() {
   Handle<ScriptContextTable> context_table = Handle<ScriptContextTable>::cast(
-      NewFixedArrayWithMap(read_only_roots().script_context_table_map(),
+      NewFixedArrayWithMap(read_only_roots().script_context_table_map_handle(),
                            ScriptContextTable::kMinLength));
   context_table->set_used(0);
   return context_table;

src/heap/factory.h

@@ -110,12 +110,6 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
   // Marks self references within code generation.
   Handle<Oddball> NewSelfReferenceMarker();
 
-  // Allocates a fixed array-like object with given map and initialized with
-  // undefined values.
-  Handle<FixedArray> NewFixedArrayWithMapRootIndex(
-      RootIndex map_root_index, int length,
-      AllocationType allocation = AllocationType::kYoung);
-
   // Allocates a property array initialized with undefined values.
   Handle<PropertyArray> NewPropertyArray(int length);
   // Tries allocating a fixed array initialized with undefined values.

src/objects/dictionary-inl.h

@@ -179,8 +179,8 @@ Object GlobalDictionaryShape::Unwrap(Object object) {
   return PropertyCell::cast(object).name();
 }
 
-RootIndex GlobalDictionaryShape::GetMapRootIndex() {
-  return RootIndex::kGlobalDictionaryMap;
+Handle<Map> GlobalDictionaryShape::GetMap(ReadOnlyRoots roots) {
+  return roots.global_dictionary_map_handle();
 }
 
 Name NameDictionary::NameAt(InternalIndex entry) {
@@ -192,8 +192,8 @@ Name NameDictionary::NameAt(const Isolate* isolate, InternalIndex entry) {
   return Name::cast(KeyAt(isolate, entry));
 }
 
-RootIndex NameDictionaryShape::GetMapRootIndex() {
-  return RootIndex::kNameDictionaryMap;
+Handle<Map> NameDictionaryShape::GetMap(ReadOnlyRoots roots) {
+  return roots.name_dictionary_map_handle();
 }
 
 PropertyCell GlobalDictionary::CellAt(InternalIndex entry) {
@@ -267,12 +267,12 @@ Handle<Object> NumberDictionaryBaseShape::AsHandle(Isolate* isolate,
   return isolate->factory()->NewNumberFromUint(key);
 }
 
-RootIndex NumberDictionaryShape::GetMapRootIndex() {
-  return RootIndex::kNumberDictionaryMap;
+Handle<Map> NumberDictionaryShape::GetMap(ReadOnlyRoots roots) {
+  return roots.number_dictionary_map_handle();
 }
 
-RootIndex SimpleNumberDictionaryShape::GetMapRootIndex() {
-  return RootIndex::kSimpleNumberDictionaryMap;
+Handle<Map> SimpleNumberDictionaryShape::GetMap(ReadOnlyRoots roots) {
+  return roots.simple_number_dictionary_map_handle();
 }
 
 bool NameDictionaryShape::IsMatch(Handle<Name> key, Object other) {

src/objects/dictionary.h

@@ -112,7 +112,7 @@ class NameDictionaryShape : public BaseDictionaryShape<Handle<Name>> {
   static inline uint32_t Hash(Isolate* isolate, Handle<Name> key);
   static inline uint32_t HashForObject(ReadOnlyRoots roots, Object object);
   static inline Handle<Object> AsHandle(Isolate* isolate, Handle<Name> key);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static const int kPrefixSize = 2;
   static const int kEntrySize = 3;
   static const int kEntryValueIndex = 1;
@@ -218,7 +218,7 @@ class V8_EXPORT_PRIVATE GlobalDictionaryShape : public NameDictionaryShape {
   static inline Object Unwrap(Object key);
   static inline bool IsKey(ReadOnlyRoots roots, Object k);
   static inline bool IsLive(ReadOnlyRoots roots, Object key);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
 };
 
 EXTERN_DECLARE_BASE_NAME_DICTIONARY(GlobalDictionary, GlobalDictionaryShape)
@@ -257,7 +257,7 @@ class NumberDictionaryShape : public NumberDictionaryBaseShape {
   static const int kPrefixSize = 1;
   static const int kEntrySize = 3;
 
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
 };
 
 class SimpleNumberDictionaryShape : public NumberDictionaryBaseShape {
@@ -278,7 +278,7 @@ class SimpleNumberDictionaryShape : public NumberDictionaryBaseShape {
     UNREACHABLE();
   }
 
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
 };
 
 EXTERN_DECLARE_DICTIONARY(SimpleNumberDictionary, SimpleNumberDictionaryShape)

src/objects/hash-table-inl.h

@@ -123,12 +123,12 @@ void HashTableBase::SetNumberOfDeletedElements(int nod) {
 }
 
 template <typename Key>
-RootIndex BaseShape<Key>::GetMapRootIndex() {
-  return RootIndex::kHashTableMap;
+Handle<Map> BaseShape<Key>::GetMap(ReadOnlyRoots roots) {
+  return roots.hash_table_map_handle();
 }
 
-RootIndex EphemeronHashTableShape::GetMapRootIndex() {
-  return RootIndex::kEphemeronHashTableMap;
+Handle<Map> EphemeronHashTableShape::GetMap(ReadOnlyRoots roots) {
+  return roots.ephemeron_hash_table_map_handle();
 }
 
 template <typename Derived, typename Shape>

src/objects/hash-table.h

@@ -60,7 +60,7 @@ template <typename KeyT>
 class V8_EXPORT_PRIVATE BaseShape {
  public:
   using Key = KeyT;
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static const bool kNeedsHoleCheck = true;
   static Object Unwrap(Object key) { return key; }
   static inline bool IsKey(ReadOnlyRoots roots, Object key);
@@ -347,7 +347,7 @@ class V8_EXPORT_PRIVATE ObjectHashTable
 
 class EphemeronHashTableShape : public ObjectHashTableShape {
  public:
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
 };
 
 EXTERN_DECLARE_OBJECT_BASE_HASH_TABLE(EphemeronHashTable,

src/objects/objects.cc

@@ -6545,9 +6545,8 @@ Handle<Derived> HashTable<Derived, Shape>::NewInternal(
     Isolate* isolate, int capacity, AllocationType allocation) {
   Factory* factory = isolate->factory();
   int length = EntryToIndex(InternalIndex(capacity));
-  RootIndex map_root_index = Shape::GetMapRootIndex();
-  Handle<FixedArray> array = factory->NewFixedArrayWithMapRootIndex(
-      map_root_index, length, allocation);
+  Handle<FixedArray> array = factory->NewFixedArrayWithMap(
+      Shape::GetMap(ReadOnlyRoots(isolate)), length, allocation);
   Handle<Derived> table = Handle<Derived>::cast(array);
 
   table->SetNumberOfElements(0);

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

@@ -73,28 +73,28 @@ OBJECT_CONSTRUCTORS_IMPL(SmallOrderedHashMap,
 OBJECT_CONSTRUCTORS_IMPL(SmallOrderedNameDictionary,
                          SmallOrderedHashTable<SmallOrderedNameDictionary>)
 
-RootIndex OrderedHashSet::GetMapRootIndex() {
-  return RootIndex::kOrderedHashSetMap;
+Handle<Map> OrderedHashSet::GetMap(ReadOnlyRoots roots) {
+  return roots.ordered_hash_set_map_handle();
 }
 
-RootIndex OrderedHashMap::GetMapRootIndex() {
-  return RootIndex::kOrderedHashMapMap;
+Handle<Map> OrderedHashMap::GetMap(ReadOnlyRoots roots) {
+  return roots.ordered_hash_map_map_handle();
 }
 
-RootIndex OrderedNameDictionary::GetMapRootIndex() {
-  return RootIndex::kOrderedNameDictionaryMap;
+Handle<Map> OrderedNameDictionary::GetMap(ReadOnlyRoots roots) {
+  return roots.ordered_name_dictionary_map_handle();
 }
 
-RootIndex SmallOrderedNameDictionary::GetMapRootIndex() {
-  return RootIndex::kSmallOrderedNameDictionaryMap;
+Handle<Map> SmallOrderedNameDictionary::GetMap(ReadOnlyRoots roots) {
+  return roots.small_ordered_name_dictionary_map_handle();
 }
 
-RootIndex SmallOrderedHashMap::GetMapRootIndex() {
-  return RootIndex::kSmallOrderedHashMapMap;
+Handle<Map> SmallOrderedHashMap::GetMap(ReadOnlyRoots roots) {
+  return roots.small_ordered_hash_map_map_handle();
 }
 
-RootIndex SmallOrderedHashSet::GetMapRootIndex() {
-  return RootIndex::kSmallOrderedHashSetMap;
+Handle<Map> SmallOrderedHashSet::GetMap(ReadOnlyRoots roots) {
+  return roots.small_ordered_hash_set_map_handle();
 }
 
 inline Object OrderedHashMap::ValueAt(int entry) {

src/objects/ordered-hash-table.cc

@@ -9,6 +9,7 @@
 #include "src/objects/js-collection-inl.h"
 #include "src/objects/objects-inl.h"
 #include "src/objects/ordered-hash-table-inl.h"
+#include "src/roots/roots.h"
 
 namespace v8 {
 namespace internal {
@@ -26,11 +27,10 @@ MaybeHandle<Derived> OrderedHashTable<Derived, entrysize>::Allocate(
     return MaybeHandle<Derived>();
   }
   int num_buckets = capacity / kLoadFactor;
-  Handle<FixedArray> backing_store =
-      isolate->factory()->NewFixedArrayWithMapRootIndex(
-          Derived::GetMapRootIndex(),
-          HashTableStartIndex() + num_buckets + (capacity * kEntrySize),
-          allocation);
+  Handle<FixedArray> backing_store = isolate->factory()->NewFixedArrayWithMap(
+      Derived::GetMap(ReadOnlyRoots(isolate)),
+      HashTableStartIndex() + num_buckets + (capacity * kEntrySize),
+      allocation);
   Handle<Derived> table = Handle<Derived>::cast(backing_store);
   for (int i = 0; i < num_buckets; ++i) {
     table->set(HashTableStartIndex() + i, Smi::FromInt(kNotFound));

src/objects/ordered-hash-table.h

@@ -248,7 +248,7 @@ class V8_EXPORT_PRIVATE OrderedHashSet
       Isolate* isolate, int capacity,
       AllocationType allocation = AllocationType::kYoung);
   static HeapObject GetEmpty(ReadOnlyRoots ro_roots);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static inline bool Is(Handle<HeapObject> table);
   static const int kPrefixSize = 0;
 
@@ -280,7 +280,7 @@ class V8_EXPORT_PRIVATE OrderedHashMap
   static Address GetHash(Isolate* isolate, Address raw_key);
 
   static HeapObject GetEmpty(ReadOnlyRoots ro_roots);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static inline bool Is(Handle<HeapObject> table);
 
   static const int kValueOffset = 1;
@@ -602,7 +602,7 @@ class SmallOrderedHashSet : public SmallOrderedHashTable<SmallOrderedHashSet> {
   V8_EXPORT_PRIVATE bool HasKey(Isolate* isolate, Handle<Object> key);
 
   static inline bool Is(Handle<HeapObject> table);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static Handle<SmallOrderedHashSet> Rehash(Isolate* isolate,
                                             Handle<SmallOrderedHashSet> table,
                                             int new_capacity);
@@ -635,7 +635,7 @@ class SmallOrderedHashMap : public SmallOrderedHashTable<SmallOrderedHashMap> {
                                        SmallOrderedHashMap table, Object key);
   V8_EXPORT_PRIVATE bool HasKey(Isolate* isolate, Handle<Object> key);
   static inline bool Is(Handle<HeapObject> table);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
 
   static Handle<SmallOrderedHashMap> Rehash(Isolate* isolate,
                                             Handle<SmallOrderedHashMap> table,
@@ -730,7 +730,7 @@ class OrderedNameDictionary
   inline int Hash();
 
   static HeapObject GetEmpty(ReadOnlyRoots ro_roots);
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static inline bool Is(Handle<HeapObject> table);
 
   static const int kValueOffset = 1;
@@ -832,7 +832,7 @@ class SmallOrderedNameDictionary
   V8_EXPORT_PRIVATE void SetEntry(Isolate* isolate, int entry, Object key,
                                   Object value, PropertyDetails details);
 
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
   static inline bool Is(Handle<HeapObject> table);
 
   OBJECT_CONSTRUCTORS(SmallOrderedNameDictionary,

src/objects/string-table-inl.h

@@ -72,8 +72,8 @@ uint32_t StringTableShape::HashForObject(ReadOnlyRoots roots, Object object) {
   return String::cast(object).Hash();
 }
 
-RootIndex StringTableShape::GetMapRootIndex() {
-  return RootIndex::kStringTableMap;
+Handle<Map> StringTableShape::GetMap(ReadOnlyRoots roots) {
+  return roots.string_table_map_handle();
 }
 
 }  // namespace internal

src/objects/string-table.h

@@ -47,7 +47,7 @@ class V8_EXPORT_PRIVATE StringTableShape : public BaseShape<StringTableKey*> {
 
   static inline Handle<Object> AsHandle(Isolate* isolate, Key key);
 
-  static inline RootIndex GetMapRootIndex();
+  static inline Handle<Map> GetMap(ReadOnlyRoots roots);
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 1;