Lines Matching defs:Hash
786 self->Hash(); // Force regeneration of the hash value.
834 self->Hash(); // Force regeneration of the hash value.
2413 int index = Hash(fast) % kEntries;
2452 int NormalizedMapCache::Hash(Map* fast) {
2453 // For performance reasons we only hash the 3 most variable fields of a map:
2457 int hash = (static_cast<uint32_t>(
2463 hash ^= (static_cast<uint32_t>(
2466 return hash ^ (hash >> 16) ^ fast->bit_field2();
3788 // a large number and therefore they need to go into a hash table. They are
3791 // Make sure that a hash table is allocated for the normal load code cache.
3953 // The key in the code cache hash table consists of the property name and the
3980 return name->Hash() ^ flags;
3983 uint32_t Hash() { return NameFlagsHashHelper(name_, flags_); }
4029 int entry = cache->FindInsertionEntry(key.Hash());
4321 uint32_t descriptor_hash = descriptor->GetKey()->Hash();
4327 if (key->Hash() > descriptor_hash || key == descriptor->GetKey()) {
4389 const uint32_t parent_hash = GetKey(i)->Hash();
4392 uint32_t child_hash = GetKey(child_index)->Hash();
4394 uint32_t right_child_hash = GetKey(child_index + 1)->Hash();
4413 const uint32_t parent_hash = GetKey(parent_index)->Hash();
4417 uint32_t child_hash = GetKey(child_index)->Hash();
4419 uint32_t right_child_hash = GetKey(child_index + 1)->Hash();
4440 uint32_t hash = name->Hash();
4445 uint32_t mid_hash = mid_name->Hash();
4447 if (mid_hash > hash) {
4451 if (mid_hash < hash) {
4455 // Found an element with the same hash-code.
4456 ASSERT(hash == mid_hash);
4460 while ((mid > low) && (GetKey(mid - 1)->Hash() == hash)) mid--;
4461 for (; (mid <= high) && (GetKey(mid)->Hash() == hash); mid++) {
4471 uint32_t hash = name->Hash();
4474 if ((entry->Hash() == hash) &&
5383 // Fast check: if hash code is computed for both strings
5386 if (Hash() != other->Hash()) return false;
5502 // Should only be called if hash code has not yet been computed.
5507 // Compute the hash code.
5518 // Store the hash code in the object.
5521 // Check the hash code is there.
5524 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
5561 Hash(); // force computation of hash code
5564 // Isolate the array index form the full hash field.
5575 // For array indexes mix the length into the hash as an array index could
5609 // Very long strings have a trivial hash that doesn't inspect the
5731 uint32_t hash = 0;
5735 if (source->IsUndefined()) hash = String::cast(source)->Hash();
5737 hash ^= ComputeIntegerHash(shared()->start_position_and_type());
5738 hash += ComputeIntegerHash(shared()->end_position());
5739 return hash;
8460 // We know that all entries in a hash table had their hash keys created.
8468 uint32_t Hash() { return hash_; }
8470 uint32_t HashForObject(Object* other) { return String::cast(other)->Hash(); }
8504 uint32_t hash = source->Hash();
8506 // Instead of using the SharedFunctionInfo pointer in the hash
8507 // code computation, we use a combination of the hash of the
8512 hash ^= String::cast(script->source())->Hash();
8513 if (strict_mode == kStrictMode) hash ^= 0x8000;
8514 hash += shared->start_position();
8516 return hash;
8519 uint32_t Hash() {
8558 // Rather than storing the key in the hash table, a pointer to the
8568 uint32_t Hash() { return RegExpHash(string_, flags_); }
8571 // Plain hash maps, which is where regexp keys are used, don't
8584 return string->Hash() + flags->value();
8601 uint32_t Hash() {
8608 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
8613 return String::cast(other)->Hash();
8617 if (hash_field_ == 0) Hash();
8624 int chars_; // Caches the number of characters when computing the hash code.
8634 uint32_t Hash() {
8637 // Very long strings have a trivial hash that doesn't inspect the
8660 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
8666 return String::cast(other)->Hash();
8685 Hash();
8701 if (hash_field_ == 0) Hash();
8717 uint32_t Hash() { return string_->Hash(); }
8720 return String::cast(other)->Hash();
8743 return String::cast(obj)->Hash();
8795 // 2. Avoid comparing hash codes in symbol to symbol comparision.
8802 // EnsureCapacity will guarantee the hash table is never full.
8804 uint32_t entry = FirstProbe(key->Hash(), capacity);
8864 uint32_t hash = Shape::HashForObject(key, k);
8866 EntryToIndex(table->FindInsertionEntry(hash));
8879 uint32_t HashTable<Shape, Key>::FindInsertionEntry(uint32_t hash) {
8881 uint32_t entry = FirstProbe(hash, capacity);
8883 // EnsureCapacity will guarantee the hash table is never full.
9363 // string hash calculation loop here for speed. Doesn't work if the two
9364 // characters form a decimal integer, since such strings have a different hash
9371 uint32_t hash = c1 + (c1 << 10);
9372 hash ^= hash >> 6;
9374 hash += c2;
9375 hash += hash << 10;
9376 hash ^= hash >> 6;
9378 hash += hash << 3;
9379 hash ^= hash >> 11;
9380 hash += hash << 15;
9381 if (hash == 0) hash = 27;
9388 // that we were passed two digits as characters, since the hash
9390 ASSERT_EQ(static_cast<int>(hasher.GetHash()), static_cast<int>(hash));
9392 hash_ = hash;
9403 uint32_t Hash() { return hash_; }
9406 return String::cast(key)->Hash();
9498 entry = table->FindInsertionEntry(key->Hash());
9542 int entry = cache->FindInsertionEntry(key.Hash());
9563 int entry = cache->FindInsertionEntry(key.Hash());
9588 int entry = cache->FindInsertionEntry(key.Hash());
9628 uint32_t Hash() { return HashForObject(symbols_); }
9633 uint32_t hash = 0;
9635 hash ^= String::cast(symbols->get(i))->Hash();
9637 return hash;
9663 int entry = cache->FindInsertionEntry(key.Hash());
9819 AddEntry(key, value, details, Shape::Hash(key));
9835 AddEntry(key, value, details, Shape::Hash(key));
9844 uint32_t hash) {
9851 uint32_t entry = Dictionary<Shape, Key>::FindInsertionEntry(hash);
