Implement in-heap backing store for typed arrays.

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
-//   - ExternalElementsAccessor                  (abstract)
+//   - TypedElementsAccessor                  (abstract)
 //     - ExternalByteElementsAccessor
 //     - ExternalUnsignedByteElementsAccessor
 //     - ExternalShortElementsAccessor
 //     - ExternalUnsignedShortElementsAccessor
 //     - ExternalIntElementsAccessor
 //     - ExternalUnsignedIntElementsAccessor
 //     - ExternalFloatElementsAccessor
 //     - ExternalDoubleElementsAccessor
 //     - PixelElementsAccessor
+//     - FixedUint8ArrayAccessor
+//     - FixedInt8ArrayAccessor
+//     - FixedUint16ArrayAccessor
+//     - FixedInt16ArrayAccessor
+//     - FixedUint32ArrayAccessor
+//     - FixedInt32ArrayAccessor
+//     - FixedFloat32ArrayAccessor
+//     - FixedFloat64ArrayAccessor
+//     - FixedUint8ClampedArrayAccessor
 //   - DictionaryElementsAccessor
 //   - NonStrictArgumentsElementsAccessor
 
 
 namespace v8 {
 namespace internal {
 
 
 static const int kPackedSizeNotKnown = -1;
 
@@ skipping 26 matching lines @@
   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(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,             \
+    FixedUint8ClampedArray)
 
 
 template<ElementsKind Kind> class ElementsKindTraits {
  public:
   typedef FixedArrayBase BackingStore;
 };
 
 #define ELEMENTS_TRAITS(Class, KindParam, Store)               \
 template<> class ElementsKindTraits<KindParam> {               \
   public:                                                      \
@@ skipping 971 matching lines @@
     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;
+
     default:
       UNREACHABLE();
   }
   return FAST_HOLEY_ELEMENTS;
 }
 
 
 template<typename FastElementsAccessorSubclass,
          typename KindTraits>
 class FastSmiOrObjectElementsAccessor
@@ skipping 42 matching lines @@
       }
       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();
     }
     return NULL;
   }
 
 
   static MaybeObject* SetFastElementsCapacityAndLength(JSObject* obj,
                                                        uint32_t capacity,
                                                        uint32_t length) {
     JSObject::SetFastElementsCapacitySmiMode set_capacity_mode =
@@ skipping 105 matching lines @@
       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();
     }
     return to->GetHeap()->undefined_value();
   }
 };
 
 
 class FastPackedDoubleElementsAccessor
     : public FastDoubleElementsAccessor<
         FastPackedDoubleElementsAccessor,
@@ skipping 17 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 ExternalElementsAccessorSubclass,
+template<typename AccessorSubclass,
          ElementsKind Kind>
-class ExternalElementsAccessor
-    : public ElementsAccessorBase<ExternalElementsAccessorSubclass,
+class TypedElementsAccessor
+    : public ElementsAccessorBase<AccessorSubclass,
                                   ElementsKindTraits<Kind> > {
  public:
-  explicit ExternalElementsAccessor(const char* name)
-      : ElementsAccessorBase<ExternalElementsAccessorSubclass,
+  explicit TypedElementsAccessor(const char* name)
+      : ElementsAccessorBase<AccessorSubclass,
                              ElementsKindTraits<Kind> >(name) {}
 
  protected:
   typedef typename ElementsKindTraits<Kind>::BackingStore BackingStore;
 
-  friend class ElementsAccessorBase<ExternalElementsAccessorSubclass,
+  friend class ElementsAccessorBase<AccessorSubclass,
                                     ElementsKindTraits<Kind> >;
 
   MUST_USE_RESULT static MaybeObject* GetImpl(Object* receiver,
                                               JSObject* obj,
                                               uint32_t key,
                                               FixedArrayBase* backing_store) {
     return
-        key < ExternalElementsAccessorSubclass::GetCapacityImpl(backing_store)
+        key < AccessorSubclass::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 < ExternalElementsAccessorSubclass::GetCapacityImpl(backing_store)
+        key < AccessorSubclass::GetCapacityImpl(backing_store)
           ? NONE : ABSENT;
   }
 
   MUST_USE_RESULT static PropertyType GetTypeImpl(
       Object* receiver,
       JSObject* obj,
       uint32_t key,
       FixedArrayBase* backing_store) {
     return
-        key < ExternalElementsAccessorSubclass::GetCapacityImpl(backing_store)
+        key < AccessorSubclass::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 =
-        ExternalElementsAccessorSubclass::GetCapacityImpl(backing_store);
+        AccessorSubclass::GetCapacityImpl(backing_store);
     return key < capacity;
   }
 };
 
 
 class ExternalByteElementsAccessor
-    : public ExternalElementsAccessor<ExternalByteElementsAccessor,
-                                      EXTERNAL_BYTE_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalByteElementsAccessor,
+                                   EXTERNAL_BYTE_ELEMENTS> {
  public:
   explicit ExternalByteElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalByteElementsAccessor,
-                                 EXTERNAL_BYTE_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalByteElementsAccessor,
+                              EXTERNAL_BYTE_ELEMENTS>(name) {}
 };
 
 
 class ExternalUnsignedByteElementsAccessor
