AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[dict-proto] make small ordered hash tables use InternalIndex, too

Browse Source 
This CL changes the "small" versions of ordered hash tables, like
SmallOrderedNameDictionary and the corresponding handlers, like
OrderedNameDictionaryHandler, to use InternalIndex rather than int
as the type used for indices.

This is part of an effort to make the interfaces of the
ordered and unordered name dictionaries more similar.

Bug: v8:7569
Change-Id: I3b6fe79dfd3c6743f58a04cfe82798fe2ef09e19
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2505720
Commit-Queue: Frank Emrich <emrich@google.com>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#70876}
This commit is contained in:
Frank Emrich 2020-10-29 10:33:30 +00:00 committed by Commit Bot
parent 5d51713179
commit eeb74f09c1
4 changed files with 142 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/objects/ordered-hash-table-inl.h
View File

@ -51,9 +51,9 @@ SmallOrderedHashTable<Derived>::SmallOrderedHashTable(Address ptr)
: HeapObject(ptr) {}
template <class Derived>
Object SmallOrderedHashTable<Derived>::KeyAt(int entry) const {
DCHECK_LT(entry, Capacity());
Offset entry_offset = GetDataEntryOffset(entry, Derived::kKeyIndex);
Object SmallOrderedHashTable<Derived>::KeyAt(InternalIndex entry) const {
DCHECK_LT(entry.as_int(), Capacity());
Offset entry_offset = GetDataEntryOffset(entry.as_int(), Derived::kKeyIndex);
return TaggedField<Object>::load(*this, entry_offset);
}
@ -129,27 +129,29 @@ inline void OrderedNameDictionary::DetailsAtPut(InternalIndex entry,
this->set(EntryToIndex(entry) + kPropertyDetailsOffset, value.AsSmi());
}
inline Object SmallOrderedNameDictionary::ValueAt(int entry) {
return this->GetDataEntry(entry, kValueIndex);
inline Object SmallOrderedNameDictionary::ValueAt(InternalIndex entry) {
return this->GetDataEntry(entry.as_int(), kValueIndex);
}
// Set the value for entry.
inline void SmallOrderedNameDictionary::ValueAtPut(int entry, Object value) {
this->SetDataEntry(entry, kValueIndex, value);
inline void SmallOrderedNameDictionary::ValueAtPut(InternalIndex entry,
Object value) {
this->SetDataEntry(entry.as_int(), kValueIndex, value);
}
// Returns the property details for the property at entry.
inline PropertyDetails SmallOrderedNameDictionary::DetailsAt(int entry) {
inline PropertyDetails SmallOrderedNameDictionary::DetailsAt(
InternalIndex entry) {
// TODO(gsathya): Optimize the cast away. And store this in the data table.
return PropertyDetails(
Smi::cast(this->GetDataEntry(entry, kPropertyDetailsIndex)));
Smi::cast(this->GetDataEntry(entry.as_int(), kPropertyDetailsIndex)));
}
// Set the details for entry.
inline void SmallOrderedNameDictionary::DetailsAtPut(int entry,
inline void SmallOrderedNameDictionary::DetailsAtPut(InternalIndex entry,
PropertyDetails value) {
// TODO(gsathya): Optimize the cast away. And store this in the data table.
this->SetDataEntry(entry, kPropertyDetailsIndex, value.AsSmi());
this->SetDataEntry(entry.as_int(), kPropertyDetailsIndex, value.AsSmi());
}
inline bool OrderedHashSet::Is(Handle<HeapObject> table) {

118
src/objects/ordered-hash-table.cc
View File

@ -746,29 +746,30 @@ bool SmallOrderedHashMap::HasKey(Isolate* isolate, Handle<Object> key) {
}
template <>
int V8_EXPORT_PRIVATE
InternalIndex V8_EXPORT_PRIVATE
SmallOrderedHashTable<SmallOrderedNameDictionary>::FindEntry(Isolate* isolate,
Object key) {
DisallowHeapAllocation no_gc;
DCHECK(key.IsUniqueName());
Name raw_key = Name::cast(key);
int entry = HashToFirstEntry(raw_key.Hash());
int raw_entry = HashToFirstEntry(raw_key.Hash());
// Walk the chain in the bucket to find the key.
while (entry != kNotFound) {
while (raw_entry != kNotFound) {
InternalIndex entry(raw_entry);
Object candidate_key = KeyAt(entry);
if (candidate_key == key) return entry;
entry = GetNextEntry(entry);
raw_entry = GetNextEntry(raw_entry);
}
return kNotFound;
return InternalIndex::NotFound();
}
MaybeHandle<SmallOrderedNameDictionary> SmallOrderedNameDictionary::Add(
Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
Handle<Name> key, Handle<Object> value, PropertyDetails details) {
DCHECK_EQ(kNotFound, table->FindEntry(isolate, *key));
DCHECK(table->FindEntry(isolate, *key).is_not_found());
if (table->UsedCapacity() >= table->Capacity()) {
MaybeHandle<SmallOrderedNameDictionary> new_table =
@ -806,15 +807,17 @@ MaybeHandle<SmallOrderedNameDictionary> SmallOrderedNameDictionary::Add(
return table;
}
void SmallOrderedNameDictionary::SetEntry(int entry, Object key, Object value,
void SmallOrderedNameDictionary::SetEntry(InternalIndex entry, Object key,
Object value,
PropertyDetails details) {
int raw_entry = entry.as_int();
DCHECK_IMPLIES(!key.IsName(), key.IsTheHole());
SetDataEntry(entry, SmallOrderedNameDictionary::kValueIndex, value);
SetDataEntry(entry, SmallOrderedNameDictionary::kKeyIndex, key);
SetDataEntry(raw_entry, SmallOrderedNameDictionary::kValueIndex, value);
SetDataEntry(raw_entry, SmallOrderedNameDictionary::kKeyIndex, key);
// TODO(gsathya): PropertyDetails should be stored as part of the
// data table to save more memory.
SetDataEntry(entry, SmallOrderedNameDictionary::kPropertyDetailsIndex,
SetDataEntry(raw_entry, SmallOrderedNameDictionary::kPropertyDetailsIndex,
details.AsSmi());
}
@ -822,22 +825,22 @@ template <class Derived>
bool SmallOrderedHashTable<Derived>::HasKey(Isolate* isolate,
Handle<Object> key) {
DisallowHeapAllocation no_gc;
return FindEntry(isolate, *key) != kNotFound;
return FindEntry(isolate, *key).is_found();
}
template <class Derived>
bool SmallOrderedHashTable<Derived>::Delete(Isolate* isolate, Derived table,
Object key) {
DisallowHeapAllocation no_gc;
int entry = table.FindEntry(isolate, key);
if (entry == kNotFound) return false;
InternalIndex entry = table.FindEntry(isolate, key);
if (entry.is_not_found()) return false;
int nof = table.NumberOfElements();
int nod = table.NumberOfDeletedElements();
Object hole = ReadOnlyRoots(isolate).the_hole_value();
for (int j = 0; j < Derived::kEntrySize; j++) {
table.SetDataEntry(entry, j, hole);
table.SetDataEntry(entry.as_int(), j, hole);
}
table.SetNumberOfElements(nof - 1);
@ -847,8 +850,9 @@ bool SmallOrderedHashTable<Derived>::Delete(Isolate* isolate, Derived table,
}
Handle<SmallOrderedNameDictionary> SmallOrderedNameDictionary::DeleteEntry(
Isolate* isolate, Handle<SmallOrderedNameDictionary> table, int entry) {
DCHECK_NE(entry, kNotFound);
Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
InternalIndex entry) {
DCHECK(entry.is_found());
{
DisallowHeapAllocation no_gc;
Object hole = ReadOnlyRoots(isolate).the_hole_value();
@ -873,13 +877,11 @@ Handle<Derived> SmallOrderedHashTable<Derived>::Rehash(Isolate* isolate,
isolate, new_capacity,
Heap::InYoungGeneration(*table) ? AllocationType::kYoung
: AllocationType::kOld);
int nof = table->NumberOfElements();
int nod = table->NumberOfDeletedElements();
int new_entry = 0;
{
DisallowHeapAllocation no_gc;
for (int old_entry = 0; old_entry < (nof + nod); ++old_entry) {
for (InternalIndex old_entry : table->IterateEntries()) {
Object key = table->KeyAt(old_entry);
if (key.IsTheHole(isolate)) continue;
@ -891,14 +893,14 @@ Handle<Derived> SmallOrderedHashTable<Derived>::Rehash(Isolate* isolate,
new_table->SetNextEntry(new_entry, chain);
for (int i = 0; i < Derived::kEntrySize; ++i) {
Object value = table->GetDataEntry(old_entry, i);
Object value = table->GetDataEntry(old_entry.as_int(), i);
new_table->SetDataEntry(new_entry, i, value);
}
++new_entry;
}
new_table->SetNumberOfElements(nof);
new_table->SetNumberOfElements(table->NumberOfElements());
}
return new_table;
}
@ -962,20 +964,22 @@ MaybeHandle<Derived> SmallOrderedHashTable<Derived>::Grow(
}
template <class Derived>
int SmallOrderedHashTable<Derived>::FindEntry(Isolate* isolate, Object key) {
InternalIndex SmallOrderedHashTable<Derived>::FindEntry(Isolate* isolate,
Object key) {
DisallowHeapAllocation no_gc;
Object hash = key.GetHash();
if (hash.IsUndefined(isolate)) return kNotFound;
int entry = HashToFirstEntry(Smi::ToInt(hash));
if (hash.IsUndefined(isolate)) return InternalIndex::NotFound();
int raw_entry = HashToFirstEntry(Smi::ToInt(hash));
// Walk the chain in the bucket to find the key.
while (entry != kNotFound) {
while (raw_entry != kNotFound) {
InternalIndex entry(raw_entry);
Object candidate_key = KeyAt(entry);
if (candidate_key.SameValueZero(key)) return entry;
entry = GetNextEntry(entry);
raw_entry = GetNextEntry(raw_entry);
}
return kNotFound;
return InternalIndex::NotFound();
}
template bool EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
@ -1098,17 +1102,16 @@ MaybeHandle<OrderedHashMap> OrderedHashMapHandler::AdjustRepresentation(
if (!new_table_candidate.ToHandle(&new_table)) {
return new_table_candidate;
}
int nof = table->NumberOfElements();
int nod = table->NumberOfDeletedElements();
// TODO(gsathya): Optimize the lookup to not re calc offsets. Also,
// unhandlify this code as we preallocate the new backing store with
// the proper capacity.
for (int entry = 0; entry < (nof + nod); ++entry) {
for (InternalIndex entry : table->IterateEntries()) {
Handle<Object> key = handle(table->KeyAt(entry), isolate);
if (key->IsTheHole(isolate)) continue;
Handle<Object> value = handle(
table->GetDataEntry(entry, SmallOrderedHashMap::kValueIndex), isolate);
table->GetDataEntry(entry.as_int(), SmallOrderedHashMap::kValueIndex),
isolate);
new_table_candidate = OrderedHashMap::Add(isolate, new_table, key, value);
if (!new_table_candidate.ToHandle(&new_table)) {
return new_table_candidate;
@ -1126,13 +1129,11 @@ MaybeHandle<OrderedHashSet> OrderedHashSetHandler::AdjustRepresentation(
if (!new_table_candidate.ToHandle(&new_table)) {
return new_table_candidate;
}
int nof = table->NumberOfElements();
int nod = table->NumberOfDeletedElements();
// TODO(gsathya): Optimize the lookup to not re calc offsets. Also,
// unhandlify this code as we preallocate the new backing store with
// the proper capacity.
for (int entry = 0; entry < (nof + nod); ++entry) {
for (InternalIndex entry : table->IterateEntries()) {
Handle<Object> key = handle(table->KeyAt(entry), isolate);
if (key->IsTheHole(isolate)) continue;
new_table_candidate = OrderedHashSet::Add(isolate, new_table, key);
@ -1153,13 +1154,11 @@ OrderedNameDictionaryHandler::AdjustRepresentation(
if (!new_table_candidate.ToHandle(&new_table)) {
return new_table_candidate;
}
int nof = table->NumberOfElements();
int nod = table->NumberOfDeletedElements();
// TODO(gsathya): Optimize the lookup to not re calc offsets. Also,
// unhandlify this code as we preallocate the new backing store with
// the proper capacity.
for (int entry = 0; entry < (nof + nod); ++entry) {
for (InternalIndex entry : table->IterateEntries()) {
Handle<Name> key(Name::cast(table->KeyAt(entry)), isolate);
if (key->IsTheHole(isolate)) continue;
Handle<Object> value(table->ValueAt(entry), isolate);
@ -1247,8 +1246,9 @@ MaybeHandle<HeapObject> OrderedNameDictionaryHandler::Add(
isolate, Handle<OrderedNameDictionary>::cast(table), key, value, details);
}
void OrderedNameDictionaryHandler::SetEntry(HeapObject table, int entry,
Object key, Object value,
void OrderedNameDictionaryHandler::SetEntry(HeapObject table,
InternalIndex entry, Object key,
Object value,
PropertyDetails details) {
DisallowHeapAllocation no_gc;
if (table.IsSmallOrderedNameDictionary()) {
@ -1261,61 +1261,58 @@ void OrderedNameDictionaryHandler::SetEntry(HeapObject table, int entry,
value, details);
}
int OrderedNameDictionaryHandler::FindEntry(Isolate* isolate, HeapObject table,
Name key) {
InternalIndex OrderedNameDictionaryHandler::FindEntry(Isolate* isolate,
HeapObject table,
Name key) {
DisallowHeapAllocation no_gc;
if (table.IsSmallOrderedNameDictionary()) {
int entry = SmallOrderedNameDictionary::cast(table).FindEntry(isolate, key);
return entry == SmallOrderedNameDictionary::kNotFound
? OrderedNameDictionaryHandler::kNotFound
: entry;
return SmallOrderedNameDictionary::cast(table).FindEntry(isolate, key);
}
DCHECK(table.IsOrderedNameDictionary());
InternalIndex entry =
OrderedNameDictionary::cast(table).FindEntry(isolate, key);
return entry.is_not_found() ? OrderedNameDictionaryHandler::kNotFound
: entry.as_int();
return OrderedNameDictionary::cast(table).FindEntry(isolate, key);
}
Object OrderedNameDictionaryHandler::ValueAt(HeapObject table, int entry) {
Object OrderedNameDictionaryHandler::ValueAt(HeapObject table,
InternalIndex entry) {
if (table.IsSmallOrderedNameDictionary()) {
return SmallOrderedNameDictionary::cast(table).ValueAt(entry);
}
DCHECK(table.IsOrderedNameDictionary());
return OrderedNameDictionary::cast(table).ValueAt(InternalIndex(entry));
return OrderedNameDictionary::cast(table).ValueAt(entry);
}
void OrderedNameDictionaryHandler::ValueAtPut(HeapObject table, int entry,
void OrderedNameDictionaryHandler::ValueAtPut(HeapObject table,
InternalIndex entry,
Object value) {
if (table.IsSmallOrderedNameDictionary()) {
return SmallOrderedNameDictionary::cast(table).ValueAtPut(entry, value);
}
DCHECK(table.IsOrderedNameDictionary());
OrderedNameDictionary::cast(table).ValueAtPut(InternalIndex(entry), value);
OrderedNameDictionary::cast(table).ValueAtPut(entry, value);
}
PropertyDetails OrderedNameDictionaryHandler::DetailsAt(HeapObject table,
int entry) {
InternalIndex entry) {
if (table.IsSmallOrderedNameDictionary()) {
return SmallOrderedNameDictionary::cast(table).DetailsAt(entry);
}
DCHECK(table.IsOrderedNameDictionary());
return OrderedNameDictionary::cast(table).DetailsAt(InternalIndex(entry));
return OrderedNameDictionary::cast(table).DetailsAt(entry);
}
void OrderedNameDictionaryHandler::DetailsAtPut(HeapObject table, int entry,
void OrderedNameDictionaryHandler::DetailsAtPut(HeapObject table,
InternalIndex entry,
PropertyDetails details) {
if (table.IsSmallOrderedNameDictionary()) {
return SmallOrderedNameDictionary::cast(table).DetailsAtPut(entry, details);
}
DCHECK(table.IsOrderedNameDictionary());
OrderedNameDictionary::cast(table).DetailsAtPut(InternalIndex(entry),
details);
OrderedNameDictionary::cast(table).DetailsAtPut(entry, details);
}
int OrderedNameDictionaryHandler::Hash(HeapObject table) {
@ -1336,7 +1333,8 @@ void OrderedNameDictionaryHandler::SetHash(HeapObject table, int hash) {
OrderedNameDictionary::cast(table).SetHash(hash);
}
Name OrderedNameDictionaryHandler::KeyAt(HeapObject table, int entry) {
Name OrderedNameDictionaryHandler::KeyAt(HeapObject table,
InternalIndex entry) {
if (table.IsSmallOrderedNameDictionary()) {
return Name::cast(SmallOrderedNameDictionary::cast(table).KeyAt(entry));
}
@ -1375,7 +1373,7 @@ Handle<HeapObject> OrderedNameDictionaryHandler::Shrink(
}
Handle<HeapObject> OrderedNameDictionaryHandler::DeleteEntry(
Isolate* isolate, Handle<HeapObject> table, int entry) {
Isolate* isolate, Handle<HeapObject> table, InternalIndex entry) {
DisallowHeapAllocation no_gc;
if (table->IsSmallOrderedNameDictionary()) {
Handle<SmallOrderedNameDictionary> small_dict =

43
src/objects/ordered-hash-table.h
View File

@ -403,7 +403,7 @@ class SmallOrderedHashTable : public HeapObject {
// we've already reached MaxCapacity.
static MaybeHandle<Derived> Grow(Isolate* isolate, Handle<Derived> table);
int FindEntry(Isolate* isolate, Object key);
InternalIndex FindEntry(Isolate* isolate, Object key);
static Handle<Derived> Shrink(Isolate* isolate, Handle<Derived> table);
// Iterates only fields in the DataTable.
@ -450,7 +450,11 @@ class SmallOrderedHashTable : public HeapObject {
int NumberOfBuckets() const { return getByte(NumberOfBucketsOffset(), 0); }
V8_INLINE Object KeyAt(int entry) const;
V8_INLINE Object KeyAt(InternalIndex entry) const;
InternalIndex::Range IterateEntries() {
return InternalIndex::Range(UsedCapacity());
}
DECL_VERIFIER(SmallOrderedHashTable)
@ -800,24 +804,26 @@ class V8_EXPORT_PRIVATE OrderedNameDictionaryHandler
static Handle<HeapObject> Shrink(Isolate* isolate, Handle<HeapObject> table);
static Handle<HeapObject> DeleteEntry(Isolate* isolate,
Handle<HeapObject> table, int entry);
static int FindEntry(Isolate* isolate, HeapObject table, Name key);
static void SetEntry(HeapObject table, int entry, Object key, Object value,
PropertyDetails details);
Handle<HeapObject> table,
InternalIndex entry);
static InternalIndex FindEntry(Isolate* isolate, HeapObject table, Name key);
static void SetEntry(HeapObject table, InternalIndex entry, Object key,
Object value, PropertyDetails details);
// Returns the value for entry.
static Object ValueAt(HeapObject table, int entry);
static Object ValueAt(HeapObject table, InternalIndex entry);
// Set the value for entry.
static void ValueAtPut(HeapObject table, int entry, Object value);
static void ValueAtPut(HeapObject table, InternalIndex entry, Object value);
// Returns the property details for the property at entry.
static PropertyDetails DetailsAt(HeapObject table, int entry);
static PropertyDetails DetailsAt(HeapObject table, InternalIndex entry);
// Set the details for entry.
static void DetailsAtPut(HeapObject table, int entry, PropertyDetails value);
static void DetailsAtPut(HeapObject table, InternalIndex entry,
PropertyDetails value);
static Name KeyAt(HeapObject table, int entry);
static Name KeyAt(HeapObject table, InternalIndex entry);
static void SetHash(HeapObject table, int hash);
static int Hash(HeapObject table);
@ -825,8 +831,6 @@ class V8_EXPORT_PRIVATE OrderedNameDictionaryHandler
static int NumberOfElements(HeapObject table);
static int Capacity(HeapObject table);
static const int kNotFound = -1;
protected:
static MaybeHandle<OrderedNameDictionary> AdjustRepresentation(
Isolate* isolate, Handle<SmallOrderedNameDictionary> table);
@ -841,23 +845,24 @@ class SmallOrderedNameDictionary
DECL_VERIFIER(SmallOrderedNameDictionary)
// Returns the value for entry.
inline Object ValueAt(int entry);
inline Object ValueAt(InternalIndex entry);
static Handle<SmallOrderedNameDictionary> Rehash(
Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
int new_capacity);
V8_EXPORT_PRIVATE static Handle<SmallOrderedNameDictionary> DeleteEntry(
Isolate* isolate, Handle<SmallOrderedNameDictionary> table, int entry);
Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
InternalIndex entry);
// Set the value for entry.
inline void ValueAtPut(int entry, Object value);
inline void ValueAtPut(InternalIndex entry, Object value);
// Returns the property details for the property at entry.
inline PropertyDetails DetailsAt(int entry);
inline PropertyDetails DetailsAt(InternalIndex entry);
// Set the details for entry.
inline void DetailsAtPut(int entry, PropertyDetails value);
inline void DetailsAtPut(InternalIndex entry, PropertyDetails value);
inline void SetHash(int hash);
inline int Hash();
@ -875,7 +880,7 @@ class SmallOrderedNameDictionary
Isolate* isolate, Handle<SmallOrderedNameDictionary> table,
Handle<Name> key, Handle<Object> value, PropertyDetails details);
V8_EXPORT_PRIVATE void SetEntry(int entry, Object key, Object value,
V8_EXPORT_PRIVATE void SetEntry(InternalIndex entry, Object key, Object value,
PropertyDetails details);
static inline Handle<Map> GetMap(ReadOnlyRoots roots);

106
test/cctest/test-orderedhashtable.cc
View File

@ -1621,26 +1621,24 @@ TEST(SmallOrderedNameDictionaryInsertion) {
Handle<String> key1 = isolate->factory()->InternalizeUtf8String("foo");
Handle<String> value = isolate->factory()->InternalizeUtf8String("bar");
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key1));
CHECK(dict->FindEntry(isolate, *key1).is_not_found());
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_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
Handle<Symbol> key2 = factory->NewSymbol();
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key2));
CHECK(dict->FindEntry(isolate, *key2).is_not_found());
dict = SmallOrderedNameDictionary::Add(isolate, dict, key2, value, details)
.ToHandleChecked();
Verify(isolate, dict);
CHECK_EQ(2, dict->NumberOfBuckets());
CHECK_EQ(2, dict->NumberOfElements());
CHECK_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(1, dict->FindEntry(isolate, *key2));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(1), dict->FindEntry(isolate, *key2));
}
TEST(SmallOrderedNameDictionaryInsertionMax) {
@ -1686,8 +1684,7 @@ TEST(SmallOrderedNameDictionaryFindEntry) {
Handle<String> key1 = isolate->factory()->InternalizeUtf8String("foo");
Handle<String> value = isolate->factory()->InternalizeUtf8String("bar");
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key1));
CHECK(dict->FindEntry(isolate, *key1).is_not_found());
PropertyDetails details = PropertyDetails::Empty();
dict = SmallOrderedNameDictionary::Add(isolate, dict, key1, value, details)
@ -1695,22 +1692,21 @@ TEST(SmallOrderedNameDictionaryFindEntry) {
Verify(isolate, dict);
CHECK_EQ(2, dict->NumberOfBuckets());
CHECK_EQ(1, dict->NumberOfElements());
CHECK_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
int entry = dict->FindEntry(isolate, *key1);
CHECK_NE(entry, OrderedNameDictionary::kNotFound);
InternalIndex entry = dict->FindEntry(isolate, *key1);
CHECK(entry.is_found());
Handle<Symbol> key2 = factory->NewSymbol();
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key2));
CHECK(dict->FindEntry(isolate, *key2).is_not_found());
dict = SmallOrderedNameDictionary::Add(isolate, dict, key2, value, details)
.ToHandleChecked();
Verify(isolate, dict);
CHECK_EQ(2, dict->NumberOfBuckets());
CHECK_EQ(2, dict->NumberOfElements());
CHECK_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(1, dict->FindEntry(isolate, *key2));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(1), dict->FindEntry(isolate, *key2));
}
TEST(SmallOrderedNameDictionaryValueAtAndValueAtPut) {
@ -1727,17 +1723,16 @@ TEST(SmallOrderedNameDictionaryValueAtAndValueAtPut) {
Handle<String> key1 = isolate->factory()->InternalizeUtf8String("foo");
Handle<String> value = isolate->factory()->InternalizeUtf8String("bar");
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key1));
CHECK(dict->FindEntry(isolate, *key1).is_not_found());
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_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
int entry = dict->FindEntry(isolate, *key1);
InternalIndex entry = dict->FindEntry(isolate, *key1);
Handle<Object> found = handle(dict->ValueAt(entry), isolate);
CHECK_EQ(*found, *value);
@ -1750,15 +1745,14 @@ TEST(SmallOrderedNameDictionaryValueAtAndValueAtPut) {
CHECK_EQ(*found, *other_value);
Handle<Symbol> key2 = factory->NewSymbol();
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key2));
CHECK(dict->FindEntry(isolate, *key2).is_not_found());
dict = SmallOrderedNameDictionary::Add(isolate, dict, key2, value, details)
.ToHandleChecked();
Verify(isolate, dict);
CHECK_EQ(2, dict->NumberOfBuckets());
CHECK_EQ(2, dict->NumberOfElements());
CHECK_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(1, dict->FindEntry(isolate, *key2));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(1), dict->FindEntry(isolate, *key2));
entry = dict->FindEntry(isolate, *key1);
found = handle(dict->ValueAt(entry), isolate);
@ -1790,17 +1784,16 @@ TEST(SmallOrderedNameDictionaryDetailsAtAndDetailsAtPut) {
Handle<String> key1 = isolate->factory()->InternalizeUtf8String("foo");
Handle<String> value = isolate->factory()->InternalizeUtf8String("bar");
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key1));
CHECK(dict->FindEntry(isolate, *key1).is_not_found());
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_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
int entry = dict->FindEntry(isolate, *key1);
InternalIndex entry = dict->FindEntry(isolate, *key1);
PropertyDetails found = dict->DetailsAt(entry);
CHECK_EQ(PropertyDetails::Empty().AsSmi(), found.AsSmi());
@ -1813,15 +1806,14 @@ TEST(SmallOrderedNameDictionaryDetailsAtAndDetailsAtPut) {
CHECK_EQ(other.AsSmi(), found.AsSmi());
Handle<Symbol> key2 = factory->NewSymbol();
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key2));
CHECK(dict->FindEntry(isolate, *key2).is_not_found());
dict = SmallOrderedNameDictionary::Add(isolate, dict, key2, value, details)
.ToHandleChecked();
Verify(isolate, dict);
CHECK_EQ(2, dict->NumberOfBuckets());
CHECK_EQ(2, dict->NumberOfElements());
CHECK_EQ(0, dict->FindEntry(isolate, *key1));
CHECK_EQ(1, dict->FindEntry(isolate, *key2));
CHECK_EQ(InternalIndex(0), dict->FindEntry(isolate, *key1));
CHECK_EQ(InternalIndex(1), dict->FindEntry(isolate, *key2));
entry = dict->FindEntry(isolate, *key1);
found = dict->DetailsAt(entry);
@ -1905,8 +1897,8 @@ TEST(OrderedNameDictionaryHandlerInsertion) {
DCHECK(key->IsUniqueName());
Verify(isolate, table);
CHECK(table->IsSmallOrderedNameDictionary());
CHECK_NE(OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key));
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key)
.is_found());
char buf[10];
for (int i = 0; i < 1024; i++) {
@ -1921,17 +1913,15 @@ TEST(OrderedNameDictionaryHandlerInsertion) {
for (int j = 0; j <= i; j++) {
CHECK_LT(0, snprintf(buf, sizeof(buf), "foo%d", j));
Handle<Name> key_j = isolate->factory()->InternalizeUtf8String(buf);
CHECK_NE(
OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key_j));
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key_j)
.is_found());
}
for (int j = i + 1; j < 1024; j++) {
CHECK_LT(0, snprintf(buf, sizeof(buf), "foo%d", j));
Handle<Name> key_j = isolate->factory()->InternalizeUtf8String(buf);
CHECK_EQ(
OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key_j));
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key_j)
.is_not_found());
}
}
@ -1959,24 +1949,24 @@ TEST(OrderedNameDictionaryHandlerDeletion) {
DCHECK(key->IsUniqueName());
Verify(isolate, table);
CHECK(table->IsSmallOrderedNameDictionary());
CHECK_NE(OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key));
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key)
.is_found());
// Remove a non-existing key.
OrderedNameDictionaryHandler::Delete(isolate, table, key2);
Verify(isolate, table);
CHECK(table->IsSmallOrderedNameDictionary());
CHECK_EQ(OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key2));
CHECK_NE(OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key));
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key2)
.is_not_found());
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key)
.is_found());
// Remove an existing key.
OrderedNameDictionaryHandler::Delete(isolate, table, key);
Verify(isolate, table);
CHECK(table->IsSmallOrderedNameDictionary());
CHECK_EQ(OrderedNameDictionaryHandler::kNotFound,
OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key));
CHECK(OrderedNameDictionaryHandler::FindEntry(isolate, *table, *key)
.is_not_found());
CHECK(table->IsSmallOrderedNameDictionary());
}
@ -2038,8 +2028,7 @@ TEST(SmallOrderedNameDictionarySetEntry) {
Handle<String> key = factory->InternalizeUtf8String("foo");
Handle<String> value = factory->InternalizeUtf8String("bar");
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key));
CHECK(dict->FindEntry(isolate, *key).is_not_found());
PropertyDetails details = PropertyDetails::Empty();
dict = SmallOrderedNameDictionary::Add(isolate, dict, key, value, details)
.ToHandleChecked();
@ -2048,8 +2037,8 @@ TEST(SmallOrderedNameDictionarySetEntry) {
CHECK_EQ(1, dict->NumberOfElements());
CHECK_EQ(0, dict->NumberOfDeletedElements());
int entry = dict->FindEntry(isolate, *key);
CHECK_EQ(0, entry);
InternalIndex entry = dict->FindEntry(isolate, *key);
CHECK_EQ(InternalIndex(0), entry);
Handle<Object> found = handle(dict->ValueAt(entry), isolate);
CHECK_EQ(*found, *value);
@ -2060,7 +2049,7 @@ TEST(SmallOrderedNameDictionarySetEntry) {
dict->SetEntry(entry, *key, *other_value, other_details);
entry = dict->FindEntry(isolate, *key);
CHECK_EQ(0, entry);
CHECK_EQ(InternalIndex(0), entry);
found = handle(dict->ValueAt(entry), isolate);
CHECK_EQ(*found, *other_value);
found = handle(dict->KeyAt(entry), isolate);
@ -2144,8 +2133,7 @@ TEST(SmallOrderedNameDictionaryDeleteEntry) {
Handle<String> key = factory->InternalizeUtf8String("foo");
Handle<String> value = factory->InternalizeUtf8String("bar");
CHECK_EQ(SmallOrderedNameDictionary::kNotFound,
dict->FindEntry(isolate, *key));
CHECK(dict->FindEntry(isolate, *key).is_not_found());
PropertyDetails details = PropertyDetails::Empty();
dict = SmallOrderedNameDictionary::Add(isolate, dict, key, value, details)
.ToHandleChecked();
@ -2154,11 +2142,11 @@ TEST(SmallOrderedNameDictionaryDeleteEntry) {
CHECK_EQ(1, dict->NumberOfElements());
CHECK_EQ(0, dict->NumberOfDeletedElements());
int entry = dict->FindEntry(isolate, *key);
CHECK_EQ(0, entry);
InternalIndex entry = dict->FindEntry(isolate, *key);
CHECK_EQ(InternalIndex(0), entry);
dict = SmallOrderedNameDictionary::DeleteEntry(isolate, dict, entry);
entry = dict->FindEntry(isolate, *key);
CHECK_EQ(SmallOrderedNameDictionary::kNotFound, entry);
CHECK(entry.is_not_found());
char buf[10];
// Make sure we grow at least once.
@ -2186,7 +2174,7 @@ TEST(SmallOrderedNameDictionaryDeleteEntry) {
Verify(isolate, dict);
entry = dict->FindEntry(isolate, *key);
CHECK_EQ(SmallOrderedNameDictionary::kNotFound, entry);
CHECK(entry.is_not_found());
}
CHECK_EQ(0, dict->NumberOfElements());