Implement UnionOfKeys for NonStrictArguments

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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "objects.h"
 #include "elements.h"
+#include "utils.h"
 
 namespace v8 {
 namespace internal {
 
 
 ElementsAccessor** ElementsAccessor::elements_accessors_;
 
 
 bool HasKey(FixedArray* array, Object* key) {
   int len0 = array->length();
@@ skipping 21 matching lines @@
 //                                   BackingStoreClass> {
 //     ...
 //   }
 //
 // This is an example of the Curiously Recurring Template Pattern (see
 // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern).  We use
 // CRTP to guarantee aggressive compile time optimizations (i.e.  inlining and
 // specialization of SomeElementsAccessor methods).
 template <typename ElementsAccessorSubclass, typename BackingStoreClass>
 class ElementsAccessorBase : public ElementsAccessor {
- public:
+ protected:
   ElementsAccessorBase() { }
   virtual MaybeObject* GetWithReceiver(JSObject* obj,
                                        Object* receiver,
-                                       uint32_t index) {
+                                       uint32_t key) {
     BackingStoreClass* backing_store = BackingStoreClass::cast(obj->elements());
-    if (index < ElementsAccessorSubclass::GetLength(backing_store)) {
-      return backing_store->get(index);
+    if (key < ElementsAccessorSubclass::GetCapacity(backing_store)) {
+      return backing_store->get(key);
     }
     return obj->GetHeap()->the_hole_value();
   }
 
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t index,
+                              uint32_t key,
                               JSReceiver::DeleteMode mode) = 0;
 
   virtual MaybeObject* AddElementsToFixedArray(FixedArrayBase* from,
                                                FixedArray* to) {
     int len0 = to->length();
 #ifdef DEBUG
     if (FLAG_enable_slow_asserts) {
       for (int i = 0; i < len0; i++) {
         ASSERT(!to->get(i)->IsTheHole());
       }
     }
 #endif
     BackingStoreClass* backing_store = BackingStoreClass::cast(from);
-    int len1 = ElementsAccessorSubclass::GetCapacity(backing_store);
+    uint32_t len1 = ElementsAccessorSubclass::GetCapacity(backing_store);
 
     // Optimize if 'other' is empty.
     // We cannot optimize if 'this' is empty, as other may have holes.
     if (len1 == 0) return to;
 
     // Compute how many elements are not in other.
     int extra = 0;
-    for (int y = 0; y < len1; y++) {
-      Object* value;
-      MaybeObject* maybe_value =
-          ElementsAccessorSubclass::GetElementAtCapacityIndex(backing_store, y);
-      if (!maybe_value->ToObject(&value)) return maybe_value;
-      if (!value->IsTheHole() && !HasKey(to, value)) extra++;
+    for (uint32_t y = 0; y < len1; y++) {
+      if (ElementsAccessorSubclass::HasElementAtIndex(backing_store, y)) {
+        uint32_t key =
+            ElementsAccessorSubclass::GetKeyForIndex(backing_store, y);
+        MaybeObject* maybe_value =
+            ElementsAccessorSubclass::GetElement(backing_store, key);
+        Object* value;
+        if (!maybe_value->ToObject(&value)) return maybe_value;
+        ASSERT(!value->IsTheHole());
+        if (!HasKey(to, value)) {
+          extra++;
+        }
+      }
     }
 
     if (extra == 0) return to;
 
     // Allocate the result
     FixedArray* result;
     MaybeObject* maybe_obj =
         backing_store->GetHeap()->AllocateFixedArray(len0 + extra);
     if (!maybe_obj->To<FixedArray>(&result)) return maybe_obj;
 
     // Fill in the content
     {
       AssertNoAllocation no_gc;
       WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
       for (int i = 0; i < len0; i++) {
         Object* e = to->get(i);
         ASSERT(e->IsString() || e->IsNumber());
         result->set(i, e, mode);
       }
     }
     // Fill in the extra values.
     int index = 0;
-    for (int y = 0; y < len1; y++) {
-      MaybeObject* maybe_value =
-          ElementsAccessorSubclass::GetElementAtCapacityIndex(backing_store, y);
-      Object* value;
-      if (!maybe_value->ToObject(&value)) return maybe_value;
-      if (!value->IsTheHole() && !HasKey(to, value)) {
-        result->set(len0 + index, value);
-        index++;
+    for (uint32_t y = 0; y < len1; y++) {
+      if (ElementsAccessorSubclass::HasElementAtIndex(backing_store, y)) {
+        uint32_t key =
+            ElementsAccessorSubclass::GetKeyForIndex(backing_store, y);
+        MaybeObject* maybe_value =
+            ElementsAccessorSubclass::GetElement(backing_store, key);
+        Object* value;
+        if (!maybe_value->ToObject(&value)) return maybe_value;
+        if (!value->IsTheHole() && !HasKey(to, value)) {
+          result->set(len0 + index, value);
+          index++;
+        }
       }
     }
     ASSERT(extra == index);
     return result;
   }
 
-  static uint32_t GetLength(BackingStoreClass* backing_store) {
+ protected:
+  static uint32_t GetCapacity(BackingStoreClass* backing_store) {
     return backing_store->length();
   }
 
-  static uint32_t GetCapacity(BackingStoreClass* backing_store) {
-    return GetLength(backing_store);
+  virtual uint32_t GetCapacity(FixedArrayBase* backing_store) {
+    return ElementsAccessorSubclass::GetCapacity(
+        BackingStoreClass::cast(backing_store));
   }
 
-  static MaybeObject* GetElementAtCapacityIndex(
+  static MaybeObject* GetElement(
       BackingStoreClass* backing_store,
-      int index) {
-    return backing_store->get(index);
+      uint32_t key) {
+    return backing_store->get(key);
+  }
+
+  virtual MaybeObject* GetElement(FixedArrayBase* backing_store,
+                                  uint32_t key) {
+    return ElementsAccessorSubclass::GetElement(
+        BackingStoreClass::cast(backing_store), key);
+  }
+
+  static bool HasElementAtIndex(BackingStoreClass* backing_store,
+                                uint32_t index) {
+    uint32_t key =
+        ElementsAccessorSubclass::GetKeyForIndex(backing_store, index);
+    MaybeObject* element = ElementsAccessorSubclass::GetElement(backing_store,
+                                                                key);
+    return !element->IsTheHole();
+  }
+
+  virtual bool HasElementAtIndex(FixedArrayBase* backing_store,
+                                 uint32_t index) {
+    return ElementsAccessorSubclass::HasElementAtIndex(
+        BackingStoreClass::cast(backing_store), index);
+  }
+
+  static uint32_t GetKeyForIndex(BackingStoreClass* backing_store,
+                                         uint32_t index) {
+    return index;
+  }
+
+  virtual uint32_t GetKeyForIndex(FixedArrayBase* backing_store,
+                                              uint32_t index) {
+    return ElementsAccessorSubclass::GetKeyForIndex(
+        BackingStoreClass::cast(backing_store), index);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ElementsAccessorBase);
 };
 
 
 class FastElementsAccessor
     : public ElementsAccessorBase<FastElementsAccessor, FixedArray> {
  public:
   static MaybeObject* DeleteCommon(JSObject* obj,
-                                   uint32_t index) {
+                                   uint32_t key) {
     ASSERT(obj->HasFastElements() || obj->HasFastArgumentsElements());
     Heap* heap = obj->GetHeap();
     FixedArray* backing_store = FixedArray::cast(obj->elements());
     if (backing_store->map() == heap->non_strict_arguments_elements_map()) {
       backing_store = FixedArray::cast(backing_store->get(1));
     } else {
       Object* writable;
       MaybeObject* maybe = obj->EnsureWritableFastElements();
       if (!maybe->ToObject(&writable)) return maybe;
       backing_store = FixedArray::cast(writable);
     }
     uint32_t length = static_cast<uint32_t>(
         obj->IsJSArray()
         ? Smi::cast(JSArray::cast(obj)->length())->value()
         : backing_store->length());
-    if (index < length) {
-      backing_store->set_the_hole(index);
+    if (key < length) {
+      backing_store->set_the_hole(key);
       // If an old space backing store is larger than a certain size and
       // has too few used values, normalize it.
       // To avoid doing the check on every delete we require at least
       // one adjacent hole to the value being deleted.
       Object* hole = heap->the_hole_value();
       const int kMinLengthForSparsenessCheck = 64;
       if (backing_store->length() >= kMinLengthForSparsenessCheck &&
           !heap->InNewSpace(backing_store) &&
-          ((index > 0 && backing_store->get(index - 1) == hole) ||
-           (index + 1 < length && backing_store->get(index + 1) == hole))) {
+          ((key > 0 && backing_store->get(key - 1) == hole) ||
+           (key + 1 < length && backing_store->get(key + 1) == hole))) {
         int num_used = 0;
         for (int i = 0; i < backing_store->length(); ++i) {
           if (backing_store->get(i) != hole) ++num_used;
           // Bail out early if more than 1/4 is used.
           if (4 * num_used > backing_store->length()) break;
         }
         if (4 * num_used <= backing_store->length()) {
           MaybeObject* result = obj->NormalizeElements();
           if (result->IsFailure()) return result;
         }
       }
     }
     return heap->true_value();
   }
 
+ protected:
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t index,
+                              uint32_t key,
                               JSReceiver::DeleteMode mode) {
-    return DeleteCommon(obj, index);
+    return DeleteCommon(obj, key);
   }
 };
 
 
 class FastDoubleElementsAccessor
     : public ElementsAccessorBase<FastDoubleElementsAccessor,
                                   FixedDoubleArray> {
+ protected:
+  friend class ElementsAccessorBase<FastDoubleElementsAccessor,
+                                    FixedDoubleArray>;
+
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t index,
+                              uint32_t key,
                               JSReceiver::DeleteMode mode) {
     int length = obj->IsJSArray()
         ? Smi::cast(JSArray::cast(obj)->length())->value()
         : FixedDoubleArray::cast(obj->elements())->length();
-    if (index < static_cast<uint32_t>(length)) {
-      FixedDoubleArray::cast(obj->elements())->set_the_hole(index);
+    if (key < static_cast<uint32_t>(length)) {
+      FixedDoubleArray::cast(obj->elements())->set_the_hole(key);
     }
     return obj->GetHeap()->true_value();
   }
+
+  static bool HasElementAtIndex(FixedDoubleArray* backing_store,
+                                uint32_t index) {
+    return !backing_store->is_the_hole(index);
+  }
 };
 
 
 // Super class for all external element arrays.
 template<typename ExternalElementsAccessorSubclass,
          typename ExternalArray>
 class ExternalElementsAccessor
     : public ElementsAccessorBase<ExternalElementsAccessorSubclass,
                                   ExternalArray> {
- public:
+ protected:
   virtual MaybeObject* GetWithReceiver(JSObject* obj,
                                        Object* receiver,
-                                       uint32_t index) {
+                                       uint32_t key) {
     ExternalArray* backing_store = ExternalArray::cast(obj->elements());
-    if (index < ExternalElementsAccessorSubclass::GetLength(backing_store)) {
-      return backing_store->get(index);
+    if (key < ExternalElementsAccessorSubclass::GetCapacity(backing_store)) {
+      return backing_store->get(key);
     } else {
       return obj->GetHeap()->undefined_value();
     }
   }
 
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t index,
+                              uint32_t key,
                               JSReceiver::DeleteMode mode) {
     // External arrays always ignore deletes.
     return obj->GetHeap()->true_value();
   }
 };
 
 
 class ExternalByteElementsAccessor
     : public ExternalElementsAccessor<ExternalByteElementsAccessor,
                                       ExternalByteArray> {
@@ skipping 49 matching lines @@
 
 
 class DictionaryElementsAccessor
     : public ElementsAccessorBase<DictionaryElementsAccessor,
                                   NumberDictionary> {
  public:
   static MaybeObject* GetNumberDictionaryElement(
       JSObject* obj,
       Object* receiver,
       NumberDictionary* backing_store,
-      uint32_t index) {
-    int entry = backing_store->FindEntry(index);
+      uint32_t key) {
+    int entry = backing_store->FindEntry(key);
     if (entry != NumberDictionary::kNotFound) {
       Object* element = backing_store->ValueAt(entry);
       PropertyDetails details = backing_store->DetailsAt(entry);
       if (details.type() == CALLBACKS) {
         return obj->GetElementWithCallback(receiver,
                                            element,
-                                           index,
+                                           key,
                                            obj);
       } else {
         return element;
       }
     }
     return obj->GetHeap()->the_hole_value();
   }
 
-
   static MaybeObject* DeleteCommon(JSObject* obj,
-                                   uint32_t index,
+                                   uint32_t key,
                                    JSReceiver::DeleteMode mode) {
     Isolate* isolate = obj->GetIsolate();
     Heap* heap = isolate->heap();
     FixedArray* backing_store = FixedArray::cast(obj->elements());
     bool is_arguments =
         (obj->GetElementsKind() == JSObject::NON_STRICT_ARGUMENTS_ELEMENTS);
     if (is_arguments) {
       backing_store = FixedArray::cast(backing_store->get(1));
     }
     NumberDictionary* dictionary = NumberDictionary::cast(backing_store);
-    int entry = dictionary->FindEntry(index);
+    int entry = dictionary->FindEntry(key);
     if (entry != NumberDictionary::kNotFound) {
       Object* result = dictionary->DeleteProperty(entry, mode);
       if (result == heap->true_value()) {
-        MaybeObject* maybe_elements = dictionary->Shrink(index);
+        MaybeObject* maybe_elements = dictionary->Shrink(key);
         FixedArray* new_elements = NULL;
         if (!maybe_elements->To(&new_elements)) {
           return maybe_elements;
         }
         if (is_arguments) {
           FixedArray::cast(obj->elements())->set(1, new_elements);
         } else {
           obj->set_elements(new_elements);
         }
       }
       if (mode == JSObject::STRICT_DELETION &&
           result == heap->false_value()) {
         // In strict mode, attempting to delete a non-configurable property
         // throws an exception.
         HandleScope scope(isolate);
         Handle<Object> holder(obj);
-        Handle<Object> name = isolate->factory()->NewNumberFromUint(index);
+        Handle<Object> name = isolate->factory()->NewNumberFromUint(key);
         Handle<Object> args[2] = { name, holder };
         Handle<Object> error =
             isolate->factory()->NewTypeError("strict_delete_property",
                                              HandleVector(args, 2));
         return isolate->Throw(*error);
       }
     }
     return heap->true_value();
   }
 
+ protected:
+  friend class ElementsAccessorBase<DictionaryElementsAccessor,
+                                    NumberDictionary>;
+
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t index,
+                              uint32_t key,
                               JSReceiver::DeleteMode mode) {
-    return DeleteCommon(obj, index, mode);
+    return DeleteCommon(obj, key, mode);
   }
 
   virtual MaybeObject* GetWithReceiver(JSObject* obj,
                                        Object* receiver,
-                                       uint32_t index) {
+                                       uint32_t key) {
     return GetNumberDictionaryElement(obj,
                                       receiver,
                                       obj->element_dictionary(),
-                                      index);
+                                      key);
   }
 
-  static uint32_t GetCapacity(NumberDictionary* dict) {
-    return dict->Capacity();
+  static uint32_t GetKeyForIndex(NumberDictionary* dict,
+                                 uint32_t index) {
+    Object* key = dict->KeyAt(index);
+    return Smi::cast(key)->value();
   }
 
-  static MaybeObject* GetElementAtCapacityIndex(NumberDictionary* dict,
-                                                int index) {
-    if (dict->IsKey(dict->KeyAt(index))) {
-      return dict->ValueAt(index);
+  static MaybeObject* GetElement(NumberDictionary* dict,
+                                 int key) {
+    int entry = dict->FindEntry(key);
+    if (entry != NumberDictionary::kNotFound) {
+      return dict->ValueAt(entry);
     } else {
       return dict->GetHeap()->the_hole_value();
     }
   }
 };
 
 
 class NonStrictArgumentsElementsAccessor
     : public ElementsAccessorBase<NonStrictArgumentsElementsAccessor,
                                   FixedArray> {
- public:
+ protected:
+  friend class ElementsAccessorBase<NonStrictArgumentsElementsAccessor,
+                                    FixedArray>;
+
   virtual MaybeObject* GetWithReceiver(JSObject* obj,
                                        Object* receiver,
-                                       uint32_t index) {
+                                       uint32_t key) {
     FixedArray* parameter_map = FixedArray::cast(obj->elements());
-    uint32_t length = parameter_map->length();
-    Object* probe =
-        (index < length - 2) ? parameter_map->get(index + 2) : NULL;
-    if (probe != NULL && !probe->IsTheHole()) {
+    Object* probe = GetParameterMapArg(parameter_map, key);
+    if (!probe->IsTheHole()) {
       Context* context = Context::cast(parameter_map->get(0));
       int context_index = Smi::cast(probe)->value();
       ASSERT(!context->get(context_index)->IsTheHole());
       return context->get(context_index);
     } else {
       // Object is not mapped, defer to the arguments.
       FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
       if (arguments->IsDictionary()) {
         return DictionaryElementsAccessor::GetNumberDictionaryElement(
             obj,
             receiver,
             NumberDictionary::cast(arguments),
-            index);
-      } else if (index < static_cast<uint32_t>(arguments->length())) {
-        return arguments->get(index);
+            key);
+      } else if (key < static_cast<uint32_t>(arguments->length())) {
+        return arguments->get(key);
       }
     }
     return obj->GetHeap()->the_hole_value();
   }
 
   virtual MaybeObject* Delete(JSObject* obj,
-                              uint32_t index,
+                              uint32_t key
+                              ,
                               JSReceiver::DeleteMode mode) {
     FixedArray* parameter_map = FixedArray::cast(obj->elements());
-    uint32_t length = parameter_map->length();
-    Object* probe =
-        index < (length - 2) ? parameter_map->get(index + 2) : NULL;
-    if (probe != NULL && !probe->IsTheHole()) {
+    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(index + 2);
+      parameter_map->set_the_hole(key + 2);
     } else {
       FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
       if (arguments->IsDictionary()) {
-        return DictionaryElementsAccessor::DeleteCommon(obj, index, mode);
+        return DictionaryElementsAccessor::DeleteCommon(obj, key, mode);
       } else {
-        return FastElementsAccessor::DeleteCommon(obj, index);
+        return FastElementsAccessor::DeleteCommon(obj, key);
       }
     }
     return obj->GetHeap()->true_value();
   }
 
-  static uint32_t GetCapacity(FixedArray* obj) {
-    // TODO(danno): Return max of parameter map length or backing store
-    // capacity.
-    return 0;
+  static uint32_t GetCapacity(FixedArray* parameter_map) {
+    FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1));
+    return Max(static_cast<uint32_t>(parameter_map->length() - 2),
+               ForArray(arguments)->GetCapacity(arguments));
   }
 
-  static MaybeObject* GetElementAtCapacityIndex(FixedArray* obj, int index) {
-    // TODO(danno): Return either value from parameter map of backing
-    // store value at index.
-    return obj->GetHeap()->the_hole_value();
+  static uint32_t GetKeyForIndex(FixedArray* dict,
+                                 uint32_t index) {
+    return index;
+  }
+
+  static bool HasElementAtIndex(FixedArray* parameter_map,
+                                uint32_t index) {
+    Object* probe = GetParameterMapArg(parameter_map, index);
+    if (!probe->IsTheHole()) {
+      return true;
+    } else {
+      FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1));
+      ElementsAccessor* accessor = ElementsAccessor::ForArray(arguments);
+      return !accessor->GetElement(arguments, index)->IsTheHole();
+    }
+  }
+
+  static MaybeObject* GetElement(FixedArray* parameter_map,
+                                 uint32_t key) {
+    Object* probe = GetParameterMapArg(parameter_map, key);
+    if (!probe->IsTheHole()) {
+      Context* context = Context::cast(parameter_map->get(0));
+      int context_index = Smi::cast(probe)->value();
+      ASSERT(!context->get(context_index)->IsTheHole());
+      return context->get(context_index);
+    } else {
+      FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1));
+      return ForArray(arguments)->GetElement(arguments, key);
+    }
+  }
+
+ private:
+
+  static Object* GetParameterMapArg(FixedArray* parameter_map,
+                                    uint32_t key) {
+    uint32_t length = parameter_map->length();
+    return key < (length - 2 )
+        ? parameter_map->get(key + 2)
+        : parameter_map->GetHeap()->the_hole_value();
   }
 };
 
 
+ElementsAccessor* ElementsAccessor::ForArray(FixedArrayBase* array) {
+  switch (array->map()->instance_type()) {
+    case FIXED_ARRAY_TYPE:
+      if (array->IsDictionary()) {
+        return elements_accessors_[JSObject::DICTIONARY_ELEMENTS];
+      } else {
+        return elements_accessors_[JSObject::FAST_ELEMENTS];
+      }
+    case EXTERNAL_BYTE_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_BYTE_ELEMENTS];
+    case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_UNSIGNED_BYTE_ELEMENTS];
+    case EXTERNAL_SHORT_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_SHORT_ELEMENTS];
+    case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_UNSIGNED_SHORT_ELEMENTS];
+    case EXTERNAL_INT_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_INT_ELEMENTS];
+    case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_UNSIGNED_INT_ELEMENTS];
+    case EXTERNAL_FLOAT_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_FLOAT_ELEMENTS];
+    case EXTERNAL_DOUBLE_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_DOUBLE_ELEMENTS];
+    case EXTERNAL_PIXEL_ARRAY_TYPE:
+      return elements_accessors_[JSObject::EXTERNAL_PIXEL_ELEMENTS];
+    default:
+      UNREACHABLE();
+      return NULL;
+      break;
+  }
+}
+
+
 void ElementsAccessor::InitializeOncePerProcess() {
   static struct ConcreteElementsAccessors {
     FastElementsAccessor fast_elements_handler;
     FastDoubleElementsAccessor fast_double_elements_handler;
     DictionaryElementsAccessor dictionary_elements_handler;
     NonStrictArgumentsElementsAccessor non_strict_arguments_elements_handler;
     ExternalByteElementsAccessor byte_elements_handler;
     ExternalUnsignedByteElementsAccessor unsigned_byte_elements_handler;
     ExternalShortElementsAccessor short_elements_handler;
     ExternalUnsignedShortElementsAccessor unsigned_short_elements_handler;
@@ skipping 18 matching lines @@
     &element_accessors.float_elements_handler,
     &element_accessors.double_elements_handler,
     &element_accessors.pixel_elements_handler
   };
 
   elements_accessors_ = accessor_array;
 }
 
 
 } }  // namespace v8::internal