Refactor how elements are redefined by the runtime.

src/elements.cc

 // 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 73 matching lines @@
   static MaybeObject* Get(BackingStoreClass* backing_store,
                           uint32_t key,
                           JSObject* obj,
                           Object* receiver) {
     if (key < ElementsAccessorSubclass::GetCapacity(backing_store)) {
       return backing_store->get(key);
     }
     return backing_store->GetHeap()->the_hole_value();
   }
 
+  virtual MaybeObject* Set(JSObject* obj,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes) = 0;

[danno, 2011/10/24 21:09:02]

Use CRTP here. The virtual Set method should call the static Set method that is
specialized by the subclasses. 

+
+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,

[danno, 2011/10/24 21:09:02]

Can you get away with a single Set wrapper in the common base class that handles
setting elements based on the return result of SetInternal, and only have a
single method that needs to be implemented in subclasses? 

+                                   uint32_t index,
+                                   Object* value,
+                                   PropertyAttributes attributes) = 0;
+
   virtual MaybeObject* Delete(JSObject* obj,
                               uint32_t key,
                               JSReceiver::DeleteMode mode) = 0;
 
   virtual MaybeObject* AddElementsToFixedArray(FixedArrayBase* from,
                                                FixedArray* to,
                                                JSObject* holder,
                                                Object* receiver) {
     int len0 = to->length();
 #ifdef DEBUG
@@ skipping 161 matching lines @@
         if (4 * num_used <= backing_store->length()) {
           MaybeObject* result = obj->NormalizeElements();
           if (result->IsFailure()) return result;
         }
       }
     }
     return heap->true_value();
   }
 
  protected:
+  virtual MaybeObject* Set(JSObject* obj,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes) {
+    // Normalize the elements to enable attributes on the element and make
+    // sure that we never go back to fast case.
+    if (attributes != NONE && attributes != ABSENT) {
+      MaybeObject* maybe_dictionary = obj->NormalizeElements();
+      NumberDictionary* dictionary;
+      if (!maybe_dictionary->To(&dictionary)) {
+        return maybe_dictionary;
+      }
+      dictionary->set_requires_slow_elements();
+      return ForKind(DICTIONARY_ELEMENTS)->Set(obj, key, value, attributes);
+    }
+
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,
+                                   uint32_t index,
+                                   Object* value,
+                                   PropertyAttributes attributes) {
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
   virtual MaybeObject* Delete(JSObject* obj,
                               uint32_t key,
                               JSReceiver::DeleteMode mode) {
     return DeleteCommon(obj, key);
   }
 };
 
 
 class FastDoubleElementsAccessor
     : public ElementsAccessorBase<FastDoubleElementsAccessor,
                                   FixedDoubleArray> {
  protected:
   friend class ElementsAccessorBase<FastDoubleElementsAccessor,
                                     FixedDoubleArray>;
 
+  virtual MaybeObject* Set(JSObject* obj,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes) {
+    // Normalize the elements to enable attributes on the element and make
+    // sure that we never go back to fast case.
+    if (attributes != NONE && attributes != ABSENT) {
+      MaybeObject* maybe_dictionary = obj->NormalizeElements();
+      NumberDictionary* dictionary;
+      if (!maybe_dictionary->To(&dictionary)) {
+        return maybe_dictionary;
+      }
+      dictionary->set_requires_slow_elements();
+      return ForKind(DICTIONARY_ELEMENTS)->Set(obj, key, value, attributes);
+    }
+
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,
+                                   uint32_t index,
+                                   Object* value,
+                                   PropertyAttributes attributes) {
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
   virtual MaybeObject* Delete(JSObject* obj,
                               uint32_t key,
                               JSReceiver::DeleteMode mode) {
     int length = obj->IsJSArray()
         ? Smi::cast(JSArray::cast(obj)->length())->value()
         : FixedDoubleArray::cast(obj->elements())->length();
     if (key < static_cast<uint32_t>(length)) {
       FixedDoubleArray::cast(obj->elements())->set_the_hole(key);
     }
     return obj->GetHeap()->true_value();
@@ skipping 22 matching lines @@
                           uint32_t key,
                           JSObject* obj,
                           Object* receiver) {
     if (key < ExternalElementsAccessorSubclass::GetCapacity(backing_store)) {
       return backing_store->get(key);
     } else {
       return backing_store->GetHeap()->undefined_value();
     }
   }
 
+  virtual MaybeObject* Set(JSObject* obj,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes) {
+    // There is no way to set attributes for external elements.
+    ASSERT(attributes == NONE || attributes == ABSENT);
+
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,
+                                   uint32_t index,
+                                   Object* value,
+                                   PropertyAttributes attributes) {
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
   virtual MaybeObject* Delete(JSObject* obj,
                               uint32_t key,
                               JSReceiver::DeleteMode mode) {
     // External arrays always ignore deletes.
     return obj->GetHeap()->true_value();
   }
 };
 
 
 class ExternalByteElementsAccessor
@@ skipping 95 matching lines @@
         return isolate->Throw(*error);
       }
     }
     return heap->true_value();
   }
 
  protected:
   friend class ElementsAccessorBase<DictionaryElementsAccessor,
                                     NumberDictionary>;
 
