[objects] seed NumberDictionary (only ia32 now)

src/objects-inl.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2039 matching lines @@
 template<typename Shape, typename Key>
 int HashTable<Shape, Key>::FindEntry(Key key) {
   return FindEntry(GetIsolate(), key);
 }
 
 
 // Find entry for key otherwise return kNotFound.
 template<typename Shape, typename Key>
 int HashTable<Shape, Key>::FindEntry(Isolate* isolate, Key key) {
   uint32_t capacity = Capacity();
-  uint32_t entry = FirstProbe(Shape::Hash(key), capacity);
+  uint32_t entry = FirstProbe(Shape::Hash(key, GetHeap()->StringHashSeed()),

[Erik Corry, 2012/01/09 23:52:48]

isolate->heap() is faster than GetHeap()
If the arguments don't all fit on one line they should have a line each.

+                              capacity);
   uint32_t count = 1;
   // EnsureCapacity will guarantee the hash table is never full.
   while (true) {
     Object* element = KeyAt(entry);
     // Empty entry.
     if (element == isolate->heap()->raw_unchecked_undefined_value()) break;
     if (element != isolate->heap()->raw_unchecked_the_hole_value() &&
         Shape::IsMatch(key, element)) return entry;
     entry = NextProbe(entry, count++, capacity);
   }
@@ skipping 2457 matching lines @@
   FixedArray::set(index+2, details.AsSmi());
 }
 
 
 bool NumberDictionaryShape::IsMatch(uint32_t key, Object* other) {
   ASSERT(other->IsNumber());
   return key == static_cast<uint32_t>(other->Number());
 }
 
 
-uint32_t NumberDictionaryShape::Hash(uint32_t key) {
-  return ComputeIntegerHash(key);
+uint32_t NumberDictionaryShape::Hash(uint32_t key, uint32_t seed) {
+  return ComputeIntegerHash(key, seed);
 }
 
 
-uint32_t NumberDictionaryShape::HashForObject(uint32_t key, Object* other) {
+uint32_t NumberDictionaryShape::HashForObject(uint32_t key, uint32_t seed,

[Erik Corry, 2012/01/09 23:52:48]

Formatting.

+                                              Object* other) {
   ASSERT(other->IsNumber());
-  return ComputeIntegerHash(static_cast<uint32_t>(other->Number()));
+  return ComputeIntegerHash(static_cast<uint32_t>(other->Number()), seed);
 }
 
 
 MaybeObject* NumberDictionaryShape::AsObject(uint32_t key) {
   return Isolate::Current()->heap()->NumberFromUint32(key);
 }
 
 
 bool StringDictionaryShape::IsMatch(String* key, Object* other) {
   // We know that all entries in a hash table had their hash keys created.
   // Use that knowledge to have fast failure.
   if (key->Hash() != String::cast(other)->Hash()) return false;
   return key->Equals(String::cast(other));
 }
 
 
-uint32_t StringDictionaryShape::Hash(String* key) {
+uint32_t StringDictionaryShape::Hash(String* key, uint32_t) {
   return key->Hash();
 }
 
 
-uint32_t StringDictionaryShape::HashForObject(String* key, Object* other) {
+uint32_t StringDictionaryShape::HashForObject(String* key, uint32_t,

[Erik Corry, 2012/01/09 23:52:48]

Formatting.

+                                              Object* other) {
   return String::cast(other)->Hash();
 }
 
 
 MaybeObject* StringDictionaryShape::AsObject(String* key) {
   return key;
 }
 
 
 template <int entrysize>
 bool ObjectHashTableShape<entrysize>::IsMatch(Object* key, Object* other) {
   return key->SameValue(other);
 }
 
 
 template <int entrysize>
-uint32_t ObjectHashTableShape<entrysize>::Hash(Object* key) {
+uint32_t ObjectHashTableShape<entrysize>::Hash(Object* key, uint32_t) {
   MaybeObject* maybe_hash = key->GetHash(OMIT_CREATION);
   return Smi::cast(maybe_hash->ToObjectChecked())->value();
 }
 
 
 template <int entrysize>
 uint32_t ObjectHashTableShape<entrysize>::HashForObject(Object* key,
+                                                        uint32_t,
                                                         Object* other) {
   MaybeObject* maybe_hash = other->GetHash(OMIT_CREATION);
   return Smi::cast(maybe_hash->ToObjectChecked())->value();
 }
 
 
 template <int entrysize>
 MaybeObject* ObjectHashTableShape<entrysize>::AsObject(Object* key) {
   return key;
 }
@@ skipping 167 matching lines @@
 #undef WRITE_INT_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_