Handle TypedDataView objects in Dart_TypedDataAcquireData and

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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.
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 2315 matching lines @@
 
 
 // Helper method to get the type of a TypedData object.
 static Dart_TypedData_Type GetType(intptr_t class_id) {
   Dart_TypedData_Type type;
   switch (class_id) {
     case kByteArrayCid :
       type = kByteData;
       break;
     case kTypedDataInt8ArrayCid :
+    case kTypedDataInt8ArrayViewCid :
     case kExternalTypedDataInt8ArrayCid :
       type = kInt8;
       break;
     case kTypedDataUint8ArrayCid :
+    case kTypedDataUint8ArrayViewCid :
     case kExternalTypedDataUint8ArrayCid :
       type = kUint8;
       break;
     case kTypedDataUint8ClampedArrayCid :
+    case kTypedDataUint8ClampedArrayViewCid :
     case kExternalTypedDataUint8ClampedArrayCid :
       type = kUint8Clamped;
       break;
     case kTypedDataInt16ArrayCid :
+    case kTypedDataInt16ArrayViewCid :
     case kExternalTypedDataInt16ArrayCid :
       type = kInt16;
       break;
     case kTypedDataUint16ArrayCid :
+    case kTypedDataUint16ArrayViewCid :
     case kExternalTypedDataUint16ArrayCid :
       type = kUint16;
       break;
     case kTypedDataInt32ArrayCid :
+    case kTypedDataInt32ArrayViewCid :
     case kExternalTypedDataInt32ArrayCid :
       type = kInt32;
       break;
     case kTypedDataUint32ArrayCid :
+    case kTypedDataUint32ArrayViewCid :
     case kExternalTypedDataUint32ArrayCid :
       type = kUint32;
       break;
     case kTypedDataInt64ArrayCid :
+    case kTypedDataInt64ArrayViewCid :
     case kExternalTypedDataInt64ArrayCid :
       type = kInt64;
       break;
     case kTypedDataUint64ArrayCid :
+    case kTypedDataUint64ArrayViewCid :
     case kExternalTypedDataUint64ArrayCid :
       type = kUint64;
       break;
     case kTypedDataFloat32ArrayCid :
+    case kTypedDataFloat32ArrayViewCid :
     case kExternalTypedDataFloat32ArrayCid :
       type = kFloat32;
       break;
     case kTypedDataFloat64ArrayCid :
+    case kTypedDataFloat64ArrayViewCid :
     case kExternalTypedDataFloat64ArrayCid :
       type = kFloat64;
       break;
     default:
       type = kInvalid;
       break;
   }
   return type;
 }
 
 
 DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfTypedData(Dart_Handle object) {
   intptr_t class_id = Api::ClassId(object);
-  if (!RawObject::IsTypedDataClassId(class_id)) {
+  if (!RawObject::IsTypedDataClassId(class_id) &&
+      !RawObject::IsTypedDataViewClassId(class_id)) {
     return kInvalid;
   }
   return GetType(class_id);
 }
 
 
 DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfExternalTypedData(
     Dart_Handle object) {
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id)) {
@@ skipping 175 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object,
                                                   Dart_TypedData_Type* type,
                                                   void** data,
                                                   intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
+      !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
     RETURN_TYPE_ERROR(isolate, object, 'TypedData');
   }
   if (type == NULL) {
     RETURN_NULL_ERROR(type);
   }
   if (data == NULL) {
     RETURN_NULL_ERROR(data);
   }
   if (len == NULL) {
     RETURN_NULL_ERROR(len);
   }
   // Get the type of typed data object.
   *type = GetType(class_id);
   // If it is an external typed data object just return the data field.
   if (RawObject::IsExternalTypedDataClassId(class_id)) {
     const ExternalTypedData& obj =
         Api::UnwrapExternalTypedDataHandle(isolate, object);
     ASSERT(!obj.IsNull());
     *len = obj.Length();
-    *data = reinterpret_cast<void*>(obj.DataAddr(0));
-  } else {
+    *data = obj.DataAddr(0);
+  } else if (RawObject::IsTypedDataClassId(class_id)) {
     // Regular typed data object, set up some GC and API callback guards.
     const TypedData& obj = Api::UnwrapTypedDataHandle(isolate, object);
     ASSERT(!obj.IsNull());
     *len = obj.Length();
     isolate->IncrementNoGCScopeDepth();
     START_NO_CALLBACK_SCOPE(isolate);
-    *data = reinterpret_cast<void*>(obj.DataAddr(0));
+    *data = obj.DataAddr(0);
+  } else {
+    // typed data view object, set up some GC and API callback guards.
+    // TODO(asiva): Have to come up with a scheme to directly access
+    // the fields using offsets for a more efficient implementation.

[Ivan Posva, 2013/03/22 04:50:01]

How about making class _TypedListView known to the VM in a similar manner to the
way class _TypedList is partially implemented in the VM.

[siva, 2013/03/25 17:20:35]

I thought about this but for now choose against adding two more classes in the
VM (in this case we would need to setup the offsets in the VM code and have some
verification to ensure that the Dart fields and the VM assumptions match).

Maybe if this turns out to be super hot entrypoint we could consider that.

On 2013/03/22 04:50:01, Ivan Posva wrote:

+    Dart_Handle field_name = Dart_NewStringFromCString("length");
+    Dart_Handle field_value = Dart_GetField(object, field_name);
+    ASSERT(Api::IsSmi(field_value));
+    *len = Api::SmiValue(field_value);
+    field_name = Dart_NewStringFromCString("offsetInBytes");
+    field_value = Dart_GetField(object, field_name);
+    ASSERT(Api::IsSmi(field_value));
+    intptr_t offset_in_bytes = Api::SmiValue(field_value);
+    field_name = Dart_NewStringFromCString("_typeddata");
+    field_value = Dart_GetField(object, field_name);
+    const TypedData& obj = Api::UnwrapTypedDataHandle(isolate, field_value);
+    isolate->IncrementNoGCScopeDepth();
+    START_NO_CALLBACK_SCOPE(isolate);
+    *data = obj.DataAddr(offset_in_bytes);
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_TypedDataReleaseData(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
+      !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
     RETURN_TYPE_ERROR(isolate, object, 'TypedData');
   }
   if (!RawObject::IsExternalTypedDataClassId(class_id)) {
     isolate->DecrementNoGCScopeDepth();
     END_NO_CALLBACK_SCOPE(isolate);
   }
   return Api::Success(isolate);
 }
 
@@ skipping 2046 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart