External Array renaming and boilerplate scrapping

src/elements.cc

 // Copyright 2012 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 30 matching lines @@
 // - ElementsAccessorBase                        (abstract)
 //   - FastElementsAccessor                      (abstract)
 //     - FastSmiOrObjectElementsAccessor
 //       - FastPackedSmiElementsAccessor
 //       - FastHoleySmiElementsAccessor
 //       - FastPackedObjectElementsAccessor
 //       - FastHoleyObjectElementsAccessor
 //     - FastDoubleElementsAccessor
 //       - FastPackedDoubleElementsAccessor
 //       - FastHoleyDoubleElementsAccessor
-//   - TypedElementsAccessor                  (abstract)
-//     - ExternalByteElementsAccessor
-//     - ExternalUnsignedByteElementsAccessor
-//     - ExternalShortElementsAccessor
-//     - ExternalUnsignedShortElementsAccessor
-//     - ExternalIntElementsAccessor
-//     - ExternalUnsignedIntElementsAccessor
-//     - ExternalFloatElementsAccessor
-//     - ExternalDoubleElementsAccessor
-//     - PixelElementsAccessor
-//     - FixedUint8ArrayAccessor
-//     - FixedInt8ArrayAccessor
-//     - FixedUint16ArrayAccessor
-//     - FixedInt16ArrayAccessor
-//     - FixedUint32ArrayAccessor
-//     - FixedInt32ArrayAccessor
-//     - FixedFloat32ArrayAccessor
-//     - FixedFloat64ArrayAccessor
-//     - FixedUint8ClampedArrayAccessor
+//   - TypedElementsAccessor: template, with instantiations:
+//     - ExternalInt8ElementsAccessor
+//     - ExternalUint8ElementsAccessor
+//     - ExternalInt16ElementsAccessor
+//     - ExternalUint16ElementsAccessor
+//     - ExternalInt32ElementsAccessor
+//     - ExternalUint32ElementsAccessor
+//     - ExternalFloat32ElementsAccessor
+//     - ExternalFloat64ElementsAccessor
+//     - ExternalUint8ClampedElementsAccessor
+//     - FixedUint8ElementsAccessor
+//     - FixedInt8ElementsAccessor
+//     - FixedUint16ElementsAccessor
+//     - FixedInt16ElementsAccessor
+//     - FixedUint32ElementsAccessor
+//     - FixedInt32ElementsAccessor
+//     - FixedFloat32ElementsAccessor
+//     - FixedFloat64ElementsAccessor
+//     - FixedUint8ClampedElementsAccessor
 //   - DictionaryElementsAccessor
 //   - NonStrictArgumentsElementsAccessor
 
 
 namespace v8 {
 namespace internal {
 
 
 static const int kPackedSizeNotKnown = -1;
 
@@ skipping 10 matching lines @@
   V(FastPackedObjectElementsAccessor, FAST_ELEMENTS, FixedArray)        \
   V(FastHoleyObjectElementsAccessor, FAST_HOLEY_ELEMENTS, FixedArray)   \
   V(FastPackedDoubleElementsAccessor, FAST_DOUBLE_ELEMENTS,             \
     FixedDoubleArray)                                                   \
   V(FastHoleyDoubleElementsAccessor, FAST_HOLEY_DOUBLE_ELEMENTS,        \
     FixedDoubleArray)                                                   \
   V(DictionaryElementsAccessor, DICTIONARY_ELEMENTS,                    \
     SeededNumberDictionary)                                             \
   V(NonStrictArgumentsElementsAccessor, NON_STRICT_ARGUMENTS_ELEMENTS,  \
     FixedArray)                                                         \
-  V(ExternalByteElementsAccessor, EXTERNAL_BYTE_ELEMENTS,               \
-    ExternalByteArray)                                                  \
-  V(ExternalUnsignedByteElementsAccessor,                               \
-    EXTERNAL_UNSIGNED_BYTE_ELEMENTS, ExternalUnsignedByteArray)         \
-  V(ExternalShortElementsAccessor, EXTERNAL_SHORT_ELEMENTS,             \
-    ExternalShortArray)                                                 \
-  V(ExternalUnsignedShortElementsAccessor,                              \
-    EXTERNAL_UNSIGNED_SHORT_ELEMENTS, ExternalUnsignedShortArray)       \
-  V(ExternalIntElementsAccessor, EXTERNAL_INT_ELEMENTS,                 \
-    ExternalIntArray)                                                   \
-  V(ExternalUnsignedIntElementsAccessor,                                \
-    EXTERNAL_UNSIGNED_INT_ELEMENTS, ExternalUnsignedIntArray)           \
-  V(ExternalFloatElementsAccessor,                                      \
-    EXTERNAL_FLOAT_ELEMENTS, ExternalFloatArray)                        \
-  V(ExternalDoubleElementsAccessor,                                     \
-    EXTERNAL_DOUBLE_ELEMENTS, ExternalDoubleArray)                      \
-  V(PixelElementsAccessor, EXTERNAL_PIXEL_ELEMENTS, ExternalPixelArray) \
-  V(FixedUint8ArrayAccessor, UINT8_ELEMENTS, FixedUint8Array)           \
-  V(FixedInt8ArrayAccessor, INT8_ELEMENTS, FixedInt8Array)              \
-  V(FixedUint16ArrayAccessor, UINT16_ELEMENTS, FixedUint16Array)        \
-  V(FixedInt16ArrayAccessor, INT16_ELEMENTS, FixedInt16Array)           \
-  V(FixedUint32ArrayAccessor, UINT32_ELEMENTS, FixedUint32Array)        \
-  V(FixedInt32ArrayAccessor, INT32_ELEMENTS, FixedInt32Array)           \
-  V(FixedFloat32ArrayAccessor, FLOAT32_ELEMENTS, FixedFloat32Array)     \
-  V(FixedFloat64ArrayAccessor, FLOAT64_ELEMENTS, FixedFloat64Array)     \
-  V(FixedUint8ClampedArrayAccessor, UINT8_CLAMPED_ELEMENTS,             \
+  V(ExternalInt8ElementsAccessor, EXTERNAL_INT8_ELEMENTS,               \
+    ExternalInt8Array)                                                  \
+  V(ExternalUint8ElementsAccessor,                                      \
+    EXTERNAL_UINT8_ELEMENTS, ExternalUint8Array)                        \
+  V(ExternalInt16ElementsAccessor, EXTERNAL_INT16_ELEMENTS,             \
+    ExternalInt16Array)                                                 \
+  V(ExternalUint16ElementsAccessor,                                     \
+    EXTERNAL_UINT16_ELEMENTS, ExternalUint16Array)                      \
+  V(ExternalInt32ElementsAccessor, EXTERNAL_INT32_ELEMENTS,             \
+    ExternalInt32Array)                                                 \
+  V(ExternalUint32ElementsAccessor,                                     \
+    EXTERNAL_UINT32_ELEMENTS, ExternalUint32Array)                      \
+  V(ExternalFloat32ElementsAccessor,                                    \
+    EXTERNAL_FLOAT32_ELEMENTS, ExternalFloat32Array)                    \
+  V(ExternalFloat64ElementsAccessor,                                    \
+    EXTERNAL_FLOAT64_ELEMENTS, ExternalFloat64Array)                    \
+  V(ExternalUint8ClampedElementsAccessor,                               \
+    EXTERNAL_UINT8_CLAMPED_ELEMENTS,                                    \
+    ExternalUint8ClampedArray)                                          \
+  V(FixedUint8ElementsAccessor, UINT8_ELEMENTS, FixedUint8Array)        \
+  V(FixedInt8ElementsAccessor, INT8_ELEMENTS, FixedInt8Array)           \
+  V(FixedUint16ElementsAccessor, UINT16_ELEMENTS, FixedUint16Array)     \
+  V(FixedInt16ElementsAccessor, INT16_ELEMENTS, FixedInt16Array)        \
+  V(FixedUint32ElementsAccessor, UINT32_ELEMENTS, FixedUint32Array)     \
+  V(FixedInt32ElementsAccessor, INT32_ELEMENTS, FixedInt32Array)        \
+  V(FixedFloat32ElementsAccessor, FLOAT32_ELEMENTS, FixedFloat32Array)  \
+  V(FixedFloat64ElementsAccessor, FLOAT64_ELEMENTS, FixedFloat64Array)  \
+  V(FixedUint8ClampedElementsAccessor, UINT8_CLAMPED_ELEMENTS,          \
     FixedUint8ClampedArray)
 
 
 template<ElementsKind Kind> class ElementsKindTraits {
  public:
   typedef FixedArrayBase BackingStore;
 };
 
 #define ELEMENTS_TRAITS(Class, KindParam, Store)               \
 template<> class ElementsKindTraits<KindParam> {               \
@@ skipping 954 matching lines @@
 static inline ElementsKind ElementsKindForArray(FixedArrayBase* array) {
   switch (array->map()->instance_type()) {
     case FIXED_ARRAY_TYPE:
       if (array->IsDictionary()) {
         return DICTIONARY_ELEMENTS;
       } else {
         return FAST_HOLEY_ELEMENTS;
       }
     case FIXED_DOUBLE_ARRAY_TYPE:
       return FAST_HOLEY_DOUBLE_ELEMENTS;
-    case EXTERNAL_BYTE_ARRAY_TYPE:
-      return EXTERNAL_BYTE_ELEMENTS;
-    case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE:
-      return EXTERNAL_UNSIGNED_BYTE_ELEMENTS;
-    case EXTERNAL_SHORT_ARRAY_TYPE:
-      return EXTERNAL_SHORT_ELEMENTS;
-    case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE:
-      return EXTERNAL_UNSIGNED_SHORT_ELEMENTS;
-    case EXTERNAL_INT_ARRAY_TYPE:
-      return EXTERNAL_INT_ELEMENTS;
-    case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
-      return EXTERNAL_UNSIGNED_INT_ELEMENTS;
-    case EXTERNAL_FLOAT_ARRAY_TYPE:
-      return EXTERNAL_FLOAT_ELEMENTS;
-    case EXTERNAL_DOUBLE_ARRAY_TYPE:
-      return EXTERNAL_DOUBLE_ELEMENTS;
-    case EXTERNAL_PIXEL_ARRAY_TYPE:
-      return EXTERNAL_PIXEL_ELEMENTS;
 
-    case FIXED_UINT8_ARRAY_TYPE:
-      return UINT8_ELEMENTS;
-    case FIXED_INT8_ARRAY_TYPE:
-      return INT8_ELEMENTS;
-    case FIXED_UINT16_ARRAY_TYPE:
-      return UINT16_ELEMENTS;
-    case FIXED_INT16_ARRAY_TYPE:
-      return INT16_ELEMENTS;
-    case FIXED_UINT32_ARRAY_TYPE:
-      return UINT32_ELEMENTS;
-    case FIXED_INT32_ARRAY_TYPE:
-      return INT32_ELEMENTS;
-    case FIXED_FLOAT32_ARRAY_TYPE:
-      return FLOAT32_ELEMENTS;
-    case FIXED_FLOAT64_ARRAY_TYPE:
-      return FLOAT64_ELEMENTS;
-    case FIXED_UINT8_CLAMPED_ARRAY_TYPE:
-      return UINT8_CLAMPED_ELEMENTS;
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                       \
+    case EXTERNAL_##TYPE##_ARRAY_TYPE:                                        \
+      return EXTERNAL_##TYPE##_ELEMENTS;                                      \
+    case FIXED_##TYPE##_ARRAY_TYPE:                                           \
+      return TYPE##_ELEMENTS;
+
+    TYPED_ARRAYS(TYPED_ARRAY_CASE)
+#undef TYPED_ARRAY_CASE
 
     default:
       UNREACHABLE();
   }
   return FAST_HOLEY_ELEMENTS;
 }
 
 
 template<typename FastElementsAccessorSubclass,
          typename KindTraits>
@@ skipping 34 matching lines @@
       case NON_STRICT_ARGUMENTS_ELEMENTS: {
         // TODO(verwaest): This is a temporary hack to support extending
         // NON_STRICT_ARGUMENTS_ELEMENTS in SetFastElementsCapacityAndLength.
         // This case should be UNREACHABLE().
         FixedArray* parameter_map = FixedArray::cast(from);
         FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1));
         ElementsKind from_kind = ElementsKindForArray(arguments);
         return CopyElementsImpl(arguments, from_start, to, from_kind,
                                 to_start, packed_size, copy_size);
       }
-      case EXTERNAL_BYTE_ELEMENTS:
-      case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
-      case EXTERNAL_SHORT_ELEMENTS:
-      case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
-      case EXTERNAL_INT_ELEMENTS:
-      case EXTERNAL_UNSIGNED_INT_ELEMENTS:
-      case EXTERNAL_FLOAT_ELEMENTS:
-      case EXTERNAL_DOUBLE_ELEMENTS:
-      case EXTERNAL_PIXEL_ELEMENTS:
-      case UINT8_ELEMENTS:
-      case INT8_ELEMENTS:
-      case UINT16_ELEMENTS:
-      case INT16_ELEMENTS:
-      case UINT32_ELEMENTS:
-      case INT32_ELEMENTS:
-      case FLOAT32_ELEMENTS:
-      case FLOAT64_ELEMENTS:
-      case UINT8_CLAMPED_ELEMENTS:
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                       \
+      case EXTERNAL_##TYPE##_ELEMENTS:                                        \
+      case TYPE##_ELEMENTS:                                                   \
         UNREACHABLE();
+      TYPED_ARRAYS(TYPED_ARRAY_CASE)
+#undef TYPED_ARRAY_CASE
     }
     return NULL;
   }
 
 
   static MaybeObject* SetFastElementsCapacityAndLength(JSObject* obj,
                                                        uint32_t capacity,
                                                        uint32_t length) {
     JSObject::SetFastElementsCapacitySmiMode set_capacity_mode =
         obj->HasFastSmiElements()
@@ skipping 95 matching lines @@
         break;
       case FAST_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
         CopyObjectToDoubleElements(from, from_start, to, to_start, copy_size);
         break;
       case DICTIONARY_ELEMENTS:
         CopyDictionaryToDoubleElements(
             from, from_start, to, to_start, copy_size);
         break;
       case NON_STRICT_ARGUMENTS_ELEMENTS:
-      case EXTERNAL_BYTE_ELEMENTS:
-      case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
-      case EXTERNAL_SHORT_ELEMENTS:
-      case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
-      case EXTERNAL_INT_ELEMENTS:
-      case EXTERNAL_UNSIGNED_INT_ELEMENTS:
-      case EXTERNAL_FLOAT_ELEMENTS:
-      case EXTERNAL_DOUBLE_ELEMENTS:
-      case EXTERNAL_PIXEL_ELEMENTS:
-      case UINT8_ELEMENTS:
-      case INT8_ELEMENTS:
-      case UINT16_ELEMENTS:
-      case INT16_ELEMENTS:
-      case UINT32_ELEMENTS:
-      case INT32_ELEMENTS:
-      case FLOAT32_ELEMENTS:
-      case FLOAT64_ELEMENTS:
-      case UINT8_CLAMPED_ELEMENTS:
         UNREACHABLE();
+
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                       \
+      case EXTERNAL_##TYPE##_ELEMENTS:                                        \
+      case TYPE##_ELEMENTS:                                                   \
+        UNREACHABLE();
+      TYPED_ARRAYS(TYPED_ARRAY_CASE)
+#undef TYPED_ARRAY_CASE
     }
     return to->GetHeap()->undefined_value();
   }
 };
 
 
 class FastPackedDoubleElementsAccessor
     : public FastDoubleElementsAccessor<
         FastPackedDoubleElementsAccessor,
         ElementsKindTraits<FAST_DOUBLE_ELEMENTS> > {
@@ skipping 16 matching lines @@
     FastHoleyDoubleElementsAccessor,
     ElementsKindTraits<FAST_HOLEY_DOUBLE_ELEMENTS> >;
   explicit FastHoleyDoubleElementsAccessor(const char* name)
       : FastDoubleElementsAccessor<
           FastHoleyDoubleElementsAccessor,
           ElementsKindTraits<FAST_HOLEY_DOUBLE_ELEMENTS> >(name) {}
 };
 
 
 // Super class for all external element arrays.