-    : public ExternalElementsAccessor<ExternalUnsignedByteElementsAccessor,
-                                      EXTERNAL_UNSIGNED_BYTE_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalUnsignedByteElementsAccessor,
+                                   EXTERNAL_UNSIGNED_BYTE_ELEMENTS> {
  public:
   explicit ExternalUnsignedByteElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalUnsignedByteElementsAccessor,
-                                 EXTERNAL_UNSIGNED_BYTE_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalUnsignedByteElementsAccessor,
+                              EXTERNAL_UNSIGNED_BYTE_ELEMENTS>(name) {}
 };
 
 
 class ExternalShortElementsAccessor
-    : public ExternalElementsAccessor<ExternalShortElementsAccessor,
-                                      EXTERNAL_SHORT_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalShortElementsAccessor,
+                                   EXTERNAL_SHORT_ELEMENTS> {
  public:
   explicit ExternalShortElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalShortElementsAccessor,
-                                 EXTERNAL_SHORT_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalShortElementsAccessor,
+                              EXTERNAL_SHORT_ELEMENTS>(name) {}
 };
 
 
 class ExternalUnsignedShortElementsAccessor
-    : public ExternalElementsAccessor<ExternalUnsignedShortElementsAccessor,
-                                      EXTERNAL_UNSIGNED_SHORT_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalUnsignedShortElementsAccessor,
+                                   EXTERNAL_UNSIGNED_SHORT_ELEMENTS> {
  public:
   explicit ExternalUnsignedShortElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalUnsignedShortElementsAccessor,
-                                 EXTERNAL_UNSIGNED_SHORT_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalUnsignedShortElementsAccessor,
+                              EXTERNAL_UNSIGNED_SHORT_ELEMENTS>(name) {}
 };
 
 
 class ExternalIntElementsAccessor
-    : public ExternalElementsAccessor<ExternalIntElementsAccessor,
-                                      EXTERNAL_INT_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalIntElementsAccessor,
+                                   EXTERNAL_INT_ELEMENTS> {
  public:
   explicit ExternalIntElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalIntElementsAccessor,
-                                 EXTERNAL_INT_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalIntElementsAccessor,
+                              EXTERNAL_INT_ELEMENTS>(name) {}
 };
 
 
 class ExternalUnsignedIntElementsAccessor
-    : public ExternalElementsAccessor<ExternalUnsignedIntElementsAccessor,
-                                      EXTERNAL_UNSIGNED_INT_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalUnsignedIntElementsAccessor,
+                                   EXTERNAL_UNSIGNED_INT_ELEMENTS> {
  public:
   explicit ExternalUnsignedIntElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalUnsignedIntElementsAccessor,
+      : TypedElementsAccessor<ExternalUnsignedIntElementsAccessor,
                                  EXTERNAL_UNSIGNED_INT_ELEMENTS>(name) {}
 };
 
 
 class ExternalFloatElementsAccessor
-    : public ExternalElementsAccessor<ExternalFloatElementsAccessor,
-                                      EXTERNAL_FLOAT_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalFloatElementsAccessor,
+                                   EXTERNAL_FLOAT_ELEMENTS> {
  public:
   explicit ExternalFloatElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalFloatElementsAccessor,
-                                 EXTERNAL_FLOAT_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalFloatElementsAccessor,
+                              EXTERNAL_FLOAT_ELEMENTS>(name) {}
 };
 
 
 class ExternalDoubleElementsAccessor
-    : public ExternalElementsAccessor<ExternalDoubleElementsAccessor,
-                                      EXTERNAL_DOUBLE_ELEMENTS> {
+    : public TypedElementsAccessor<ExternalDoubleElementsAccessor,
+                                   EXTERNAL_DOUBLE_ELEMENTS> {
  public:
   explicit ExternalDoubleElementsAccessor(const char* name)
-      : ExternalElementsAccessor<ExternalDoubleElementsAccessor,
-                                 EXTERNAL_DOUBLE_ELEMENTS>(name) {}
+      : TypedElementsAccessor<ExternalDoubleElementsAccessor,
+                              EXTERNAL_DOUBLE_ELEMENTS>(name) {}
 };
 
 
 class PixelElementsAccessor
-    : public ExternalElementsAccessor<PixelElementsAccessor,
-                                      EXTERNAL_PIXEL_ELEMENTS> {
+    : public TypedElementsAccessor<PixelElementsAccessor,
+                                   EXTERNAL_PIXEL_ELEMENTS> {
  public:
   explicit PixelElementsAccessor(const char* name)
-      : ExternalElementsAccessor<PixelElementsAccessor,
-                                 EXTERNAL_PIXEL_ELEMENTS>(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
   // length according to ES5 section 15.4.5.2 behavior.
@@ skipping 562 matching lines @@
       UNREACHABLE();
       break;
   }
 
   array->set_elements(elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 } }  // namespace v8::internal