deps: update V8 to 7.3.492.25

PR-URL: https://github.com/nodejs/node/pull/25852
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>

1 files changed, 148 insertions, 2 deletions

diff --git a/deps/v8/src/objects/ordered-hash-table-inl.h b/deps/v8/src/objects/ordered-hash-table-inl.h
index 76343c21ed..277c033994 100644
--- a/deps/v8/src/objects/ordered-hash-table-inl.h
+++ b/deps/v8/src/objects/ordered-hash-table-inl.h
@@ -10,9 +10,49 @@
 #include "src/heap/heap.h"
 #include "src/objects/fixed-array-inl.h"
 
+// Has to be the last include (doesn't have include guards):
+#include "src/objects/object-macros.h"
+
 namespace v8 {
 namespace internal {
 
+CAST_ACCESSOR(OrderedNameDictionary)
+CAST_ACCESSOR(SmallOrderedNameDictionary)
+CAST_ACCESSOR(OrderedHashMap)
+CAST_ACCESSOR(OrderedHashSet)
+CAST_ACCESSOR(SmallOrderedHashMap)
+CAST_ACCESSOR(SmallOrderedHashSet)
+
+template <class Derived, int entrysize>
+OrderedHashTable<Derived, entrysize>::OrderedHashTable(Address ptr)
+    : FixedArray(ptr) {}
+
+OrderedHashSet::OrderedHashSet(Address ptr)
+    : OrderedHashTable<OrderedHashSet, 1>(ptr) {
+  SLOW_DCHECK(IsOrderedHashSet());
+}
+
+OrderedHashMap::OrderedHashMap(Address ptr)
+    : OrderedHashTable<OrderedHashMap, 2>(ptr) {
+  SLOW_DCHECK(IsOrderedHashMap());
+}
+
+OrderedNameDictionary::OrderedNameDictionary(Address ptr)
+    : OrderedHashTable<OrderedNameDictionary, 3>(ptr) {
+  SLOW_DCHECK(IsOrderedNameDictionary());
+}
+
+template <class Derived>
+SmallOrderedHashTable<Derived>::SmallOrderedHashTable(Address ptr)
+    : HeapObject(ptr) {}
+
+OBJECT_CONSTRUCTORS_IMPL(SmallOrderedHashSet,
+                         SmallOrderedHashTable<SmallOrderedHashSet>)
+OBJECT_CONSTRUCTORS_IMPL(SmallOrderedHashMap,
+                         SmallOrderedHashTable<SmallOrderedHashMap>)
+OBJECT_CONSTRUCTORS_IMPL(SmallOrderedNameDictionary,
+                         SmallOrderedHashTable<SmallOrderedNameDictionary>)
+
 RootIndex OrderedHashSet::GetMapRootIndex() {
   return RootIndex::kOrderedHashSetMap;
 }
@@ -21,6 +61,14 @@ RootIndex OrderedHashMap::GetMapRootIndex() {
   return RootIndex::kOrderedHashMapMap;
 }
 
+RootIndex OrderedNameDictionary::GetMapRootIndex() {
+  return RootIndex::kOrderedNameDictionaryMap;
+}
+
+RootIndex SmallOrderedNameDictionary::GetMapRootIndex() {
+  return RootIndex::kSmallOrderedNameDictionaryMap;
+}
+
 RootIndex SmallOrderedHashMap::GetMapRootIndex() {
   return RootIndex::kSmallOrderedHashMapMap;
 }
@@ -29,11 +77,65 @@ RootIndex SmallOrderedHashSet::GetMapRootIndex() {
   return RootIndex::kSmallOrderedHashSetMap;
 }
 
-inline Object* OrderedHashMap::ValueAt(int entry) {
-  DCHECK_LT(entry, this->UsedCapacity());
+inline Object OrderedHashMap::ValueAt(int entry) {
+  DCHECK_NE(entry, kNotFound);
+  DCHECK_LT(entry, UsedCapacity());
+  return get(EntryToIndex(entry) + kValueOffset);
+}
+
+inline Object OrderedNameDictionary::ValueAt(int entry) {
+  DCHECK_NE(entry, kNotFound);
+  DCHECK_LT(entry, UsedCapacity());
   return get(EntryToIndex(entry) + kValueOffset);
 }
 
+// Set the value for entry.
+inline void OrderedNameDictionary::ValueAtPut(int entry, Object value) {
+  DCHECK_NE(entry, kNotFound);
+  DCHECK_LT(entry, UsedCapacity());
+  this->set(EntryToIndex(entry) + kValueOffset, value);
+}
+
+// Returns the property details for the property at entry.
+inline PropertyDetails OrderedNameDictionary::DetailsAt(int entry) {
+  DCHECK_NE(entry, kNotFound);
+  DCHECK_LT(entry, this->UsedCapacity());
+  // TODO(gsathya): Optimize the cast away.
+  return PropertyDetails(
+      Smi::cast(get(EntryToIndex(entry) + kPropertyDetailsOffset)));
+}
+
+inline void OrderedNameDictionary::DetailsAtPut(int entry,
+                                                PropertyDetails value) {
+  DCHECK_NE(entry, kNotFound);
+  DCHECK_LT(entry, this->UsedCapacity());
+  // TODO(gsathya): Optimize the cast away.
+  this->set(EntryToIndex(entry) + kPropertyDetailsOffset, value.AsSmi());
+}
+
+inline Object SmallOrderedNameDictionary::ValueAt(int entry) {
+  return this->GetDataEntry(entry, kValueIndex);
+}
+
+// Set the value for entry.
+inline void SmallOrderedNameDictionary::ValueAtPut(int entry, Object value) {
+  this->SetDataEntry(entry, kValueIndex, value);
+}
+
+// Returns the property details for the property at entry.
+inline PropertyDetails SmallOrderedNameDictionary::DetailsAt(int entry) {
+  // TODO(gsathya): Optimize the cast away. And store this in the data table.
+  return PropertyDetails(
+      Smi::cast(this->GetDataEntry(entry, kPropertyDetailsIndex)));
+}
+
+// Set the details for entry.
+inline void SmallOrderedNameDictionary::DetailsAtPut(int entry,
+                                                     PropertyDetails value) {
+  // TODO(gsathya): Optimize the cast away. And store this in the data table.
+  this->SetDataEntry(entry, kPropertyDetailsIndex, value.AsSmi());
+}
+
 inline bool OrderedHashSet::Is(Handle<HeapObject> table) {
   return table->IsOrderedHashSet();
 }
@@ -49,7 +151,51 @@ inline bool SmallOrderedHashSet::Is(Handle<HeapObject> table) {
 inline bool SmallOrderedHashMap::Is(Handle<HeapObject> table) {
   return table->IsSmallOrderedHashMap();
 }
+
+template <class Derived>
+void SmallOrderedHashTable<Derived>::SetDataEntry(int entry, int relative_index,
+                                                  Object value) {
+  DCHECK_NE(kNotFound, entry);
+  int entry_offset = GetDataEntryOffset(entry, relative_index);
+  RELAXED_WRITE_FIELD(*this, entry_offset, value);
+  WRITE_BARRIER(*this, entry_offset, value);
+}
+
+template <class Derived, class TableType>
+Object OrderedHashTableIterator<Derived, TableType>::CurrentKey() {
+  TableType table = TableType::cast(this->table());
+  int index = Smi::ToInt(this->index());
+  Object key = table->KeyAt(index);
+  DCHECK(!key->IsTheHole());
+  return key;
+}
+
+inline void SmallOrderedNameDictionary::SetHash(int hash) {
+  DCHECK(PropertyArray::HashField::is_valid(hash));
+  WRITE_INT_FIELD(*this, PrefixOffset(), hash);
+}
+
+inline int SmallOrderedNameDictionary::Hash() {
+  int hash = READ_INT_FIELD(*this, PrefixOffset());
+  DCHECK(PropertyArray::HashField::is_valid(hash));
+  return hash;
+}
+
+inline void OrderedNameDictionary::SetHash(int hash) {
+  DCHECK(PropertyArray::HashField::is_valid(hash));
+  this->set(PrefixIndex(), Smi::FromInt(hash));
+}
+
+inline int OrderedNameDictionary::Hash() {
+  Object hash_obj = this->get(PrefixIndex());
+  int hash = Smi::ToInt(hash_obj);
+  DCHECK(PropertyArray::HashField::is_valid(hash));
+  return hash;
+}
+
 }  // namespace internal
 }  // namespace v8
 
+#include "src/objects/object-macros-undef.h"
+
 #endif  // V8_OBJECTS_ORDERED_HASH_TABLE_INL_H_