From: ishell@chromium.org Date: Mon, 14 Apr 2014 13:25:16 +0000 (+0000) Subject: Revert "Reland "HashTable::Shrink() handlified and derived template parameter added... X-Git-Tag: upstream/4.7.83~9639 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=f4dc0ee8826384313ffed6094bf48768022bb571;p=platform%2Fupstream%2Fv8.git Revert "Reland "HashTable::Shrink() handlified and derived template parameter added to HashTable hierarchy."" This reverts r20724. TBR=jarin@chromium.org Review URL: https://codereview.chromium.org/237043002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20726 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/objects-inl.h b/src/objects-inl.h index 221c1da..cde3818 100644 --- a/src/objects-inl.h +++ b/src/objects-inl.h @@ -2882,8 +2882,8 @@ DescriptorArray::WhitenessWitness::~WhitenessWitness() { } -template -int HashTable::ComputeCapacity(int at_least_space_for) { +template +int HashTable::ComputeCapacity(int at_least_space_for) { const int kMinCapacity = 32; int capacity = RoundUpToPowerOf2(at_least_space_for * 2); if (capacity < kMinCapacity) { @@ -2893,17 +2893,17 @@ int HashTable::ComputeCapacity(int at_least_space_for) { } -template -int HashTable::FindEntry(Key key) { +template +int HashTable::FindEntry(Key key) { return FindEntry(GetIsolate(), key); } // Find entry for key otherwise return kNotFound. -template -int HashTable::FindEntry(Isolate* isolate, Key key) { +template +int HashTable::FindEntry(Isolate* isolate, Key key) { uint32_t capacity = Capacity(); - uint32_t entry = FirstProbe(HashTable::Hash(key), capacity); + uint32_t entry = FirstProbe(HashTable::Hash(key), capacity); uint32_t count = 1; // EnsureCapacity will guarantee the hash table is never full. while (true) { @@ -3028,9 +3028,8 @@ FixedTypedArray* FixedTypedArray::cast(Object* object) { #undef MAKE_STRUCT_CAST -template -HashTable* -HashTable::cast(Object* obj) { +template +HashTable* HashTable::cast(Object* obj) { ASSERT(obj->IsHashTable()); return reinterpret_cast(obj); } @@ -6672,23 +6671,23 @@ bool AccessorPair::prohibits_overwriting() { } -template -void Dictionary::SetEntry(int entry, - Object* key, - Object* value) { +template +void Dictionary::SetEntry(int entry, + Object* key, + Object* value) { SetEntry(entry, key, value, PropertyDetails(Smi::FromInt(0))); } -template -void Dictionary::SetEntry(int entry, - Object* key, - Object* value, - PropertyDetails details) { +template +void Dictionary::SetEntry(int entry, + Object* key, + Object* value, + PropertyDetails details) { ASSERT(!key->IsName() || details.IsDeleted() || details.dictionary_index() > 0); - int index = DerivedHashTable::EntryToIndex(entry); + int index = HashTable::EntryToIndex(entry); DisallowHeapAllocation no_gc; WriteBarrierMode mode = FixedArray::GetWriteBarrierMode(no_gc); FixedArray::set(index, key, mode); @@ -6774,12 +6773,6 @@ MaybeObject* ObjectHashTableShape::AsObject(Heap* heap, Object* key) { } -Handle ObjectHashTable::Shrink( - Handle table, Handle key) { - return HashTable_::Shrink(table, *key); -} - - template bool WeakHashTableShape::IsMatch(Object* key, Object* other) { return key->SameValue(other); diff --git a/src/objects.cc b/src/objects.cc index 34df92f..cadfb50 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -691,6 +691,13 @@ void JSObject::SetNormalizedProperty(Handle object, } +// TODO(mstarzinger): Temporary wrapper until target is handlified. +Handle NameDictionaryShrink(Handle dict, + Handle name) { + CALL_HEAP_FUNCTION(dict->GetIsolate(), dict->Shrink(*name), NameDictionary); +} + + Handle JSObject::DeleteNormalizedProperty(Handle object, Handle name, DeleteMode mode) { @@ -720,7 +727,7 @@ Handle JSObject::DeleteNormalizedProperty(Handle object, Handle deleted(dictionary->DeleteProperty(entry, mode), isolate); if (*deleted == isolate->heap()->true_value()) { Handle new_properties = - NameDictionary::Shrink(dictionary, *name); + NameDictionaryShrink(dictionary, name); object->set_properties(*new_properties); } return deleted; @@ -13164,12 +13171,12 @@ bool JSObject::ShouldConvertToFastDoubleElements( // together, so even though this function belongs in objects-debug.cc, // we keep it here instead to satisfy certain compilers. #ifdef OBJECT_PRINT -template -void Dictionary::Print(FILE* out) { - int capacity = DerivedHashTable::Capacity(); +template +void Dictionary::Print(FILE* out) { + int capacity = HashTable::Capacity(); for (int i = 0; i < capacity; i++) { - Object* k = DerivedHashTable::KeyAt(i); - if (DerivedHashTable::IsKey(k)) { + Object* k = HashTable::KeyAt(i); + if (HashTable::IsKey(k)) { PrintF(out, " "); if (k->IsString()) { String::cast(k)->StringPrint(out); @@ -13185,15 +13192,15 @@ void Dictionary::Print(FILE* out) { #endif -template -void Dictionary::CopyValuesTo(FixedArray* elements) { +template +void Dictionary::CopyValuesTo(FixedArray* elements) { int pos = 0; - int capacity = DerivedHashTable::Capacity(); + int capacity = HashTable::Capacity(); DisallowHeapAllocation no_gc; WriteBarrierMode mode = elements->GetWriteBarrierMode(no_gc); for (int i = 0; i < capacity; i++) { - Object* k = Dictionary::KeyAt(i); - if (Dictionary::IsKey(k)) { + Object* k = Dictionary::KeyAt(i); + if (Dictionary::IsKey(k)) { elements->set(pos++, ValueAt(i), mode); } } @@ -13897,26 +13904,25 @@ class InternalizedStringKey : public HashTableKey { }; -template -void HashTable::IteratePrefix(ObjectVisitor* v) { +template +void HashTable::IteratePrefix(ObjectVisitor* v) { IteratePointers(v, 0, kElementsStartOffset); } -template -void HashTable::IterateElements(ObjectVisitor* v) { +template +void HashTable::IterateElements(ObjectVisitor* v) { IteratePointers(v, kElementsStartOffset, kHeaderSize + length() * kPointerSize); } -template -MaybeObject* HashTable::Allocate( - Heap* heap, - int at_least_space_for, - MinimumCapacity capacity_option, - PretenureFlag pretenure) { +template +MaybeObject* HashTable::Allocate(Heap* heap, + int at_least_space_for, + MinimumCapacity capacity_option, + PretenureFlag pretenure) { ASSERT(!capacity_option || IsPowerOf2(at_least_space_for)); int capacity = (capacity_option == USE_CUSTOM_MINIMUM_CAPACITY) ? at_least_space_for @@ -13937,23 +13943,10 @@ MaybeObject* HashTable::Allocate( } -template -Handle HashTable::New( - Isolate* isolate, - int at_least_space_for, - MinimumCapacity capacity_option, - PretenureFlag pretenure) { - CALL_HEAP_FUNCTION( - isolate, - Allocate(isolate->heap(), at_least_space_for, capacity_option, pretenure), - Derived); -} - - // Find entry for key otherwise return kNotFound. int NameDictionary::FindEntry(Name* key) { if (!key->IsUniqueName()) { - return DerivedHashTable::FindEntry(key); + return HashTable::FindEntry(key); } // Optimized for unique names. Knowledge of the key type allows: @@ -13990,8 +13983,8 @@ int NameDictionary::FindEntry(Name* key) { } -template -void HashTable::Rehash(Derived* new_table, Key key) { +template +MaybeObject* HashTable::Rehash(HashTable* new_table, Key key) { ASSERT(NumberOfElements() < new_table->Capacity()); DisallowHeapAllocation no_gc; @@ -14010,7 +14003,7 @@ void HashTable::Rehash(Derived* new_table, Key key) { uint32_t from_index = EntryToIndex(i); Object* k = get(from_index); if (IsKey(k)) { - uint32_t hash = HashTable::HashForObject(key, k); + uint32_t hash = HashTable::HashForObject(key, k); uint32_t insertion_index = EntryToIndex(new_table->FindInsertionEntry(hash)); for (int j = 0; j < Shape::kEntrySize; j++) { @@ -14020,16 +14013,16 @@ void HashTable::Rehash(Derived* new_table, Key key) { } new_table->SetNumberOfElements(NumberOfElements()); new_table->SetNumberOfDeletedElements(0); + return new_table; } -template -uint32_t HashTable::EntryForProbe( - Key key, - Object* k, - int probe, - uint32_t expected) { - uint32_t hash = HashTable::HashForObject(key, k); +template +uint32_t HashTable::EntryForProbe(Key key, + Object* k, + int probe, + uint32_t expected) { + uint32_t hash = HashTable::HashForObject(key, k); uint32_t capacity = Capacity(); uint32_t entry = FirstProbe(hash, capacity); for (int i = 1; i < probe; i++) { @@ -14040,10 +14033,10 @@ uint32_t HashTable::EntryForProbe( } -template -void HashTable::Swap(uint32_t entry1, - uint32_t entry2, - WriteBarrierMode mode) { +template +void HashTable::Swap(uint32_t entry1, + uint32_t entry2, + WriteBarrierMode mode) { int index1 = EntryToIndex(entry1); int index2 = EntryToIndex(entry2); Object* temp[Shape::kEntrySize]; @@ -14059,8 +14052,8 @@ void HashTable::Swap(uint32_t entry1, } -template -void HashTable::Rehash(Key key) { +template +void HashTable::Rehash(Key key) { DisallowHeapAllocation no_gc; WriteBarrierMode mode = GetWriteBarrierMode(no_gc); uint32_t capacity = Capacity(); @@ -14092,11 +14085,10 @@ void HashTable::Rehash(Key key) { } -template -MaybeObject* HashTable::EnsureCapacity( - int n, - Key key, - PretenureFlag pretenure) { +template +MaybeObject* HashTable::EnsureCapacity(int n, + Key key, + PretenureFlag pretenure) { int capacity = Capacity(); int nof = NumberOfElements() + n; int nod = NumberOfDeletedElements(); @@ -14120,45 +14112,44 @@ MaybeObject* HashTable::EnsureCapacity( if (!maybe_obj->ToObject(&obj)) return maybe_obj; } - Rehash(Derived::cast(obj), key); - return Derived::cast(obj); + return Rehash(HashTable::cast(obj), key); } -template -Handle HashTable::Shrink(Handle table, - Key key) { - int capacity = table->Capacity(); - int nof = table->NumberOfElements(); +template +MaybeObject* HashTable::Shrink(Key key) { + int capacity = Capacity(); + int nof = NumberOfElements(); // Shrink to fit the number of elements if only a quarter of the // capacity is filled with elements. - if (nof > (capacity >> 2)) return table; + if (nof > (capacity >> 2)) return this; // Allocate a new dictionary with room for at least the current // number of elements. The allocation method will make sure that // there is extra room in the dictionary for additions. Don't go // lower than room for 16 elements. int at_least_room_for = nof; - if (at_least_room_for < 16) return table; + if (at_least_room_for < 16) return this; - Isolate* isolate = table->GetIsolate(); const int kMinCapacityForPretenure = 256; bool pretenure = (at_least_room_for > kMinCapacityForPretenure) && - !isolate->heap()->InNewSpace(*table); - Handle new_table = New( - isolate, - at_least_room_for, - USE_DEFAULT_MINIMUM_CAPACITY, - pretenure ? TENURED : NOT_TENURED); + !GetHeap()->InNewSpace(this); + Object* obj; + { MaybeObject* maybe_obj = + Allocate(GetHeap(), + at_least_room_for, + USE_DEFAULT_MINIMUM_CAPACITY, + pretenure ? TENURED : NOT_TENURED); + if (!maybe_obj->ToObject(&obj)) return maybe_obj; + } - table->Rehash(*new_table, key); - return new_table; + return Rehash(HashTable::cast(obj), key); } -template -uint32_t HashTable::FindInsertionEntry(uint32_t hash) { +template +uint32_t HashTable::FindInsertionEntry(uint32_t hash) { uint32_t capacity = Capacity(); uint32_t entry = FirstProbe(hash, capacity); uint32_t count = 1; @@ -14175,165 +14166,129 @@ uint32_t HashTable::FindInsertionEntry(uint32_t hash) { // Force instantiation of template instances class. // Please note this list is compiler dependent. -template class HashTable; +template class HashTable; -template class HashTable; +template class HashTable; -template class HashTable; +template class HashTable; -template class HashTable; +template class HashTable; -template class HashTable, Object*>; +template class HashTable, Object*>; -template class Dictionary; +template class Dictionary; -template class Dictionary; +template class Dictionary; -template class Dictionary; +template class Dictionary; -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: Allocate(Heap* heap, int at_least_space_for, PretenureFlag pretenure); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: Allocate(Heap* heap, int at_least_space_for, PretenureFlag pretenure); -template MaybeObject* Dictionary:: +template MaybeObject* Dictionary:: Allocate(Heap* heap, int n, PretenureFlag pretenure); -template MaybeObject* -Dictionary:: - AtPut(uint32_t, Object*); +template MaybeObject* Dictionary::AtPut( + uint32_t, Object*); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: AtPut(uint32_t, Object*); -template Object* -Dictionary:: +template Object* Dictionary:: SlowReverseLookup(Object* value); -template Object* -Dictionary:: +template Object* Dictionary:: SlowReverseLookup(Object* value); -template Object* -Dictionary::SlowReverseLookup( +template Object* Dictionary::SlowReverseLookup( Object*); -template void -Dictionary:: - CopyKeysTo( - FixedArray*, - PropertyAttributes, - Dictionary::SortMode); - -template Object* -Dictionary::DeleteProperty( +template void Dictionary::CopyKeysTo( + FixedArray*, + PropertyAttributes, + Dictionary::SortMode); + +template Object* Dictionary::DeleteProperty( int, JSObject::DeleteMode); -template Handle -Dictionary::DeleteProperty( - Handle >, +template Handle Dictionary::DeleteProperty( + Handle >, int, JSObject::DeleteMode); -template Object* -Dictionary:: +template Object* Dictionary:: DeleteProperty(int, JSObject::DeleteMode); template Handle -Dictionary:: - DeleteProperty( - Handle >, - int, - JSObject::DeleteMode); - -template Handle -HashTable:: - Shrink(Handle, Name* n); - -template Handle -HashTable:: - Shrink(Handle, uint32_t); - -template void Dictionary:: - CopyKeysTo( - FixedArray*, - int, - PropertyAttributes, - Dictionary::SortMode); +Dictionary::DeleteProperty( + Handle >, + int, + JSObject::DeleteMode); + +template MaybeObject* Dictionary::Shrink(Name* n); + +template MaybeObject* Dictionary::Shrink( + uint32_t); +template Handle +Dictionary::Shrink( + Handle >, + uint32_t); + +template void Dictionary::CopyKeysTo( + FixedArray*, + int, + PropertyAttributes, + Dictionary::SortMode); template int -Dictionary:: - NumberOfElementsFilterAttributes(PropertyAttributes); +Dictionary::NumberOfElementsFilterAttributes( + PropertyAttributes); -template MaybeObject* -Dictionary::Add( +template MaybeObject* Dictionary::Add( Name*, Object*, PropertyDetails); template MaybeObject* -Dictionary:: - GenerateNewEnumerationIndices(); +Dictionary::GenerateNewEnumerationIndices(); template int -Dictionary:: +Dictionary:: NumberOfElementsFilterAttributes(PropertyAttributes); -template MaybeObject* -Dictionary::Add( +template MaybeObject* Dictionary::Add( uint32_t, Object*, PropertyDetails); -template MaybeObject* -Dictionary:: - Add(uint32_t, Object*, PropertyDetails); +template MaybeObject* Dictionary::Add( + uint32_t, Object*, PropertyDetails); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: EnsureCapacity(int, uint32_t); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: EnsureCapacity(int, uint32_t); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: EnsureCapacity(int, Name*); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: AddEntry(uint32_t, Object*, PropertyDetails, uint32_t); -template MaybeObject* -Dictionary:: +template MaybeObject* Dictionary:: AddEntry(uint32_t, Object*, PropertyDetails, uint32_t); -template MaybeObject* -Dictionary::AddEntry( +template MaybeObject* Dictionary::AddEntry( Name*, Object*, PropertyDetails, uint32_t); template -int Dictionary:: - NumberOfEnumElements(); +int Dictionary::NumberOfEnumElements(); template -int Dictionary:: - NumberOfEnumElements(); +int Dictionary::NumberOfEnumElements(); template -int HashTable:: - FindEntry(uint32_t); +int HashTable::FindEntry(uint32_t); Handle JSObject::PrepareSlowElementsForSort( @@ -15179,14 +15134,13 @@ MaybeObject* MapCache::Put(FixedArray* array, Map* value) { } -template -MaybeObject* Dictionary::Allocate( - Heap* heap, - int at_least_space_for, - PretenureFlag pretenure) { +template +MaybeObject* Dictionary::Allocate(Heap* heap, + int at_least_space_for, + PretenureFlag pretenure) { Object* obj; { MaybeObject* maybe_obj = - DerivedHashTable::Allocate( + HashTable::Allocate( heap, at_least_space_for, USE_DEFAULT_MINIMUM_CAPACITY, @@ -15194,7 +15148,7 @@ MaybeObject* Dictionary::Allocate( if (!maybe_obj->ToObject(&obj)) return maybe_obj; } // Initialize the next enumeration index. - Dictionary::cast(obj)-> + Dictionary::cast(obj)-> SetNextEnumerationIndex(PropertyDetails::kInitialIndex); return obj; } @@ -15206,10 +15160,10 @@ void NameDictionary::DoGenerateNewEnumerationIndices( dictionary->GenerateNewEnumerationIndices()); } -template -MaybeObject* Dictionary::GenerateNewEnumerationIndices() { - Heap* heap = Dictionary::GetHeap(); - int length = DerivedHashTable::NumberOfElements(); +template +MaybeObject* Dictionary::GenerateNewEnumerationIndices() { + Heap* heap = Dictionary::GetHeap(); + int length = HashTable::NumberOfElements(); // Allocate and initialize iteration order array. Object* obj; @@ -15228,10 +15182,10 @@ MaybeObject* Dictionary::GenerateNewEnumerationIndices() { FixedArray* enumeration_order = FixedArray::cast(obj); // Fill the enumeration order array with property details. - int capacity = DerivedHashTable::Capacity(); + int capacity = HashTable::Capacity(); int pos = 0; for (int i = 0; i < capacity; i++) { - if (Dictionary::IsKey(Dictionary::KeyAt(i))) { + if (Dictionary::IsKey(Dictionary::KeyAt(i))) { int index = DetailsAt(i).dictionary_index(); enumeration_order->set(pos++, Smi::FromInt(index)); } @@ -15248,10 +15202,10 @@ MaybeObject* Dictionary::GenerateNewEnumerationIndices() { } // Update the dictionary with new indices. - capacity = DerivedHashTable::Capacity(); + capacity = HashTable::Capacity(); pos = 0; for (int i = 0; i < capacity; i++) { - if (Dictionary::IsKey(Dictionary::KeyAt(i))) { + if (Dictionary::IsKey(Dictionary::KeyAt(i))) { int enum_index = Smi::cast(enumeration_order->get(pos++))->value(); PropertyDetails details = DetailsAt(i); PropertyDetails new_details = PropertyDetails( @@ -15265,8 +15219,8 @@ MaybeObject* Dictionary::GenerateNewEnumerationIndices() { return this; } -template -MaybeObject* Dictionary::EnsureCapacity(int n, Key key) { +template +MaybeObject* Dictionary::EnsureCapacity(int n, Key key) { // Check whether there are enough enumeration indices to add n elements. if (Shape::kIsEnumerable && !PropertyDetails::IsValidIndex(NextEnumerationIndex() + n)) { @@ -15276,14 +15230,14 @@ MaybeObject* Dictionary::EnsureCapacity(int n, Key key) { if (!maybe_result->ToObject(&result)) return maybe_result; } } - return DerivedHashTable::EnsureCapacity(n, key); + return HashTable::EnsureCapacity(n, key); } // TODO(ishell): Temporary wrapper until handlified. -template -Handle Dictionary::DeleteProperty( - Handle > dictionary, +template +Handle Dictionary::DeleteProperty( + Handle > dictionary, int entry, JSObject::DeleteMode mode) { CALL_HEAP_FUNCTION(dictionary->GetIsolate(), @@ -15292,28 +15246,44 @@ Handle Dictionary::DeleteProperty( } -template -Object* Dictionary::DeleteProperty( - int entry, - JSReceiver::DeleteMode mode) { - Heap* heap = Dictionary::GetHeap(); +template +Object* Dictionary::DeleteProperty(int entry, + JSReceiver::DeleteMode mode) { + Heap* heap = Dictionary::GetHeap(); PropertyDetails details = DetailsAt(entry); // Ignore attributes if forcing a deletion. if (details.IsDontDelete() && mode != JSReceiver::FORCE_DELETION) { return heap->false_value(); } SetEntry(entry, heap->the_hole_value(), heap->the_hole_value()); - DerivedHashTable::ElementRemoved(); + HashTable::ElementRemoved(); return heap->true_value(); } -template -MaybeObject* Dictionary::AtPut(Key key, Object* value) { +// TODO(ishell): Temporary wrapper until handlified. +template +Handle Dictionary::Shrink( + Handle > dictionary, + Key key) { + CALL_HEAP_FUNCTION(dictionary->GetIsolate(), + dictionary->Shrink(key), + FixedArray); +} + + +template +MaybeObject* Dictionary::Shrink(Key key) { + return HashTable::Shrink(key); +} + + +template +MaybeObject* Dictionary::AtPut(Key key, Object* value) { int entry = this->FindEntry(key); // If the entry is present set the value; - if (entry != Dictionary::kNotFound) { + if (entry != Dictionary::kNotFound) { ValueAtPut(entry, value); return this; } @@ -15330,43 +15300,41 @@ MaybeObject* Dictionary::AtPut(Key key, Object* value) { } PropertyDetails details = PropertyDetails(NONE, NORMAL, 0); - return Dictionary::cast(obj)->AddEntry( - key, value, details, Dictionary::Hash(key)); + return Dictionary::cast(obj)->AddEntry(key, value, details, + Dictionary::Hash(key)); } -template -MaybeObject* Dictionary::Add( - Key key, - Object* value, - PropertyDetails details) { +template +MaybeObject* Dictionary::Add(Key key, + Object* value, + PropertyDetails details) { // Valdate key is absent. - SLOW_ASSERT((this->FindEntry(key) == Dictionary::kNotFound)); + SLOW_ASSERT((this->FindEntry(key) == Dictionary::kNotFound)); // Check whether the dictionary should be extended. Object* obj; { MaybeObject* maybe_obj = EnsureCapacity(1, key); if (!maybe_obj->ToObject(&obj)) return maybe_obj; } - return Dictionary::cast(obj)->AddEntry( - key, value, details, Dictionary::Hash(key)); + return Dictionary::cast(obj)->AddEntry(key, value, details, + Dictionary::Hash(key)); } // Add a key, value pair to the dictionary. -template -MaybeObject* Dictionary::AddEntry( - Key key, - Object* value, - PropertyDetails details, - uint32_t hash) { +template +MaybeObject* Dictionary::AddEntry(Key key, + Object* value, + PropertyDetails details, + uint32_t hash) { // Compute the key object. Object* k; { MaybeObject* maybe_k = Shape::AsObject(this->GetHeap(), key); if (!maybe_k->ToObject(&k)) return maybe_k; } - uint32_t entry = Dictionary::FindInsertionEntry(hash); + uint32_t entry = Dictionary::FindInsertionEntry(hash); // Insert element at empty or deleted entry if (!details.IsDeleted() && details.dictionary_index() == 0 && @@ -15378,9 +15346,9 @@ MaybeObject* Dictionary::AddEntry( SetNextEnumerationIndex(index + 1); } SetEntry(entry, k, value, details); - ASSERT((Dictionary::KeyAt(entry)->IsNumber() || - Dictionary::KeyAt(entry)->IsName())); - DerivedHashTable::ElementAdded(); + ASSERT((Dictionary::KeyAt(entry)->IsNumber() || + Dictionary::KeyAt(entry)->IsName())); + HashTable::ElementAdded(); return this; } @@ -15494,14 +15462,14 @@ MaybeObject* UnseededNumberDictionary::Set(uint32_t key, -template -int Dictionary::NumberOfElementsFilterAttributes( +template +int Dictionary::NumberOfElementsFilterAttributes( PropertyAttributes filter) { - int capacity = DerivedHashTable::Capacity(); + int capacity = HashTable::Capacity(); int result = 0; for (int i = 0; i < capacity; i++) { - Object* k = DerivedHashTable::KeyAt(i); - if (DerivedHashTable::IsKey(k) && !FilterKey(k, filter)) { + Object* k = HashTable::KeyAt(i); + if (HashTable::IsKey(k) && !FilterKey(k, filter)) { PropertyDetails details = DetailsAt(i); if (details.IsDeleted()) continue; PropertyAttributes attr = details.attributes(); @@ -15512,31 +15480,31 @@ int Dictionary::NumberOfElementsFilterAttributes( } -template -int Dictionary::NumberOfEnumElements() { +template +int Dictionary::NumberOfEnumElements() { return NumberOfElementsFilterAttributes( static_cast(DONT_ENUM | SYMBOLIC)); } -template -void Dictionary::CopyKeysTo( +template +void Dictionary::CopyKeysTo( FixedArray* storage, PropertyAttributes filter, - typename Dictionary::SortMode sort_mode) { + typename Dictionary::SortMode sort_mode) { ASSERT(storage->length() >= NumberOfElementsFilterAttributes(filter)); - int capacity = DerivedHashTable::Capacity(); + int capacity = HashTable::Capacity(); int index = 0; for (int i = 0; i < capacity; i++) { - Object* k = DerivedHashTable::KeyAt(i); - if (DerivedHashTable::IsKey(k) && !FilterKey(k, filter)) { + Object* k = HashTable::KeyAt(i); + if (HashTable::IsKey(k) && !FilterKey(k, filter)) { PropertyDetails details = DetailsAt(i); if (details.IsDeleted()) continue; PropertyAttributes attr = details.attributes(); if ((attr & filter) == 0) storage->set(index++, k); } } - if (sort_mode == Dictionary::SORTED) { + if (sort_mode == Dictionary::SORTED) { storage->SortPairs(storage, index); } ASSERT(storage->length() >= index); @@ -15578,24 +15546,24 @@ void NameDictionary::CopyEnumKeysTo(FixedArray* storage) { } -template -void Dictionary::CopyKeysTo( +template +void Dictionary::CopyKeysTo( FixedArray* storage, int index, PropertyAttributes filter, - typename Dictionary::SortMode sort_mode) { + typename Dictionary::SortMode sort_mode) { ASSERT(storage->length() >= NumberOfElementsFilterAttributes(filter)); - int capacity = DerivedHashTable::Capacity(); + int capacity = HashTable::Capacity(); for (int i = 0; i < capacity; i++) { - Object* k = DerivedHashTable::KeyAt(i); - if (DerivedHashTable::IsKey(k) && !FilterKey(k, filter)) { + Object* k = HashTable::KeyAt(i); + if (HashTable::IsKey(k) && !FilterKey(k, filter)) { PropertyDetails details = DetailsAt(i); if (details.IsDeleted()) continue; PropertyAttributes attr = details.attributes(); if ((attr & filter) == 0) storage->set(index++, k); } } - if (sort_mode == Dictionary::SORTED) { + if (sort_mode == Dictionary::SORTED) { storage->SortPairs(storage, index); } ASSERT(storage->length() >= index); @@ -15603,12 +15571,12 @@ void Dictionary::CopyKeysTo( // Backwards lookup (slow). -template -Object* Dictionary::SlowReverseLookup(Object* value) { - int capacity = DerivedHashTable::Capacity(); +template +Object* Dictionary::SlowReverseLookup(Object* value) { + int capacity = HashTable::Capacity(); for (int i = 0; i < capacity; i++) { - Object* k = DerivedHashTable::KeyAt(i); - if (Dictionary::IsKey(k)) { + Object* k = HashTable::KeyAt(i); + if (Dictionary::IsKey(k)) { Object* e = ValueAt(i); if (e->IsPropertyCell()) { e = PropertyCell::cast(e)->value(); @@ -15616,7 +15584,7 @@ Object* Dictionary::SlowReverseLookup(Object* value) { if (e == value) return k; } } - Heap* heap = Dictionary::GetHeap(); + Heap* heap = Dictionary::GetHeap(); return heap->undefined_value(); } @@ -15626,15 +15594,22 @@ Handle ObjectHashTable::EnsureCapacity( int n, Handle key, PretenureFlag pretenure) { - Handle > table_base = table; + Handle > table_base = table; CALL_HEAP_FUNCTION(table_base->GetIsolate(), table_base->EnsureCapacity(n, *key, pretenure), ObjectHashTable); } +Handle ObjectHashTable::Shrink( + Handle table, Handle key) { + Handle > table_base = table; + CALL_HEAP_FUNCTION(table_base->GetIsolate(), + table_base->Shrink(*key), + ObjectHashTable); +} + + Object* ObjectHashTable::Lookup(Object* key) { ASSERT(IsKey(key)); diff --git a/src/objects.h b/src/objects.h index 48468c3..1c3a820 100644 --- a/src/objects.h +++ b/src/objects.h @@ -3656,7 +3656,7 @@ class BaseShape { } }; -template +template class HashTable: public FixedArray { public: // Wrapper methods @@ -3709,20 +3709,12 @@ class HashTable: public FixedArray { } // Returns a new HashTable object. Might return Failure. - // TODO(ishell): this will be eventually replaced by New(). MUST_USE_RESULT static MaybeObject* Allocate( Heap* heap, int at_least_space_for, MinimumCapacity capacity_option = USE_DEFAULT_MINIMUM_CAPACITY, PretenureFlag pretenure = NOT_TENURED); - // Returns a new HashTable object. - static Handle New( - Isolate* isolate, - int at_least_space_for, - MinimumCapacity capacity_option = USE_DEFAULT_MINIMUM_CAPACITY, - PretenureFlag pretenure = NOT_TENURED); - // Computes the required capacity for a table holding the given // number of elements. May be more than HashTable::kMaxCapacity. static int ComputeCapacity(int at_least_space_for); @@ -3832,10 +3824,10 @@ class HashTable: public FixedArray { void Swap(uint32_t entry1, uint32_t entry2, WriteBarrierMode mode); // Rehashes this hash-table into the new table. - void Rehash(Derived* new_table, Key key); + MUST_USE_RESULT MaybeObject* Rehash(HashTable* new_table, Key key); // Attempt to shrink hash table after removal of key. - static Handle Shrink(Handle table, Key key); + MUST_USE_RESULT MaybeObject* Shrink(Key key); // Ensure enough space for n additional elements. MUST_USE_RESULT MaybeObject* EnsureCapacity( @@ -3888,9 +3880,7 @@ class SeqOneByteString; // // No special elements in the prefix and the element size is 1 // because only the string itself (the key) needs to be stored. -class StringTable: public HashTable { +class StringTable: public HashTable { public: // Find string in the string table. If it is not there yet, it is // added. The return value is the string table which might have @@ -3942,7 +3932,7 @@ class MapCacheShape : public BaseShape { // // Maps keys that are a fixed array of unique names to a map. // Used for canonicalize maps for object literals. -class MapCache: public HashTable { +class MapCache: public HashTable { public: // Find cached value for a name key, otherwise return null. Object* Lookup(FixedArray* key); @@ -3954,36 +3944,33 @@ class MapCache: public HashTable { }; -template -class Dictionary: public HashTable { - protected: - typedef HashTable DerivedHashTable; - +template +class Dictionary: public HashTable { public: - static inline Dictionary* cast(Object* obj) { - return reinterpret_cast(obj); + static inline Dictionary* cast(Object* obj) { + return reinterpret_cast*>(obj); } // Returns the value at entry. Object* ValueAt(int entry) { - return this->get(DerivedHashTable::EntryToIndex(entry) + 1); + return this->get(HashTable::EntryToIndex(entry) + 1); } // Set the value for entry. void ValueAtPut(int entry, Object* value) { - this->set(DerivedHashTable::EntryToIndex(entry) + 1, value); + this->set(HashTable::EntryToIndex(entry) + 1, value); } // Returns the property details for the property at entry. PropertyDetails DetailsAt(int entry) { ASSERT(entry >= 0); // Not found is -1, which is not caught by get(). return PropertyDetails( - Smi::cast(this->get(DerivedHashTable::EntryToIndex(entry) + 2))); + Smi::cast(this->get(HashTable::EntryToIndex(entry) + 2))); } // Set the details for entry. void DetailsAtPut(int entry, PropertyDetails value) { - this->set(DerivedHashTable::EntryToIndex(entry) + 2, value.AsSmi()); + this->set(HashTable::EntryToIndex(entry) + 2, value.AsSmi()); } // Sorting support @@ -3993,14 +3980,16 @@ class Dictionary: public HashTable { Object* DeleteProperty(int entry, JSObject::DeleteMode mode); // TODO(ishell): Temporary wrapper until handlified. static Handle DeleteProperty( - Handle dictionary, + Handle > dictionary, int entry, JSObject::DeleteMode mode); // Attempt to shrink the dictionary after deletion of key. - static inline Handle Shrink(Handle dictionary, Key key) { - return DerivedHashTable::Shrink(dictionary, key); - } + MUST_USE_RESULT MaybeObject* Shrink(Key key); + // TODO(ishell): Temporary wrapper until handlified. + MUST_USE_RESULT static Handle Shrink( + Handle > dictionary, + Key key); // Returns the number of elements in the dictionary filtering out properties // with the specified attributes. @@ -4070,7 +4059,8 @@ class Dictionary: public HashTable { // Generate new enumeration indices to avoid enumeration index overflow. MUST_USE_RESULT MaybeObject* GenerateNewEnumerationIndices(); - static const int kMaxNumberKeyIndex = DerivedHashTable::kPrefixStartIndex; + static const int kMaxNumberKeyIndex = + HashTable::kPrefixStartIndex; static const int kNextEnumerationIndexIndex = kMaxNumberKeyIndex + 1; }; @@ -4088,9 +4078,7 @@ class NameDictionaryShape : public BaseShape { }; -class NameDictionary: public Dictionary { +class NameDictionary: public Dictionary { public: static inline NameDictionary* cast(Object* obj) { ASSERT(obj->IsDictionary()); @@ -4140,9 +4128,7 @@ class UnseededNumberDictionaryShape : public NumberDictionaryShape { class SeededNumberDictionary - : public Dictionary { + : public Dictionary { public: static SeededNumberDictionary* cast(Object* obj) { ASSERT(obj->IsDictionary()); @@ -4195,9 +4181,7 @@ class SeededNumberDictionary class UnseededNumberDictionary - : public Dictionary { + : public Dictionary { public: static UnseededNumberDictionary* cast(Object* obj) { ASSERT(obj->IsDictionary()); @@ -4233,10 +4217,7 @@ class ObjectHashTableShape : public BaseShape { // ObjectHashTable maps keys that are arbitrary objects to object values by // using the identity hash of the key for hashing purposes. -class ObjectHashTable: public HashTable { - typedef HashTable HashTable_; +class ObjectHashTable: public HashTable { public: static inline ObjectHashTable* cast(Object* obj) { ASSERT(obj->IsHashTable()); @@ -4250,8 +4231,8 @@ class ObjectHashTable: public HashTable Shrink(Handle table, - Handle key); + static Handle Shrink(Handle table, + Handle key); // Looks up the value associated with the given key. The hole value is // returned in case the key is not present. @@ -4449,9 +4430,7 @@ class WeakHashTableShape : public BaseShape { // WeakHashTable maps keys that are arbitrary objects to object values. // It is used for the global weak hash table that maps objects // embedded in optimized code to dependent code lists. -class WeakHashTable: public HashTable, - Object*> { +class WeakHashTable: public HashTable, Object*> { public: static inline WeakHashTable* cast(Object* obj) { ASSERT(obj->IsHashTable()); @@ -8221,8 +8200,7 @@ class CompilationCacheShape : public BaseShape { }; -class CompilationCacheTable: public HashTable { public: // Find cached value for a string key, otherwise return null. @@ -8323,8 +8301,7 @@ class CodeCacheHashTableShape : public BaseShape { }; -class CodeCacheHashTable: public HashTable { public: Object* Lookup(Name* name, Code::Flags flags); @@ -8374,9 +8351,7 @@ class PolymorphicCodeCache: public Struct { class PolymorphicCodeCacheHashTable - : public HashTable { + : public HashTable { public: Object* Lookup(MapHandleList* maps, int code_kind);