Fast copy between TypedData and ExternalTypedData

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 5016 matching lines @@
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   intptr_t ElementSizeInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
+
+  TypeDataElementType ElementType() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementType(cid);
+  }
+
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* DataAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < LengthInBytes()));
     return reinterpret_cast<void*>(raw_ptr()->data_ + byte_offset);
   }
 
@@ skipping 29 matching lines @@
     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];
+    return element_size[ElementType(class_id)];
+  }
+
+  static TypeDataElementType ElementType(intptr_t class_id) {
+    ASSERT(RawObject::IsTypedDataClassId(class_id));
+    return static_cast<TypeDataElementType>(
+        class_id - kTypedDataInt8ArrayCid);
   }
 
   static intptr_t MaxElements(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataClassId(class_id));
     return (kSmiMax / ElementSizeInBytes(class_id));
   }
 
   static RawTypedData* New(intptr_t class_id,
                            intptr_t len,
                            Heap::Space space = Heap::kNew);
 
-  static void Copy(const TypedData& dst,
-                   intptr_t dst_offset_in_bytes,
-                   const TypedData& src,
-                   intptr_t src_offset_in_bytes,
-                   intptr_t length_in_bytes);
+  template <typename DstType, typename SrcType>
+  static void Copy(const DstType& dst, intptr_t dst_offset_in_bytes,
+                   const SrcType& src, intptr_t src_offset_in_bytes,
+                   intptr_t length_in_bytes) {
+    ASSERT(dst.ElementType() == src.ElementType());
+    ASSERT(Utils::RangeCheck(src_offset_in_bytes,
+                             length_in_bytes,
+                             src.LengthInBytes()));
+    ASSERT(Utils::RangeCheck(dst_offset_in_bytes,
+                             length_in_bytes,
+                             dst.LengthInBytes()));
+    {
+      NoGCScope no_gc;
+      if (length_in_bytes > 0) {
+        memmove(dst.DataAddr(dst_offset_in_bytes),
+                src.DataAddr(src_offset_in_bytes),
+                length_in_bytes);
+      }
+    }
+  }
 
   static bool IsTypedData(const Instance& obj) {
     ASSERT(!obj.IsNull());
     intptr_t cid = obj.raw()->GetClassId();
     return RawObject::IsTypedDataClassId(cid);
   }
 
  protected:
   void SetLength(intptr_t value) const {
     raw_ptr()->length_ = Smi::New(value);
@@ skipping 14 matching lines @@
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   intptr_t ElementSizeInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
+  TypeDataElementType ElementType() const {
+    intptr_t cid = raw()->GetClassId();
+    return ElementType(cid);
+  }
+
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* GetPeer() const {
     return raw_ptr()->peer_;
   }
 
   void* DataAddr(intptr_t byte_offset) const {
@@ skipping 30 matching lines @@
   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];
+    return TypedData::element_size[ElementType(class_id)];
+  }
+
+  static TypeDataElementType ElementType(intptr_t class_id) {
+    ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
+    return static_cast<TypeDataElementType>(
+        class_id - kExternalTypedDataInt8ArrayCid);
   }
 
   static intptr_t MaxElements(intptr_t class_id) {
     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
     return (kSmiMax / ElementSizeInBytes(class_id));
   }
 
   static RawExternalTypedData* New(intptr_t class_id,
                                    uint8_t* data,
                                    intptr_t len,
                                    Heap::Space space = Heap::kNew);
 
-  static void Copy(const ExternalTypedData& dst,
-                   intptr_t dst_offset_in_bytes,
-                   const ExternalTypedData& src,
-                   intptr_t src_offset_in_bytes,
-                   intptr_t length_in_bytes);
-
   static bool IsExternalTypedData(const Instance& obj) {
     ASSERT(!obj.IsNull());
     intptr_t cid = obj.raw()->GetClassId();
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
  protected:
   void SetLength(intptr_t value) const {
     raw_ptr()->length_ = Smi::New(value);
   }
@@ skipping 440 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_