Implement 'dart:typeddata' directly in the VM instead of using 'dart:scalarlist'

runtime/vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 815 matching lines @@
   static RawClass* New(const String& name,
                        const Script& script,
                        intptr_t token_pos);
   static RawClass* NewNativeWrapper(const Library& library,
                                     const String& name,
                                     int num_fields);
 
   // Allocate the raw string classes.
   static RawClass* NewStringClass(intptr_t class_id);
 
+  // Allocate the raw TypedData classes.
+  static RawClass* NewTypedDataClass(intptr_t class_id);
+
+  // Allocate the raw ExternalTypedData classes.
+  static RawClass* NewExternalTypedDataClass(intptr_t class_id);
+
   // Allocate a class representing a function signature described by
   // signature_function, which must be a closure function or a signature
   // function.
   // The class may be type parameterized unless the signature_function is in a
   // static scope. In that case, the type parameters are copied from the owner
   // class of signature_function.
   // A null signature function may be passed in and patched later. See below.
   static RawClass* NewSignatureClass(const String& name,
                                      const Function& signature_function,
                                      const Script& script,
@@ skipping 3996 matching lines @@
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
 
 class Float32x4 : public Instance {
  public:
   static RawFloat32x4* New(float value0, float value1, float value2,
-                                float value3, Heap::Space space = Heap::kNew);
+                           float value3, Heap::Space space = Heap::kNew);
   static RawFloat32x4* New(simd_value_t value, Heap::Space space = Heap::kNew);
 
   float x() const;
   float y() const;
   float z() const;
   float w() const;
 
   void set_x(float x) const;
   void set_y(float y) const;
   void set_z(float z) const;
@@ skipping 12 matching lines @@
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Float32x4, Instance);
   friend class Class;
 };
 
 
 class Uint32x4 : public Instance {
  public:
   static RawUint32x4* New(uint32_t value0, uint32_t value1, uint32_t value2,
-                             uint32_t value3, Heap::Space space = Heap::kNew);
+                          uint32_t value3, Heap::Space space = Heap::kNew);
   static RawUint32x4* New(simd_value_t value, Heap::Space space = Heap::kNew);
 
   uint32_t x() const;
   uint32_t y() const;
   uint32_t z() const;
   uint32_t w() const;
 
   void set_x(uint32_t x) const;
   void set_y(uint32_t y) const;
   void set_z(uint32_t z) const;
   void set_w(uint32_t w) const;
 
   simd_value_t value() const;
   void set_value(simd_value_t value) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUint32x4));
   }
 
   static intptr_t value_offset() {
     return OFFSET_OF(RawUint32x4, value_);
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Uint32x4, Instance);
   friend class Class;
 };
 
 
