[objects] NotSeededNumberDictionary

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 2054 matching lines @@
     // 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);
   }
   return kNotFound;
 }
 
 
-bool NumberDictionary::requires_slow_elements() {
-  Object* max_index_object = get(kMaxNumberKeyIndex);
+bool NumberDictionaryBase::requires_slow_elements() {
+  Object* max_index_object = as_dict()->get(
+      NumberDictionary::kMaxNumberKeyIndex);
   if (!max_index_object->IsSmi()) return false;
   return 0 !=
-      (Smi::cast(max_index_object)->value() & kRequiresSlowElementsMask);
+      (Smi::cast(max_index_object)->value() &
+       NumberDictionary::kRequiresSlowElementsMask);
 }
 
-uint32_t NumberDictionary::max_number_key() {
+uint32_t NumberDictionaryBase::max_number_key() {
   ASSERT(!requires_slow_elements());
-  Object* max_index_object = get(kMaxNumberKeyIndex);
+  Object* max_index_object = as_dict()->get(
+      NumberDictionary::kMaxNumberKeyIndex);
   if (!max_index_object->IsSmi()) return 0;
   uint32_t value = static_cast<uint32_t>(Smi::cast(max_index_object)->value());
-  return value >> kRequiresSlowElementsTagSize;
+  return value >> NumberDictionary::kRequiresSlowElementsTagSize;
 }
 
-void NumberDictionary::set_requires_slow_elements() {
-  set(kMaxNumberKeyIndex, Smi::FromInt(kRequiresSlowElementsMask));
+void NumberDictionaryBase::set_requires_slow_elements() {
+  as_dict()->set(
+      NumberDictionary::kMaxNumberKeyIndex,
+      Smi::FromInt(NumberDictionary::kRequiresSlowElementsMask));
 }
 
 
 // ------------------------------------
 // Cast operations
 
 
 CAST_ACCESSOR(FixedArray)
 CAST_ACCESSOR(FixedDoubleArray)
 CAST_ACCESSOR(DescriptorArray)
@@ skipping 2423 matching lines @@
   ASSERT(!key->IsString() || details.IsDeleted() || details.index() > 0);
   int index = HashTable<Shape, Key>::EntryToIndex(entry);
   AssertNoAllocation no_gc;
   WriteBarrierMode mode = FixedArray::GetWriteBarrierMode(no_gc);
   FixedArray::set(index, key, mode);
   FixedArray::set(index+1, value, mode);
   FixedArray::set(index+2, details.AsSmi());
 }
 
 
-bool NumberDictionaryShape::IsMatch(uint32_t key, Object* other) {
+template <NumberDictionaryKind kind>
+bool NumberDictionaryShape<kind>::IsMatch(uint32_t key, Object* other) {
   ASSERT(other->IsNumber());
   return key == static_cast<uint32_t>(other->Number());
 }
 
 
-uint32_t NumberDictionaryShape::Hash(uint32_t key) {
-  // This function is unreachable, since shape has UsesSeed=true flag.
-  UNREACHABLE();
-  return 0;
+template <NumberDictionaryKind kind>
+uint32_t NumberDictionaryShape<kind>::Hash(uint32_t key) {
+  return ComputeIntegerHash(key, 0);
 }
 
 
-uint32_t NumberDictionaryShape::HashForObject(uint32_t key, Object* other) {
-  // This function is unreachable, since shape has UsesSeed=true flag.
-  UNREACHABLE();
-  return 0;
+template <NumberDictionaryKind kind>
+uint32_t NumberDictionaryShape<kind>::HashForObject(uint32_t key,
+                                                    Object* other) {
+  ASSERT(other->IsNumber());
+  return ComputeIntegerHash(static_cast<uint32_t>(other->Number()), 0);
 }
 
-uint32_t NumberDictionaryShape::SeededHash(uint32_t key, uint32_t seed) {
+
+template <NumberDictionaryKind kind>
+uint32_t NumberDictionaryShape<kind>::SeededHash(uint32_t key, uint32_t seed) {
   return ComputeIntegerHash(key, seed);
 }
 
-uint32_t NumberDictionaryShape::SeededHashForObject(uint32_t key,
-                                                    uint32_t seed,
-                                                    Object* other) {
+
+template <NumberDictionaryKind kind>
+uint32_t NumberDictionaryShape<kind>::SeededHashForObject(uint32_t key,
+                                                          uint32_t seed,
+                                                          Object* other) {
   ASSERT(other->IsNumber());
   return ComputeIntegerHash(static_cast<uint32_t>(other->Number()), seed);
 }
 
-MaybeObject* NumberDictionaryShape::AsObject(uint32_t key) {
+
+template <NumberDictionaryKind kind>
+MaybeObject* NumberDictionaryShape<kind>::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));
 }
@@ skipping 209 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_