1 // Copyright 2018 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_OBJECTS_ORDERED_HASH_TABLE_INL_H_
6 #define V8_OBJECTS_ORDERED_HASH_TABLE_INL_H_
7
8 #include "src/objects/ordered-hash-table.h"
9
10 #include "src/heap/heap.h"
11 #include "src/objects/compressed-slots.h"
12 #include "src/objects/fixed-array-inl.h"
13 #include "src/objects/js-collection-iterator.h"
14 #include "src/objects/objects-inl.h"
15 #include "src/objects/slots.h"
16
17 // Has to be the last include (doesn't have include guards):
18 #include "src/objects/object-macros.h"
19
20 namespace v8 {
21 namespace internal {
22
23 #include "torque-generated/src/objects/ordered-hash-table-tq-inl.inc"
24
25 CAST_ACCESSOR(OrderedNameDictionary)
CAST_ACCESSOR(SmallOrderedNameDictionary)26 CAST_ACCESSOR(SmallOrderedNameDictionary)
27 CAST_ACCESSOR(OrderedHashMap)
28 CAST_ACCESSOR(OrderedHashSet)
29 CAST_ACCESSOR(SmallOrderedHashMap)
30 CAST_ACCESSOR(SmallOrderedHashSet)
31
32 template <class Derived, int entrysize>
33 OrderedHashTable<Derived, entrysize>::OrderedHashTable(Address ptr)
34 : FixedArray(ptr) {}
35
36 template <class Derived, int entrysize>
IsKey(ReadOnlyRoots roots,Object k)37 bool OrderedHashTable<Derived, entrysize>::IsKey(ReadOnlyRoots roots,
38 Object k) {
39 return k != roots.the_hole_value();
40 }
41
OrderedHashSet(Address ptr)42 OrderedHashSet::OrderedHashSet(Address ptr)
43 : OrderedHashTable<OrderedHashSet, 1>(ptr) {
44 SLOW_DCHECK(IsOrderedHashSet());
45 }
46
OrderedHashMap(Address ptr)47 OrderedHashMap::OrderedHashMap(Address ptr)
48 : OrderedHashTable<OrderedHashMap, 2>(ptr) {
49 SLOW_DCHECK(IsOrderedHashMap());
50 }
51
OrderedNameDictionary(Address ptr)52 OrderedNameDictionary::OrderedNameDictionary(Address ptr)
53 : OrderedHashTable<OrderedNameDictionary, 3>(ptr) {
54 SLOW_DCHECK(IsOrderedNameDictionary());
55 }
56
57 template <class Derived>
SmallOrderedHashTable(Address ptr)58 SmallOrderedHashTable<Derived>::SmallOrderedHashTable(Address ptr)
59 : HeapObject(ptr) {}
60
61 template <class Derived>
KeyAt(InternalIndex entry)62 Object SmallOrderedHashTable<Derived>::KeyAt(InternalIndex entry) const {
63 DCHECK_LT(entry.as_int(), Capacity());
64 Offset entry_offset = GetDataEntryOffset(entry.as_int(), Derived::kKeyIndex);
65 return TaggedField<Object>::load(*this, entry_offset);
66 }
67
68 template <class Derived>
GetDataEntry(int entry,int relative_index)69 Object SmallOrderedHashTable<Derived>::GetDataEntry(int entry,
70 int relative_index) {
71 DCHECK_LT(entry, Capacity());
72 DCHECK_LE(static_cast<unsigned>(relative_index), Derived::kEntrySize);
73 Offset entry_offset = GetDataEntryOffset(entry, relative_index);
74 return TaggedField<Object>::load(*this, entry_offset);
75 }
76
OBJECT_CONSTRUCTORS_IMPL(SmallOrderedHashSet,SmallOrderedHashTable<SmallOrderedHashSet>)77 OBJECT_CONSTRUCTORS_IMPL(SmallOrderedHashSet,
78 SmallOrderedHashTable<SmallOrderedHashSet>)
79 OBJECT_CONSTRUCTORS_IMPL(SmallOrderedHashMap,
80 SmallOrderedHashTable<SmallOrderedHashMap>)
81 OBJECT_CONSTRUCTORS_IMPL(SmallOrderedNameDictionary,
82 SmallOrderedHashTable<SmallOrderedNameDictionary>)
83
84 Handle<Map> OrderedHashSet::GetMap(ReadOnlyRoots roots) {
85 return roots.ordered_hash_set_map_handle();
86 }
87
GetMap(ReadOnlyRoots roots)88 Handle<Map> OrderedHashMap::GetMap(ReadOnlyRoots roots) {
89 return roots.ordered_hash_map_map_handle();
90 }
91
GetMap(ReadOnlyRoots roots)92 Handle<Map> OrderedNameDictionary::GetMap(ReadOnlyRoots roots) {
93 return roots.ordered_name_dictionary_map_handle();
94 }
95
GetMap(ReadOnlyRoots roots)96 Handle<Map> SmallOrderedNameDictionary::GetMap(ReadOnlyRoots roots) {
97 return roots.small_ordered_name_dictionary_map_handle();
98 }
99
GetMap(ReadOnlyRoots roots)100 Handle<Map> SmallOrderedHashMap::GetMap(ReadOnlyRoots roots) {
101 return roots.small_ordered_hash_map_map_handle();
102 }
103
GetMap(ReadOnlyRoots roots)104 Handle<Map> SmallOrderedHashSet::GetMap(ReadOnlyRoots roots) {
105 return roots.small_ordered_hash_set_map_handle();
106 }
107
ValueAt(InternalIndex entry)108 inline Object OrderedHashMap::ValueAt(InternalIndex entry) {
109 DCHECK_LT(entry.as_int(), UsedCapacity());
110 return get(EntryToIndex(entry) + kValueOffset);
111 }
112
ValueAt(InternalIndex entry)113 inline Object OrderedNameDictionary::ValueAt(InternalIndex entry) {
114 DCHECK_LT(entry.as_int(), UsedCapacity());
115 return get(EntryToIndex(entry) + kValueOffset);
116 }
117
NameAt(InternalIndex entry)118 Name OrderedNameDictionary::NameAt(InternalIndex entry) {
119 return Name::cast(KeyAt(entry));
120 }
121
122 // Parameter |roots| only here for compatibility with HashTable<...>::ToKey.
123 template <class Derived, int entrysize>
ToKey(ReadOnlyRoots roots,InternalIndex entry,Object * out_key)124 bool OrderedHashTable<Derived, entrysize>::ToKey(ReadOnlyRoots roots,
125 InternalIndex entry,
126 Object* out_key) {
127 Object k = KeyAt(entry);
128 if (!IsKey(roots, k)) return false;
129 *out_key = k;
130 return true;
131 }
132
133 // Set the value for entry.
ValueAtPut(InternalIndex entry,Object value)134 inline void OrderedNameDictionary::ValueAtPut(InternalIndex entry,
135 Object value) {
136 DCHECK_LT(entry.as_int(), UsedCapacity());
137 this->set(EntryToIndex(entry) + kValueOffset, value);
138 }
139
140 // Returns the property details for the property at entry.
DetailsAt(InternalIndex entry)141 inline PropertyDetails OrderedNameDictionary::DetailsAt(InternalIndex entry) {
142 DCHECK_LT(entry.as_int(), this->UsedCapacity());
143 // TODO(gsathya): Optimize the cast away.
144 return PropertyDetails(
145 Smi::cast(get(EntryToIndex(entry) + kPropertyDetailsOffset)));
146 }
147
DetailsAtPut(InternalIndex entry,PropertyDetails value)148 inline void OrderedNameDictionary::DetailsAtPut(InternalIndex entry,
149 PropertyDetails value) {
150 DCHECK_LT(entry.as_int(), this->UsedCapacity());
151 // TODO(gsathya): Optimize the cast away.
152 this->set(EntryToIndex(entry) + kPropertyDetailsOffset, value.AsSmi());
153 }
154
ValueAt(InternalIndex entry)155 inline Object SmallOrderedNameDictionary::ValueAt(InternalIndex entry) {
156 return this->GetDataEntry(entry.as_int(), kValueIndex);
157 }
158
159 // Set the value for entry.
ValueAtPut(InternalIndex entry,Object value)160 inline void SmallOrderedNameDictionary::ValueAtPut(InternalIndex entry,
161 Object value) {
162 this->SetDataEntry(entry.as_int(), kValueIndex, value);
163 }
164
165 // Returns the property details for the property at entry.
DetailsAt(InternalIndex entry)166 inline PropertyDetails SmallOrderedNameDictionary::DetailsAt(
167 InternalIndex entry) {
168 // TODO(gsathya): Optimize the cast away. And store this in the data table.
169 return PropertyDetails(
170 Smi::cast(this->GetDataEntry(entry.as_int(), kPropertyDetailsIndex)));
171 }
172
173 // Set the details for entry.
DetailsAtPut(InternalIndex entry,PropertyDetails value)174 inline void SmallOrderedNameDictionary::DetailsAtPut(InternalIndex entry,
175 PropertyDetails value) {
176 // TODO(gsathya): Optimize the cast away. And store this in the data table.
177 this->SetDataEntry(entry.as_int(), kPropertyDetailsIndex, value.AsSmi());
178 }
179
Is(Handle<HeapObject> table)180 inline bool OrderedHashSet::Is(Handle<HeapObject> table) {
181 return table->IsOrderedHashSet();
182 }
183
Is(Handle<HeapObject> table)184 inline bool OrderedHashMap::Is(Handle<HeapObject> table) {
185 return table->IsOrderedHashMap();
186 }
187
Is(Handle<HeapObject> table)188 inline bool OrderedNameDictionary::Is(Handle<HeapObject> table) {
189 return table->IsOrderedNameDictionary();
190 }
191
Is(Handle<HeapObject> table)192 inline bool SmallOrderedHashSet::Is(Handle<HeapObject> table) {
193 return table->IsSmallOrderedHashSet();
194 }
195
Is(Handle<HeapObject> table)196 inline bool SmallOrderedNameDictionary::Is(Handle<HeapObject> table) {
197 return table->IsSmallOrderedNameDictionary();
198 }
199
Is(Handle<HeapObject> table)200 inline bool SmallOrderedHashMap::Is(Handle<HeapObject> table) {
201 return table->IsSmallOrderedHashMap();
202 }
203
204 template <class Derived>
SetDataEntry(int entry,int relative_index,Object value)205 void SmallOrderedHashTable<Derived>::SetDataEntry(int entry, int relative_index,
206 Object value) {
207 DCHECK_NE(kNotFound, entry);
208 int entry_offset = GetDataEntryOffset(entry, relative_index);
209 RELAXED_WRITE_FIELD(*this, entry_offset, value);
210 WRITE_BARRIER(*this, entry_offset, value);
211 }
212
213 template <class Derived, class TableType>
CurrentKey()214 Object OrderedHashTableIterator<Derived, TableType>::CurrentKey() {
215 TableType table = TableType::cast(this->table());
216 int index = Smi::ToInt(this->index());
217 DCHECK_LE(0, index);
218 InternalIndex entry(index);
219 Object key = table.KeyAt(entry);
220 DCHECK(!key.IsTheHole());
221 return key;
222 }
223
SetHash(int hash)224 inline void SmallOrderedNameDictionary::SetHash(int hash) {
225 DCHECK(PropertyArray::HashField::is_valid(hash));
226 WriteField<int>(PrefixOffset(), hash);
227 }
228
Hash()229 inline int SmallOrderedNameDictionary::Hash() {
230 int hash = ReadField<int>(PrefixOffset());
231 DCHECK(PropertyArray::HashField::is_valid(hash));
232 return hash;
233 }
234
SetHash(int hash)235 inline void OrderedNameDictionary::SetHash(int hash) {
236 DCHECK(PropertyArray::HashField::is_valid(hash));
237 this->set(HashIndex(), Smi::FromInt(hash));
238 }
239
Hash()240 inline int OrderedNameDictionary::Hash() {
241 Object hash_obj = this->get(HashIndex());
242 int hash = Smi::ToInt(hash_obj);
243 DCHECK(PropertyArray::HashField::is_valid(hash));
244 return hash;
245 }
246
247 } // namespace internal
248 } // namespace v8
249
250 #include "src/objects/object-macros-undef.h"
251
252 #endif // V8_OBJECTS_ORDERED_HASH_TABLE_INL_H_
253