OLD | NEW |
---|---|
1 // Copyright 2013 the V8 project authors. All rights reserved. | 1 // Copyright 2013 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <sstream> | 5 #include <sstream> |
6 | 6 |
7 #include "src/v8.h" | 7 #include "src/v8.h" |
8 | 8 |
9 #include "src/accessors.h" | 9 #include "src/accessors.h" |
10 #include "src/allocation-site-scopes.h" | 10 #include "src/allocation-site-scopes.h" |
(...skipping 778 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
789 return context->symbol_function()->initial_map(); | 789 return context->symbol_function()->initial_map(); |
790 } | 790 } |
791 if (heap_object->IsBoolean()) { | 791 if (heap_object->IsBoolean()) { |
792 return context->boolean_function()->initial_map(); | 792 return context->boolean_function()->initial_map(); |
793 } | 793 } |
794 return isolate->heap()->null_value()->map(); | 794 return isolate->heap()->null_value()->map(); |
795 } | 795 } |
796 | 796 |
797 | 797 |
798 Object* Object::GetHash() { | 798 Object* Object::GetHash() { |
799 // The object is either a number, a name, an odd-ball, | 799 // The object is either a Smi, a HeapNumber, a name, an odd-ball, |
800 // a real JS object, or a Harmony proxy. | 800 // a real JS object, or a Harmony proxy. |
801 if (IsSmi()) { | 801 if (IsSmi()) { |
802 int num = Smi::cast(this)->value(); | 802 uint32_t hash = ComputeIntegerHash(Smi::cast(this)->value(), kZeroHashSeed); |
803 uint32_t hash = ComputeLongHash(double_to_uint64(static_cast<double>(num))); | |
804 return Smi::FromInt(hash & Smi::kMaxValue); | 803 return Smi::FromInt(hash & Smi::kMaxValue); |
805 } | 804 } |
806 if (IsHeapNumber()) { | 805 if (IsHeapNumber()) { |
807 double num = HeapNumber::cast(this)->value(); | 806 double num = HeapNumber::cast(this)->value(); |
808 if (std::isnan(num)) return Smi::FromInt(Smi::kMaxValue); | 807 if (std::isnan(num)) return Smi::FromInt(Smi::kMaxValue); |
809 if (i::IsMinusZero(num)) num = 0; | 808 if (i::IsMinusZero(num)) num = 0; |
809 if (IsSmiDouble(num)) { | |
810 return Smi::FromInt(FastD2I(num))->GetHash(); | |
arv (Not doing code reviews)
2015/02/21 16:20:16
Why not call ComputeIntegerHash here directly so w
adamk
2015/02/23 18:43:35
Laziness, happy to clean this up.
| |
811 } | |
810 uint32_t hash = ComputeLongHash(double_to_uint64(num)); | 812 uint32_t hash = ComputeLongHash(double_to_uint64(num)); |
811 return Smi::FromInt(hash & Smi::kMaxValue); | 813 return Smi::FromInt(hash & Smi::kMaxValue); |
812 } | 814 } |
813 if (IsName()) { | 815 if (IsName()) { |
814 uint32_t hash = Name::cast(this)->Hash(); | 816 uint32_t hash = Name::cast(this)->Hash(); |
815 return Smi::FromInt(hash); | 817 return Smi::FromInt(hash); |
816 } | 818 } |
817 if (IsOddball()) { | 819 if (IsOddball()) { |
818 uint32_t hash = Oddball::cast(this)->to_string()->Hash(); | 820 uint32_t hash = Oddball::cast(this)->to_string()->Hash(); |
819 return Smi::FromInt(hash); | 821 return Smi::FromInt(hash); |
(...skipping 15658 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
16478 table->GetHeap()->InNewSpace(*table) ? NOT_TENURED : TENURED); | 16480 table->GetHeap()->InNewSpace(*table) ? NOT_TENURED : TENURED); |
16479 | 16481 |
16480 table->SetNextTable(*new_table); | 16482 table->SetNextTable(*new_table); |
16481 table->SetNumberOfDeletedElements(kClearedTableSentinel); | 16483 table->SetNumberOfDeletedElements(kClearedTableSentinel); |
16482 | 16484 |
16483 return new_table; | 16485 return new_table; |
16484 } | 16486 } |
16485 | 16487 |
16486 | 16488 |
16487 template<class Derived, class Iterator, int entrysize> | 16489 template<class Derived, class Iterator, int entrysize> |
16488 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Remove( | |
16489 Handle<Derived> table, Handle<Object> key, bool* was_present) { | |
16490 int entry = table->FindEntry(key); | |
16491 if (entry == kNotFound) { | |
16492 *was_present = false; | |
16493 return table; | |
16494 } | |
16495 *was_present = true; | |
16496 table->RemoveEntry(entry); | |
16497 return Shrink(table); | |
16498 } | |
16499 | |
16500 | |
16501 template<class Derived, class Iterator, int entrysize> | |
16502 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Rehash( | 16490 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Rehash( |
16503 Handle<Derived> table, int new_capacity) { | 16491 Handle<Derived> table, int new_capacity) { |
16504 DCHECK(!table->IsObsolete()); | 16492 DCHECK(!table->IsObsolete()); |
16505 | 16493 |
16506 Handle<Derived> new_table = | 16494 Handle<Derived> new_table = |
16507 Allocate(table->GetIsolate(), | 16495 Allocate(table->GetIsolate(), |
16508 new_capacity, | 16496 new_capacity, |
16509 table->GetHeap()->InNewSpace(*table) ? NOT_TENURED : TENURED); | 16497 table->GetHeap()->InNewSpace(*table) ? NOT_TENURED : TENURED); |
16510 int nof = table->NumberOfElements(); | 16498 int nof = table->NumberOfElements(); |
16511 int nod = table->NumberOfDeletedElements(); | 16499 int nod = table->NumberOfDeletedElements(); |
(...skipping 24 matching lines...) Expand all Loading... | |
16536 | 16524 |
16537 DCHECK_EQ(nod, removed_holes_index); | 16525 DCHECK_EQ(nod, removed_holes_index); |
16538 | 16526 |
16539 new_table->SetNumberOfElements(nof); | 16527 new_table->SetNumberOfElements(nof); |
16540 table->SetNextTable(*new_table); | 16528 table->SetNextTable(*new_table); |
16541 | 16529 |
16542 return new_table; | 16530 return new_table; |
16543 } | 16531 } |
16544 | 16532 |
16545 | 16533 |
16546 template <class Derived, class Iterator, int entrysize> | |
16547 int OrderedHashTable<Derived, Iterator, entrysize>::FindEntry( | |
16548 Handle<Object> key, int hash) { | |
16549 DCHECK(!IsObsolete()); | |
16550 | |
16551 DisallowHeapAllocation no_gc; | |
16552 DCHECK(!key->IsTheHole()); | |
16553 for (int entry = HashToEntry(hash); entry != kNotFound; | |
16554 entry = ChainAt(entry)) { | |
16555 Object* candidate = KeyAt(entry); | |
16556 if (candidate->SameValueZero(*key)) | |
16557 return entry; | |
16558 } | |
16559 return kNotFound; | |
16560 } | |
16561 | |
16562 | |
16563 template <class Derived, class Iterator, int entrysize> | |
16564 int OrderedHashTable<Derived, Iterator, entrysize>::FindEntry( | |
16565 Handle<Object> key) { | |
16566 DisallowHeapAllocation no_gc; | |
16567 Object* hash = key->GetHash(); | |
16568 if (!hash->IsSmi()) return kNotFound; | |
16569 return FindEntry(key, Smi::cast(hash)->value()); | |
16570 } | |
16571 | |
16572 | |
16573 template <class Derived, class Iterator, int entrysize> | |
16574 int OrderedHashTable<Derived, Iterator, entrysize>::AddEntry(int hash) { | |
16575 DCHECK(!IsObsolete()); | |
16576 | |
16577 int entry = UsedCapacity(); | |
16578 int bucket = HashToBucket(hash); | |
16579 int index = EntryToIndex(entry); | |
16580 Object* chain_entry = get(kHashTableStartIndex + bucket); | |
16581 set(kHashTableStartIndex + bucket, Smi::FromInt(entry)); | |
16582 set(index + kChainOffset, chain_entry); | |
16583 SetNumberOfElements(NumberOfElements() + 1); | |
16584 return index; | |
16585 } | |
16586 | |
16587 | |
16588 template<class Derived, class Iterator, int entrysize> | |
16589 void OrderedHashTable<Derived, Iterator, entrysize>::RemoveEntry(int entry) { | |
16590 DCHECK(!IsObsolete()); | |
16591 | |
16592 int index = EntryToIndex(entry); | |
16593 for (int i = 0; i < entrysize; ++i) { | |
16594 set_the_hole(index + i); | |
16595 } | |
16596 SetNumberOfElements(NumberOfElements() - 1); | |
16597 SetNumberOfDeletedElements(NumberOfDeletedElements() + 1); | |
16598 } | |
16599 | |
16600 | |
16601 template Handle<OrderedHashSet> | 16534 template Handle<OrderedHashSet> |
16602 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Allocate( | 16535 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Allocate( |
16603 Isolate* isolate, int capacity, PretenureFlag pretenure); | 16536 Isolate* isolate, int capacity, PretenureFlag pretenure); |
16604 | 16537 |
16605 template Handle<OrderedHashSet> | 16538 template Handle<OrderedHashSet> |
16606 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::EnsureGrowable( | 16539 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::EnsureGrowable( |
16607 Handle<OrderedHashSet> table); | 16540 Handle<OrderedHashSet> table); |
16608 | 16541 |
16609 template Handle<OrderedHashSet> | 16542 template Handle<OrderedHashSet> |
16610 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Shrink( | 16543 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Shrink( |
16611 Handle<OrderedHashSet> table); | 16544 Handle<OrderedHashSet> table); |
16612 | 16545 |
16613 template Handle<OrderedHashSet> | 16546 template Handle<OrderedHashSet> |
16614 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Clear( | 16547 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Clear( |
16615 Handle<OrderedHashSet> table); | 16548 Handle<OrderedHashSet> table); |
16616 | 16549 |
16617 template Handle<OrderedHashSet> | |
16618 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::Remove( | |
16619 Handle<OrderedHashSet> table, Handle<Object> key, bool* was_present); | |
16620 | |
16621 template int OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::FindEntry( | |
16622 Handle<Object> key, int hash); | |
16623 template int OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::FindEntry( | |
16624 Handle<Object> key); | |
16625 | |
16626 template int | |
16627 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::AddEntry(int hash); | |
16628 | |
16629 template void | |
16630 OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::RemoveEntry(int entry); | |
16631 | |
16632 | 16550 |
16633 template Handle<OrderedHashMap> | 16551 template Handle<OrderedHashMap> |
16634 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Allocate( | 16552 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Allocate( |
16635 Isolate* isolate, int capacity, PretenureFlag pretenure); | 16553 Isolate* isolate, int capacity, PretenureFlag pretenure); |
16636 | 16554 |
16637 template Handle<OrderedHashMap> | 16555 template Handle<OrderedHashMap> |
16638 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::EnsureGrowable( | 16556 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::EnsureGrowable( |
16639 Handle<OrderedHashMap> table); | 16557 Handle<OrderedHashMap> table); |
16640 | 16558 |
16641 template Handle<OrderedHashMap> | 16559 template Handle<OrderedHashMap> |
16642 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Shrink( | 16560 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Shrink( |
16643 Handle<OrderedHashMap> table); | 16561 Handle<OrderedHashMap> table); |
16644 | 16562 |
16645 template Handle<OrderedHashMap> | 16563 template Handle<OrderedHashMap> |
16646 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Clear( | 16564 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Clear( |
16647 Handle<OrderedHashMap> table); | 16565 Handle<OrderedHashMap> table); |
16648 | 16566 |
16649 template Handle<OrderedHashMap> | |
16650 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::Remove( | |
16651 Handle<OrderedHashMap> table, Handle<Object> key, bool* was_present); | |
16652 | |
16653 template int OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::FindEntry( | |
16654 Handle<Object> key, int hash); | |
16655 template int OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::FindEntry( | |
16656 Handle<Object> key); | |
16657 | |
16658 template int | |
16659 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::AddEntry(int hash); | |
16660 | |
16661 template void | |
16662 OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::RemoveEntry(int entry); | |
16663 | |
16664 | |
16665 bool OrderedHashSet::Contains(Handle<Object> key) { | |
16666 return FindEntry(key) != kNotFound; | |
16667 } | |
16668 | |
16669 | |
16670 Handle<OrderedHashSet> OrderedHashSet::Add(Handle<OrderedHashSet> table, | |
16671 Handle<Object> key) { | |
16672 int hash = GetOrCreateHash(table->GetIsolate(), key)->value(); | |
16673 if (table->FindEntry(key, hash) != kNotFound) return table; | |
16674 | |
16675 table = EnsureGrowable(table); | |
16676 | |
16677 int index = table->AddEntry(hash); | |
16678 table->set(index, *key); | |
16679 return table; | |
16680 } | |
16681 | |
16682 | |
16683 Object* OrderedHashMap::Lookup(Handle<Object> key) { | |
16684 DisallowHeapAllocation no_gc; | |
16685 int entry = FindEntry(key); | |
16686 if (entry == kNotFound) return GetHeap()->the_hole_value(); | |
16687 return ValueAt(entry); | |
16688 } | |
16689 | |
16690 | |
16691 Handle<OrderedHashMap> OrderedHashMap::Put(Handle<OrderedHashMap> table, | |
16692 Handle<Object> key, | |
16693 Handle<Object> value) { | |
16694 DCHECK(!key->IsTheHole()); | |
16695 | |
16696 int hash = GetOrCreateHash(table->GetIsolate(), key)->value(); | |
16697 int entry = table->FindEntry(key, hash); | |
16698 | |
16699 if (entry != kNotFound) { | |
16700 table->set(table->EntryToIndex(entry) + kValueOffset, *value); | |
16701 return table; | |
16702 } | |
16703 | |
16704 table = EnsureGrowable(table); | |
16705 | |
16706 int index = table->AddEntry(hash); | |
16707 table->set(index, *key); | |
16708 table->set(index + kValueOffset, *value); | |
16709 return table; | |
16710 } | |
16711 | |
16712 | 16567 |
16713 template<class Derived, class TableType> | 16568 template<class Derived, class TableType> |
16714 void OrderedHashTableIterator<Derived, TableType>::Transition() { | 16569 void OrderedHashTableIterator<Derived, TableType>::Transition() { |
16715 DisallowHeapAllocation no_allocation; | 16570 DisallowHeapAllocation no_allocation; |
16716 TableType* table = TableType::cast(this->table()); | 16571 TableType* table = TableType::cast(this->table()); |
16717 if (!table->IsObsolete()) return; | 16572 if (!table->IsObsolete()) return; |
16718 | 16573 |
16719 int index = Smi::cast(this->index())->value(); | 16574 int index = Smi::cast(this->index())->value(); |
16720 while (table->IsObsolete()) { | 16575 while (table->IsObsolete()) { |
16721 TableType* next_table = table->NextTable(); | 16576 TableType* next_table = table->NextTable(); |
(...skipping 622 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
17344 CompilationInfo* info) { | 17199 CompilationInfo* info) { |
17345 Handle<DependentCode> codes = DependentCode::InsertCompilationInfo( | 17200 Handle<DependentCode> codes = DependentCode::InsertCompilationInfo( |
17346 handle(cell->dependent_code(), info->isolate()), | 17201 handle(cell->dependent_code(), info->isolate()), |
17347 DependentCode::kPropertyCellChangedGroup, info->object_wrapper()); | 17202 DependentCode::kPropertyCellChangedGroup, info->object_wrapper()); |
17348 if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes); | 17203 if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes); |
17349 info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add( | 17204 info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add( |
17350 cell, info->zone()); | 17205 cell, info->zone()); |
17351 } | 17206 } |
17352 | 17207 |
17353 } } // namespace v8::internal | 17208 } } // namespace v8::internal |
OLD | NEW |