[objects] seed NumberDictionary (only ia32 now)

src/objects.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 2736 matching lines @@
   MUST_USE_RESULT virtual MaybeObject* AsObject() = 0;
   // Required.
   virtual ~HashTableKey() {}
 };
 
 class SymbolTableShape {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
-  static inline uint32_t Hash(HashTableKey* key) {
+  static inline uint32_t Hash(HashTableKey* key, uint32_t) {
     return key->Hash();
   }
-  static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
+  static inline uint32_t HashForObject(HashTableKey* key, uint32_t,

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

Formatting.

+                                       Object* object) {
     return key->HashForObject(object);
   }
   MUST_USE_RESULT static inline MaybeObject* AsObject(HashTableKey* key) {
     return key->AsObject();
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 1;
 };
 
@@ skipping 35 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SymbolTable);
 };
 
 
 class MapCacheShape {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
-  static inline uint32_t Hash(HashTableKey* key) {
+  static inline uint32_t Hash(HashTableKey* key, uint32_t) {
     return key->Hash();
   }
 
-  static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
+  static inline uint32_t HashForObject(HashTableKey* key, uint32_t,

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

Formatting.

+                                       Object* object) {
     return key->HashForObject(object);
   }
 
   MUST_USE_RESULT static inline MaybeObject* AsObject(HashTableKey* key) {
     return key->AsObject();
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 2;
 };
@@ skipping 129 matching lines @@
   MUST_USE_RESULT MaybeObject* GenerateNewEnumerationIndices();
   static const int kMaxNumberKeyIndex =
       HashTable<Shape, Key>::kPrefixStartIndex;
   static const int kNextEnumerationIndexIndex = kMaxNumberKeyIndex + 1;
 };
 
 
 class StringDictionaryShape {
  public:
   static inline bool IsMatch(String* key, Object* other);
-  static inline uint32_t Hash(String* key);
-  static inline uint32_t HashForObject(String* key, Object* object);
+  static inline uint32_t Hash(String* key, uint32_t);

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

Parameter should have a name.

I'm unhappy that we need a seed here, when the hash is got from the string.

+  static inline uint32_t HashForObject(String* key, uint32_t,

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

Formatting, and the parameter should have a name.

+                                       Object* object);
   MUST_USE_RESULT static inline MaybeObject* AsObject(String* key);
   static const int kPrefixSize = 2;
   static const int kEntrySize = 3;
   static const bool kIsEnumerable = true;
 };
 
 
 class StringDictionary: public Dictionary<StringDictionaryShape, String*> {
  public:
   static inline StringDictionary* cast(Object* obj) {
@@ skipping 11 matching lines @@
 
   // Find entry for key, otherwise return kNotFound. Optimized version of
   // HashTable::FindEntry.
   int FindEntry(String* key);
 };
 
 
 class NumberDictionaryShape {
  public:
   static inline bool IsMatch(uint32_t key, Object* other);
-  static inline uint32_t Hash(uint32_t key);
-  static inline uint32_t HashForObject(uint32_t key, Object* object);
+  static inline uint32_t Hash(uint32_t key, uint32_t seed);
+  static inline uint32_t HashForObject(uint32_t key, uint32_t seed,

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

Formatting.

+                                       Object* object);
   MUST_USE_RESULT static inline MaybeObject* AsObject(uint32_t key);
   static const int kPrefixSize = 2;
   static const int kEntrySize = 3;
   static const bool kIsEnumerable = false;
 };
 
 
 class NumberDictionary: public Dictionary<NumberDictionaryShape, uint32_t> {
  public:
   static NumberDictionary* cast(Object* obj) {
@@ skipping 38 matching lines @@
   static const int kRequiresSlowElementsMask = 1;
   static const int kRequiresSlowElementsTagSize = 1;
   static const uint32_t kRequiresSlowElementsLimit = (1 << 29) - 1;
 };
 
 
 template <int entrysize>
 class ObjectHashTableShape {
  public:
   static inline bool IsMatch(Object* key, Object* other);
-  static inline uint32_t Hash(Object* key);
-  static inline uint32_t HashForObject(Object* key, Object* object);
+  static inline uint32_t Hash(Object* key, uint32_t);

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

Names for arguments x2

+  static inline uint32_t HashForObject(Object* key, uint32_t, Object* object);
   MUST_USE_RESULT static inline MaybeObject* AsObject(Object* key);
   static const int kPrefixSize = 0;
   static const int kEntrySize = entrysize;
 };
 
 
 // ObjectHashSet holds keys that are arbitrary objects by using the identity
 // hash of the key for hashing purposes.
 class ObjectHashSet: public HashTable<ObjectHashTableShape<1>, Object*> {
  public:
@@ skipping 2893 matching lines @@
   static const int kCodeAgeMask = 0xff;
 };
 
 
 class CompilationCacheShape {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
 
-  static inline uint32_t Hash(HashTableKey* key) {
+  static inline uint32_t Hash(HashTableKey* key, uint32_t) {
     return key->Hash();
   }
 
-  static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
+  static inline uint32_t HashForObject(HashTableKey* key, uint32_t,
+                                       Object* object) {
     return key->HashForObject(object);
   }
 
   MUST_USE_RESULT static MaybeObject* AsObject(HashTableKey* key) {
     return key->AsObject();
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 2;
 };
@@ skipping 79 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCache);
 };
 
 
 class CodeCacheHashTableShape {
  public:
   static inline bool IsMatch(HashTableKey* key, Object* value) {
     return key->IsMatch(value);
   }
 
-  static inline uint32_t Hash(HashTableKey* key) {
+  static inline uint32_t Hash(HashTableKey* key, uint32_t) {
     return key->Hash();
   }
 
-  static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
+  static inline uint32_t HashForObject(HashTableKey* key, uint32_t,
+                                       Object* object) {
     return key->HashForObject(object);
   }
 
   MUST_USE_RESULT static MaybeObject* AsObject(HashTableKey* key) {
     return key->AsObject();
   }
 
   static const int kPrefixSize = 0;
   static const int kEntrySize = 2;
 };
@@ skipping 1975 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_