Implement in-heap backing store for typed arrays.

src/objects.h

 // 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 368 matching lines @@
   /* Object::IsExternalArray(). */                                             \
   V(EXTERNAL_BYTE_ARRAY_TYPE)                                                  \
   V(EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE)                                         \
   V(EXTERNAL_SHORT_ARRAY_TYPE)                                                 \
   V(EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE)                                        \
   V(EXTERNAL_INT_ARRAY_TYPE)                                                   \
   V(EXTERNAL_UNSIGNED_INT_ARRAY_TYPE)                                          \
   V(EXTERNAL_FLOAT_ARRAY_TYPE)                                                 \
   V(EXTERNAL_DOUBLE_ARRAY_TYPE)                                                \
   V(EXTERNAL_PIXEL_ARRAY_TYPE)                                                 \
+                                                                               \
+  V(FIXED_INT8_ARRAY_TYPE)                                                     \
+  V(FIXED_UINT8_ARRAY_TYPE)                                                    \
+  V(FIXED_INT16_ARRAY_TYPE)                                                    \
+  V(FIXED_UINT16_ARRAY_TYPE)                                                   \
+  V(FIXED_INT32_ARRAY_TYPE)                                                    \
+  V(FIXED_UINT32_ARRAY_TYPE)                                                   \
+  V(FIXED_FLOAT32_ARRAY_TYPE)                                                  \
+  V(FIXED_FLOAT64_ARRAY_TYPE)                                                  \
+  V(FIXED_UINT8_CLAMPED_ARRAY_TYPE)                                            \
+                                                                               \
   V(FILLER_TYPE)                                                               \
                                                                                \
   V(DECLARED_ACCESSOR_DESCRIPTOR_TYPE)                                         \
   V(DECLARED_ACCESSOR_INFO_TYPE)                                               \
   V(EXECUTABLE_ACCESSOR_INFO_TYPE)                                             \
   V(ACCESSOR_PAIR_TYPE)                                                        \
   V(ACCESS_CHECK_INFO_TYPE)                                                    \
   V(INTERCEPTOR_INFO_TYPE)                                                     \
   V(CALL_HANDLER_INFO_TYPE)                                                    \
   V(FUNCTION_TEMPLATE_INFO_TYPE)                                               \
@@ skipping 314 matching lines @@
   FREE_SPACE_TYPE,
   EXTERNAL_BYTE_ARRAY_TYPE,  // FIRST_EXTERNAL_ARRAY_TYPE
   EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE,
   EXTERNAL_SHORT_ARRAY_TYPE,
   EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE,
   EXTERNAL_INT_ARRAY_TYPE,
   EXTERNAL_UNSIGNED_INT_ARRAY_TYPE,
   EXTERNAL_FLOAT_ARRAY_TYPE,
   EXTERNAL_DOUBLE_ARRAY_TYPE,
   EXTERNAL_PIXEL_ARRAY_TYPE,  // LAST_EXTERNAL_ARRAY_TYPE
+
+  FIXED_INT8_ARRAY_TYPE,  // FIRST_FIXED_TYPED_ARRAY_TYPE
+  FIXED_UINT8_ARRAY_TYPE,
+  FIXED_INT16_ARRAY_TYPE,
+  FIXED_UINT16_ARRAY_TYPE,
+  FIXED_INT32_ARRAY_TYPE,
+  FIXED_UINT32_ARRAY_TYPE,
+  FIXED_FLOAT32_ARRAY_TYPE,
+  FIXED_FLOAT64_ARRAY_TYPE,
+  FIXED_UINT8_CLAMPED_ARRAY_TYPE,  // LAST_FIXED_TYPED_ARRAY_TYPE
+
   FIXED_DOUBLE_ARRAY_TYPE,
   CONSTANT_POOL_ARRAY_TYPE,
   FILLER_TYPE,  // LAST_DATA_TYPE
 
   // Structs.
   DECLARED_ACCESSOR_DESCRIPTOR_TYPE,
   DECLARED_ACCESSOR_INFO_TYPE,
   EXECUTABLE_ACCESSOR_INFO_TYPE,
   ACCESSOR_PAIR_TYPE,
   ACCESS_CHECK_INFO_TYPE,
@@ skipping 57 matching lines @@
   FIRST_TYPE = 0x0,
   LAST_TYPE = JS_FUNCTION_TYPE,
   FIRST_NAME_TYPE = FIRST_TYPE,
   LAST_NAME_TYPE = SYMBOL_TYPE,
   FIRST_UNIQUE_NAME_TYPE = INTERNALIZED_STRING_TYPE,
   LAST_UNIQUE_NAME_TYPE = SYMBOL_TYPE,
   FIRST_NONSTRING_TYPE = SYMBOL_TYPE,
   // Boundaries for testing for an external array.
   FIRST_EXTERNAL_ARRAY_TYPE = EXTERNAL_BYTE_ARRAY_TYPE,
   LAST_EXTERNAL_ARRAY_TYPE = EXTERNAL_PIXEL_ARRAY_TYPE,