-template<typename AccessorSubclass,
-         ElementsKind Kind>
+template<ElementsKind Kind>
 class TypedElementsAccessor
-    : public ElementsAccessorBase<AccessorSubclass,
+    : public ElementsAccessorBase<TypedElementsAccessor<Kind>,
                                   ElementsKindTraits<Kind> > {
  public:
   explicit TypedElementsAccessor(const char* name)
-      : ElementsAccessorBase<AccessorSubclass,
+      : ElementsAccessorBase<AccessorClass,
                              ElementsKindTraits<Kind> >(name) {}
 
  protected:
   typedef typename ElementsKindTraits<Kind>::BackingStore BackingStore;
+  typedef TypedElementsAccessor<Kind> AccessorClass;
 
-  friend class ElementsAccessorBase<AccessorSubclass,
+  friend class ElementsAccessorBase<AccessorClass,
                                     ElementsKindTraits<Kind> >;
 
   MUST_USE_RESULT static MaybeObject* GetImpl(Object* receiver,
                                               JSObject* obj,
                                               uint32_t key,
                                               FixedArrayBase* backing_store) {
     return
-        key < AccessorSubclass::GetCapacityImpl(backing_store)
+        key < AccessorClass::GetCapacityImpl(backing_store)
         ? BackingStore::cast(backing_store)->get(key)
         : backing_store->GetHeap()->undefined_value();
   }
 
   MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
       Object* receiver,
       JSObject* obj,
       uint32_t key,
       FixedArrayBase* backing_store) {
     return
-        key < AccessorSubclass::GetCapacityImpl(backing_store)
+        key < AccessorClass::GetCapacityImpl(backing_store)
           ? NONE : ABSENT;
   }
 
   MUST_USE_RESULT static PropertyType GetTypeImpl(
       Object* receiver,
       JSObject* obj,
       uint32_t key,
       FixedArrayBase* backing_store) {
     return
-        key < AccessorSubclass::GetCapacityImpl(backing_store)
+        key < AccessorClass::GetCapacityImpl(backing_store)
           ? FIELD : NONEXISTENT;
   }
 
   MUST_USE_RESULT static MaybeObject* SetLengthImpl(
       JSObject* obj,
       Object* length,
       FixedArrayBase* backing_store) {
     // External arrays do not support changing their length.
     UNREACHABLE();
     return obj;
   }
 
   MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj,
                                               uint32_t key,
                                               JSReceiver::DeleteMode mode) {
     // External arrays always ignore deletes.
     return obj->GetHeap()->true_value();
   }
 
   static bool HasElementImpl(Object* receiver,
                              JSObject* holder,
                              uint32_t key,
                              FixedArrayBase* backing_store) {
     uint32_t capacity =
-        AccessorSubclass::GetCapacityImpl(backing_store);
+        AccessorClass::GetCapacityImpl(backing_store);
     return key < capacity;
   }
 };
 
 