+class TypedData : public Instance {
+ public:
+  intptr_t Length() const {
+    ASSERT(!IsNull());
+    return Smi::Value(raw_ptr()->length_);
+  }
+
+  intptr_t ElementSizeInBytes() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementSizeInBytes(cid);
+  }
+
+  intptr_t LengthInBytes() const {
+    intptr_t cid = raw()->GetClassId();
+    return (ElementSizeInBytes(cid) * Length());
+  }
+
+#define TYPED_GETTER_SETTER(name, type)                                        \
+  type Get##name(intptr_t byte_offset) const {                                 \
+    return *reinterpret_cast<type*>(DataAddr(byte_offset));                    \
+  }                                                                            \
+  void Set##name(intptr_t byte_offset, type value) const {                     \
+    *reinterpret_cast<type*>(DataAddr(byte_offset)) = value;                   \
+  }
+  TYPED_GETTER_SETTER(Int8, int8_t)
+  TYPED_GETTER_SETTER(Uint8, uint8_t)
+  TYPED_GETTER_SETTER(Int16, int16_t)
+  TYPED_GETTER_SETTER(Uint16, uint16_t)
+  TYPED_GETTER_SETTER(Int32, int32_t)
+  TYPED_GETTER_SETTER(Uint32, uint32_t)
+  TYPED_GETTER_SETTER(Int64, int64_t)
+  TYPED_GETTER_SETTER(Uint64, uint64_t)
+  TYPED_GETTER_SETTER(Float32, float)
+  TYPED_GETTER_SETTER(Float64, double)
+
+  static intptr_t length_offset() {
+    return OFFSET_OF(RawTypedData, length_);
+  }
+
+  static intptr_t InstanceSize() {
+    ASSERT(sizeof(RawTypedData) == OFFSET_OF(RawTypedData, data_));
+    return 0;
+  }
+
+  static intptr_t InstanceSize(intptr_t lengthInBytes) {
+    ASSERT(0 <= lengthInBytes && lengthInBytes <= kSmiMax);
+    return RoundedAllocationSize(sizeof(RawTypedData) + lengthInBytes);
+  }
+
+  static intptr_t ElementSizeInBytes(intptr_t class_id) {
+    ASSERT(RawObject::IsTypedDataClassId(class_id));
+    return element_size[class_id - kTypedDataInt8ArrayCid];
+  }
+
+  static RawTypedData* New(intptr_t class_id,
+                           intptr_t len,
+                           Heap::Space space = Heap::kNew);
+
+ protected:
+  void SetLength(intptr_t value) const {
+    raw_ptr()->length_ = Smi::New(value);
+  }
+
+ private:
+  static const intptr_t element_size[];
+
+  void* DataAddr(intptr_t byte_offset) const {
+    ASSERT((byte_offset >= 0) && (byte_offset < LengthInBytes()));
+    return reinterpret_cast<void*>(raw_ptr()->data_ + byte_offset);
+  }
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(TypedData, Instance);
+  friend class Class;
+  friend class ExternalTypedData;
+};
+
+
+class ExternalTypedData : public Instance {
+ public:
+  intptr_t Length() const {
+    ASSERT(!IsNull());
+    return Smi::Value(raw_ptr()->length_);
+  }
+
+  intptr_t ElementSizeInBytes() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementSizeInBytes(cid);
+  }
+
+  intptr_t LengthInBytes() const {
+    intptr_t cid = raw()->GetClassId();
+    return (ElementSizeInBytes(cid) * Length());
+  }
+
+#define TYPED_GETTER_SETTER(name, type)                                        \
+  type Get##name(intptr_t byte_offset) const {                                 \
+    return *reinterpret_cast<type*>(DataAddr(byte_offset));                    \
+  }                                                                            \
+  void Set##name(intptr_t byte_offset, type value) const {                     \
+    *reinterpret_cast<type*>(DataAddr(byte_offset)) = value;                   \
+  }
+  TYPED_GETTER_SETTER(Int8, int8_t)
+  TYPED_GETTER_SETTER(Uint8, uint8_t)
+  TYPED_GETTER_SETTER(Int16, int16_t)
+  TYPED_GETTER_SETTER(Uint16, uint16_t)
+  TYPED_GETTER_SETTER(Int32, int32_t)
+  TYPED_GETTER_SETTER(Uint32, uint32_t)
+  TYPED_GETTER_SETTER(Int64, int64_t)
+  TYPED_GETTER_SETTER(Uint64, uint64_t)
+  TYPED_GETTER_SETTER(Float32, float)
+  TYPED_GETTER_SETTER(Float64, double)
+
+  FinalizablePersistentHandle* AddFinalizer(
+      void* peer, Dart_WeakPersistentHandleFinalizer callback) const;
+
+  static intptr_t length_offset() {
+    return OFFSET_OF(RawExternalTypedData, length_);
+  }
+
+  static intptr_t data_offset() {
+    return OFFSET_OF(RawExternalTypedData, data_);
+  }
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawExternalTypedData));
+  }
+
+  static intptr_t ElementSizeInBytes(intptr_t class_id) {
+    ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
+    return TypedData::element_size[class_id - kExternalTypedDataInt8ArrayCid];
+  }
+
+  static RawExternalTypedData* New(intptr_t class_id,
+                                   uint8_t* data,
+                                   intptr_t len,
+                                   Heap::Space space = Heap::kNew);
+
+ protected:
+  void SetLength(intptr_t value) const {
+    raw_ptr()->length_ = Smi::New(value);
+  }
+
+  void SetData(uint8_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
+  }
+
+ private:
+  void* DataAddr(intptr_t byte_offset) const {
+    ASSERT((byte_offset >= 0) && (byte_offset < LengthInBytes()));
+    return reinterpret_cast<void*>(raw_ptr()->data_ + byte_offset);
+  }
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData, Instance);
+  friend class Class;
+};
+
+
 class ByteArray : public Instance {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawByteArray, length_);
   }
@@ skipping 1722 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_