+  // Boundaries for testing for a fixed typed array.
+  FIRST_FIXED_TYPED_ARRAY_TYPE = FIXED_INT8_ARRAY_TYPE,
+  LAST_FIXED_TYPED_ARRAY_TYPE = FIXED_UINT8_CLAMPED_ARRAY_TYPE,
   // Boundary for promotion to old data space/old pointer space.
   LAST_DATA_TYPE = FILLER_TYPE,
   // Boundary for objects represented as JSReceiver (i.e. JSObject or JSProxy).
   // Note that there is no range for JSObject or JSProxy, since their subtypes
   // are not continuous in this enum! The enum ranges instead reflect the
   // external class names, where proxies are treated as either ordinary objects,
   // or functions.
   FIRST_JS_RECEIVER_TYPE = JS_FUNCTION_PROXY_TYPE,
   LAST_JS_RECEIVER_TYPE = LAST_TYPE,
   // Boundaries for testing the types represented as JSObject
@@ skipping 169 matching lines @@
   V(ExternalArray)                             \
   V(ExternalByteArray)                         \
   V(ExternalUnsignedByteArray)                 \
   V(ExternalShortArray)                        \
   V(ExternalUnsignedShortArray)                \
   V(ExternalIntArray)                          \
   V(ExternalUnsignedIntArray)                  \
   V(ExternalFloatArray)                        \
   V(ExternalDoubleArray)                       \
   V(ExternalPixelArray)                        \
+  V(FixedTypedArrayBase)                       \
+  V(FixedUint8Array)                           \
+  V(FixedInt8Array)                            \
+  V(FixedUint16Array)                          \
+  V(FixedInt16Array)                           \
+  V(FixedUint32Array)                          \
+  V(FixedInt32Array)                           \
+  V(FixedFloat32Array)                         \
+  V(FixedFloat64Array)                         \
+  V(FixedUint8ClampedArray)                    \
   V(ByteArray)                                 \
   V(FreeSpace)                                 \
   V(JSReceiver)                                \
   V(JSObject)                                  \
   V(JSContextExtensionObject)                  \
   V(JSGeneratorObject)                         \
   V(JSModule)                                  \
   V(Map)                                       \
   V(DescriptorArray)                           \
   V(TransitionArray)                           \
@@ skipping 1097 matching lines @@
   // Returns true if an object has any of the fast elements kinds.
   inline bool HasFastElements();
   // Returns true if an object has elements of FAST_DOUBLE_ELEMENTS
   // ElementsKind.
   inline bool HasFastDoubleElements();
   // Returns true if an object has elements of FAST_HOLEY_*_ELEMENTS
   // ElementsKind.
   inline bool HasFastHoleyElements();
   inline bool HasNonStrictArgumentsElements();
   inline bool HasDictionaryElements();
+
   inline bool HasExternalPixelElements();
   inline bool HasExternalArrayElements();
   inline bool HasExternalByteElements();
   inline bool HasExternalUnsignedByteElements();
   inline bool HasExternalShortElements();
   inline bool HasExternalUnsignedShortElements();
   inline bool HasExternalIntElements();
   inline bool HasExternalUnsignedIntElements();
   inline bool HasExternalFloatElements();
   inline bool HasExternalDoubleElements();
+
+  inline bool HasFixedTypedArrayElements();
+
   bool HasFastArgumentsElements();
   bool HasDictionaryArgumentsElements();
   inline SeededNumberDictionary* element_dictionary();  // Gets slow elements.
 
   inline void set_map_and_elements(
       Map* map,
       FixedArrayBase* value,
       WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Requires: HasFastElements().
@@ skipping 2684 matching lines @@
 
   // Dispatched behavior.
   DECLARE_PRINTER(ExternalDoubleArray)
   DECLARE_VERIFIER(ExternalDoubleArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalDoubleArray);
 };
 
 