+  virtual MaybeObject* Set(JSObject* obj,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes) {
+    NumberDictionary* dictionary = NumberDictionary::cast(obj->elements());
+    MaybeObject* maybe_elements =
+        SetInternal(dictionary, key, value, attributes);
+    FixedArray* new_elements;
+    if (!maybe_elements->To(&new_elements)) {
+      return maybe_elements;
+    }
+    if (new_elements != dictionary) {
+      obj->set_elements(new_elements);
+    }
+    return value;
+  }
+
+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,
+                                   uint32_t key,
+                                   Object* value,
+                                   PropertyAttributes attributes) {
+    NumberDictionary* dictionary = NumberDictionary::cast(backing_store);
+    PropertyDetails details = PropertyDetails(attributes, NORMAL);
+    return dictionary->Set(key, value, details);
+  }
+
   virtual MaybeObject* Delete(JSObject* obj,
                               uint32_t key,
                               JSReceiver::DeleteMode mode) {
     return DeleteCommon(obj, key, mode);
   }
 
   static MaybeObject* Get(NumberDictionary* backing_store,
                           uint32_t key,
                           JSObject* obj,
                           Object* receiver) {
@@ skipping 41 matching lines @@
     } else {
       // Object is not mapped, defer to the arguments.
       FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
       return ElementsAccessor::ForArray(arguments)->Get(arguments,
                                                         key,
                                                         obj,
                                                         receiver);
     }
   }
 
+  virtual MaybeObject* Set(JSObject* obj,
+                           uint32_t key,
+                           Object* value,
+                           PropertyAttributes attributes) {
+    // Normalize the elements to enable attributes on the element and make
+    // sure that we never go back to fast case.
+    if (attributes != NONE && attributes != ABSENT) {
+      MaybeObject* maybe_dictionary = obj->NormalizeElements();
+      NumberDictionary* dictionary;
+      if (!maybe_dictionary->To(&dictionary)) {
+        return maybe_dictionary;
+      }
+      dictionary->set_requires_slow_elements();
+
+      // Object is not mapped, defer to the arguments.
+      FixedArray* parameter_map = FixedArray::cast(obj->elements());
+      FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
+      MaybeObject* maybe_elements = ElementsAccessor::ForArray(arguments)->
+          SetInternal(arguments, key, value, attributes);
+      FixedArray* new_elements;
+      if (!maybe_elements->To(&new_elements)) {
+        return maybe_elements;
+      }
+      if (new_elements != arguments) {
+        parameter_map->set(1, new_elements);
+      }
+
+      return value;
+    }
+
+    // TODO(mstarzinger): Not yet implemented.
+    UNREACHABLE();
+    return NULL;
+  }
+
+  virtual MaybeObject* SetInternal(FixedArrayBase* backing_store,
+                                   uint32_t index,
+                                   Object* value,
+                                   PropertyAttributes attributes) {
+    // The non-strict arguments object itself cannot be a backing store.
+    UNREACHABLE();
+    return NULL;
+  }
+
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t key
-                              ,
+                              uint32_t key,
                               JSReceiver::DeleteMode mode) {
     FixedArray* parameter_map = FixedArray::cast(obj->elements());
     Object* probe = GetParameterMapArg(parameter_map, key);
     if (!probe->IsTheHole()) {
       // TODO(kmillikin): We could check if this was the last aliased
       // parameter, and revert to normal elements in that case.  That
       // would enable GC of the context.
       parameter_map->set_the_hole(key + 2);
     } else {
       FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
@@ skipping 113 matching lines @@
   };
 
   STATIC_ASSERT((sizeof(accessor_array) / sizeof(*accessor_array)) ==
                 kElementsKindCount);
 
   elements_accessors_ = accessor_array;
 }
 
 
 } }  // namespace v8::internal