-class ExternalByteElementsAccessor
-    : public TypedElementsAccessor<ExternalByteElementsAccessor,
-                                   EXTERNAL_BYTE_ELEMENTS> {
- public:
-  explicit ExternalByteElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalByteElementsAccessor,
-                              EXTERNAL_BYTE_ELEMENTS>(name) {}
-};
+
+#define EXTERNAL_ELEMENTS_ACCESSOR(Type, type, TYPE, ctype, size)    \
+  typedef TypedElementsAccessor<EXTERNAL_##TYPE##_ELEMENTS>          \
+      External##Type##ElementsAccessor;
+
+TYPED_ARRAYS(EXTERNAL_ELEMENTS_ACCESSOR)
+#undef EXTERNAL_ELEMENTS_ACCESSOR
+
+#define FIXED_ELEMENTS_ACCESSOR(Type, type, TYPE, ctype, size)       \
+  typedef TypedElementsAccessor<TYPE##_ELEMENTS >                    \
+      Fixed##Type##ElementsAccessor;
+
+TYPED_ARRAYS(FIXED_ELEMENTS_ACCESSOR)
+#undef FIXED_ELEMENTS_ACCESSOR
 
 
-class ExternalUnsignedByteElementsAccessor
-    : public TypedElementsAccessor<ExternalUnsignedByteElementsAccessor,
-                                   EXTERNAL_UNSIGNED_BYTE_ELEMENTS> {
- public:
-  explicit ExternalUnsignedByteElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalUnsignedByteElementsAccessor,
-                              EXTERNAL_UNSIGNED_BYTE_ELEMENTS>(name) {}
-};
-
-
-class ExternalShortElementsAccessor
-    : public TypedElementsAccessor<ExternalShortElementsAccessor,
-                                   EXTERNAL_SHORT_ELEMENTS> {
- public:
-  explicit ExternalShortElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalShortElementsAccessor,
-                              EXTERNAL_SHORT_ELEMENTS>(name) {}
-};
-
-
-class ExternalUnsignedShortElementsAccessor
-    : public TypedElementsAccessor<ExternalUnsignedShortElementsAccessor,
-                                   EXTERNAL_UNSIGNED_SHORT_ELEMENTS> {
- public:
-  explicit ExternalUnsignedShortElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalUnsignedShortElementsAccessor,
-                              EXTERNAL_UNSIGNED_SHORT_ELEMENTS>(name) {}
-};
-
-
-class ExternalIntElementsAccessor
-    : public TypedElementsAccessor<ExternalIntElementsAccessor,
-                                   EXTERNAL_INT_ELEMENTS> {
- public:
-  explicit ExternalIntElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalIntElementsAccessor,
-                              EXTERNAL_INT_ELEMENTS>(name) {}
-};
-
-
-class ExternalUnsignedIntElementsAccessor
-    : public TypedElementsAccessor<ExternalUnsignedIntElementsAccessor,
-                                   EXTERNAL_UNSIGNED_INT_ELEMENTS> {
- public:
-  explicit ExternalUnsignedIntElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalUnsignedIntElementsAccessor,
-                                 EXTERNAL_UNSIGNED_INT_ELEMENTS>(name) {}
-};
-
-
-class ExternalFloatElementsAccessor
-    : public TypedElementsAccessor<ExternalFloatElementsAccessor,
-                                   EXTERNAL_FLOAT_ELEMENTS> {
- public:
-  explicit ExternalFloatElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalFloatElementsAccessor,
-                              EXTERNAL_FLOAT_ELEMENTS>(name) {}
-};
-
-
-class ExternalDoubleElementsAccessor
-    : public TypedElementsAccessor<ExternalDoubleElementsAccessor,
-                                   EXTERNAL_DOUBLE_ELEMENTS> {
- public:
-  explicit ExternalDoubleElementsAccessor(const char* name)
-      : TypedElementsAccessor<ExternalDoubleElementsAccessor,
-                              EXTERNAL_DOUBLE_ELEMENTS>(name) {}
-};
-
-
-class PixelElementsAccessor
-    : public TypedElementsAccessor<PixelElementsAccessor,
-                                   EXTERNAL_PIXEL_ELEMENTS> {
- public:
-  explicit PixelElementsAccessor(const char* name)
-      : TypedElementsAccessor<PixelElementsAccessor,
-                              EXTERNAL_PIXEL_ELEMENTS>(name) {}
-};
-
-
-class FixedUint8ArrayAccessor
-    : public TypedElementsAccessor<FixedUint8ArrayAccessor,
-                                   UINT8_ELEMENTS> {
- public:
-  explicit FixedUint8ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedUint8ArrayAccessor,
-                              UINT8_ELEMENTS>(name) {}
-};
-class FixedUint8ClampedArrayAccessor
-    : public TypedElementsAccessor<FixedUint8ClampedArrayAccessor,
-                                   UINT8_CLAMPED_ELEMENTS> {
- public:
-  explicit FixedUint8ClampedArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedUint8ClampedArrayAccessor,
-                              UINT8_CLAMPED_ELEMENTS>(name) {}
-};
-class FixedInt8ArrayAccessor
-    : public TypedElementsAccessor<FixedInt8ArrayAccessor,
-                                   INT8_ELEMENTS> {
- public:
-  explicit FixedInt8ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedInt8ArrayAccessor,
-                              INT8_ELEMENTS>(name) {}
-};
-class FixedUint16ArrayAccessor
-    : public TypedElementsAccessor<FixedUint16ArrayAccessor,
-                                   UINT16_ELEMENTS> {
- public:
-  explicit FixedUint16ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedUint16ArrayAccessor,
-                              UINT16_ELEMENTS>(name) {}
-};
-class FixedInt16ArrayAccessor
-    : public TypedElementsAccessor<FixedInt16ArrayAccessor,
-                                   INT16_ELEMENTS> {
- public:
-  explicit FixedInt16ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedInt16ArrayAccessor,
-                              INT16_ELEMENTS>(name) {}
-};
-class FixedUint32ArrayAccessor
-    : public TypedElementsAccessor<FixedUint32ArrayAccessor,
-                                   UINT32_ELEMENTS> {
- public:
-  explicit FixedUint32ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedUint32ArrayAccessor,
-                              UINT32_ELEMENTS>(name) {}
-};
-class FixedInt32ArrayAccessor
-    : public TypedElementsAccessor<FixedInt32ArrayAccessor,
-                                   INT32_ELEMENTS> {
- public:
-  explicit FixedInt32ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedInt32ArrayAccessor,
-                              INT32_ELEMENTS>(name) {}
-};
-
-class FixedFloat32ArrayAccessor
-    : public TypedElementsAccessor<FixedFloat32ArrayAccessor,
-                                   FLOAT32_ELEMENTS> {
- public:
-  explicit FixedFloat32ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedFloat32ArrayAccessor,
-                              FLOAT32_ELEMENTS>(name) {}
-};
-class FixedFloat64ArrayAccessor
-    : public TypedElementsAccessor<FixedFloat64ArrayAccessor,
-                                   FLOAT64_ELEMENTS> {
- public:
-  explicit FixedFloat64ArrayAccessor(const char* name)
-      : TypedElementsAccessor<FixedFloat64ArrayAccessor,
-                              FLOAT64_ELEMENTS>(name) {}
-};
 
 class DictionaryElementsAccessor
     : public ElementsAccessorBase<DictionaryElementsAccessor,
                                   ElementsKindTraits<DICTIONARY_ELEMENTS> > {
  public:
   explicit DictionaryElementsAccessor(const char* name)
       : ElementsAccessorBase<DictionaryElementsAccessor,
                              ElementsKindTraits<DICTIONARY_ELEMENTS> >(name) {}
 
   // Adjusts the length of the dictionary backing store and returns the new
@@ skipping 563 matching lines @@
       UNREACHABLE();
       break;
   }
 
   array->set_elements(elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 } }  // namespace v8::internal