+class FixedTypedArrayBase: public FixedArrayBase {
+ public:
+  // Casting:
+  static inline FixedTypedArrayBase* cast(Object* obj);
+
+  static const int kDataOffset = kHeaderSize;
+
+  inline int size();
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArrayBase);
+};
+
+
+template <class Traits>
+class FixedTypedArray: public FixedTypedArrayBase {
+ public:
+  typedef typename Traits::ElementType ElementType;
+  static const InstanceType kInstanceType = Traits::kInstanceType;
+
+  // Casting:
+  static inline FixedTypedArray<Traits>* cast(Object* obj);
+
+  static inline int SizeFor(int length) {
+    return kDataOffset + length * sizeof(ElementType);
+  }
+
+  inline ElementType get_scalar(int index);
+  MUST_USE_RESULT inline MaybeObject* get(int index);
+  inline void set(int index, ElementType value);
+
+  // This accessor applies the correct conversion from Smi, HeapNumber
+  // and undefined.
+  MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
+
+  static Handle<Object> SetValue(Handle<FixedTypedArray<Traits> > array,
+                                 uint32_t index,
+                                 Handle<Object> value);
+
+  DECLARE_PRINTER(FixedTypedArray)
+  DECLARE_VERIFIER(FixedTypedArray)
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArray);
+};
+
+
+class Uint8ArrayTraits {
+ public:
+  typedef uint8_t ElementType;
+  static const InstanceType kInstanceType = FIXED_UINT8_ARRAY_TYPE;
+  static const char* Designator() { return "uint8 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, uint8_t scalar);
+  static uint8_t defaultValue() { return 0; }
+};
+

[Toon Verwaest, 2013/12/23 10:40:32]

Double newlines between classes.
This is a lot of boilerplate code...

[Dmitry Lomov (no reviews), 2014/01/07 15:48:43]

Done.

+typedef FixedTypedArray<Uint8ArrayTraits> FixedUint8Array;
+
+class Int8ArrayTraits {
+ public:
+  typedef int8_t ElementType;
+  static const InstanceType kInstanceType = FIXED_INT8_ARRAY_TYPE;
+  static const char* Designator() { return "int8 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, int8_t scalar);
+  static int8_t defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Int8ArrayTraits> FixedInt8Array;
+
+class Uint16ArrayTraits {
+ public:
+  typedef uint16_t ElementType;
+  static const InstanceType kInstanceType = FIXED_UINT16_ARRAY_TYPE;
+  static const char* Designator() { return "uint16 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, uint16_t scalar);
+  static uint16_t defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Uint16ArrayTraits> FixedUint16Array;
+
+class Int16ArrayTraits {
+ public:
+  typedef int16_t ElementType;
+  static const InstanceType kInstanceType = FIXED_INT16_ARRAY_TYPE;
+  static const char* Designator() { return "int16 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, int16_t scalar);
+  static int16_t defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Int16ArrayTraits> FixedInt16Array;
+
+class Uint32ArrayTraits {
+ public:
+  typedef uint32_t ElementType;
+  static const InstanceType kInstanceType = FIXED_UINT32_ARRAY_TYPE;
+  static const char* Designator() { return "uint32 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, uint32_t scalar);
+  static uint32_t defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Uint32ArrayTraits> FixedUint32Array;
+
+class Int32ArrayTraits {
+ public:
+  typedef int32_t ElementType;
+  static const InstanceType kInstanceType = FIXED_INT32_ARRAY_TYPE;
+  static const char* Designator() { return "int32 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, int32_t scalar);
+  static int32_t defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Int32ArrayTraits> FixedInt32Array;
+
+class Float32ArrayTraits {
+ public:
+  typedef float ElementType;
+  static const InstanceType kInstanceType = FIXED_FLOAT32_ARRAY_TYPE;
+  static const char* Designator() { return "float32 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, float scalar);
+  static float defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Float32ArrayTraits> FixedFloat32Array;
+
+class Float64ArrayTraits {
+ public:
+  typedef double ElementType;
+  static const InstanceType kInstanceType = FIXED_FLOAT64_ARRAY_TYPE;
+  static const char* Designator() { return "float64 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, double scalar);
+  static double defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Float64ArrayTraits> FixedFloat64Array;
+
+class Uint8ClampedArrayTraits {
+ public:
+  typedef uint8_t ElementType;
+  static const InstanceType kInstanceType = FIXED_UINT8_CLAMPED_ARRAY_TYPE;
+  static const char* Designator() { return "uint8 array"; }
+  static inline MaybeObject* ToObject(Heap* heap, uint8_t scalar);
+  static uint8_t defaultValue() { return 0; }
+};
+
+typedef FixedTypedArray<Uint8ClampedArrayTraits> FixedUint8ClampedArray;
+
 // DeoptimizationInputData is a fixed array used to hold the deoptimization
 // data for code generated by the Hydrogen/Lithium compiler.  It also
 // contains information about functions that were inlined.  If N different
 // functions were inlined then first N elements of the literal array will
 // contain these functions.
 //
 // It can be empty.
 class DeoptimizationInputData: public FixedArray {
  public:
   // Layout description.  Indices in the array.
@@ skipping 976 matching lines @@
   }
 
   inline bool has_non_strict_arguments_elements() {
     return elements_kind() == NON_STRICT_ARGUMENTS_ELEMENTS;
   }
 
   inline bool has_external_array_elements() {
     return IsExternalArrayElementsKind(elements_kind());
   }
 
+  inline bool has_fixed_typed_array_elements() {
+    return IsFixedTypedArrayElementsKind(elements_kind());
+  }
+
   inline bool has_dictionary_elements() {
     return IsDictionaryElementsKind(elements_kind());
   }
 
   inline bool has_slow_elements_kind() {
     return elements_kind() == DICTIONARY_ELEMENTS
         || elements_kind() == NON_STRICT_ARGUMENTS_ELEMENTS;
   }
 
   static bool IsValidElementsTransition(ElementsKind from_kind,
@@ skipping 4791 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_