Port SIMD types from dart:scalarlist to dart:typeddata.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 843 matching lines @@
   // Pre-register the scalarlist library so the native class implementations
   // can be hooked up before compiling it.
   LOAD_LIBRARY(Scalarlist, scalarlist);
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::ScalarlistLibrary());
 #define REGISTER_SCALARLIST_CLASS(name, object_store_name)                     \
   cls = Class::New<name>();                                                    \
   object_store->set_##object_store_name##_class(cls);                          \
   RegisterPrivateClass(cls, Symbols::_##name(), lib);                          \
 
-  REGISTER_SCALARLIST_CLASS(Float32x4, float32x4);
-  REGISTER_SCALARLIST_CLASS(Uint32x4, uint32x4);
   REGISTER_SCALARLIST_CLASS(Int8Array, int8_array);
   REGISTER_SCALARLIST_CLASS(Uint8Array, uint8_array);
   REGISTER_SCALARLIST_CLASS(Uint8ClampedArray, uint8_clamped_array);
   REGISTER_SCALARLIST_CLASS(Int16Array, int16_array);
   REGISTER_SCALARLIST_CLASS(Uint16Array, uint16_array);
   REGISTER_SCALARLIST_CLASS(Int32Array, int32_array);
   REGISTER_SCALARLIST_CLASS(Uint32Array, uint32_array);
   REGISTER_SCALARLIST_CLASS(Int64Array, int64_array);
   REGISTER_SCALARLIST_CLASS(Uint64Array, uint64_array);
   REGISTER_SCALARLIST_CLASS(Float32x4Array, float32x4_array);
   REGISTER_SCALARLIST_CLASS(Float32Array, float32_array);
   REGISTER_SCALARLIST_CLASS(Float64Array, float64_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt8Array, external_int8_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint8Array, external_uint8_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint8ClampedArray,
                             external_uint8_clamped_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt16Array, external_int16_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint16Array, external_uint16_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt32Array, external_int32_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint32Array, external_uint32_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt64Array, external_int64_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint64Array, external_uint64_array);
   REGISTER_SCALARLIST_CLASS(ExternalFloat32x4Array, external_float32x4_array);
   REGISTER_SCALARLIST_CLASS(ExternalFloat32Array, external_float32_array);
   REGISTER_SCALARLIST_CLASS(ExternalFloat64Array, external_float64_array);
 #undef REGISTER_SCALARLIST_CLASS
+  // Add Float32x4 and Uint32x4 to dart:scalarlist and register them in
+  // object_store.
+  cls = Class::New<Float32x4>();
+  object_store->set_float32x4_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
+  cls = Class::New<Uint32x4>();
+  object_store->set_uint32x4_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Uint32x4(), lib);

[siva, 2013/03/12 11:44:22]

Why are you adding these classes to the scalarlist library too?

[Cutch, 2013/03/25 21:06:35]

They were already available to scalarlist. What's the best way to handle
exposing the same class from two libraries?

+
 
   // Pre-register the typeddata library so the native class implementations
   // can be hooked up before compiling it.
   LOAD_LIBRARY(TypedData, typeddata);
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
+  const intptr_t typeddata_class_array_length =
+      RawObject::NumberOfTypedDataClasses() + 2;  // +2 for Float32x4 & Uint32x4
   Array& typeddata_classes =
-      Array::Handle(Array::New(RawObject::NumberOfTypedDataClasses()));
+      Array::Handle(Array::New(typeddata_class_array_length));
   int index = 0;
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);                      \
   index = kTypedData##clazz##Cid - kTypedDataInt8ArrayCid;                     \
   typeddata_classes.SetAt(index, cls);                                         \
   RegisterPrivateClass(cls, Symbols::_##clazz(), lib);                         \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);      \
   index = kExternalTypedData##clazz##Cid - kTypedDataInt8ArrayCid;             \
   typeddata_classes.SetAt(index, cls);                                         \
   RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);                 \
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
+  // Add Float32x4 and Uint32x4 to dart:typeddata.
+  cls = object_store->float32x4_class();
+  typeddata_classes.SetAt(typeddata_class_array_length-2, cls);
+  RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
+  cls = object_store->uint32x4_class();
+  typeddata_classes.SetAt(typeddata_class_array_length-1, cls);
+  RegisterPrivateClass(cls, Symbols::_Uint32x4(), lib);
+
   object_store->set_typeddata_classes(typeddata_classes);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
   // Note: The abstract class Function is represented by VM class
   // DartFunction, not VM class Function.
   cls = Class::New<DartFunction>();
@@ skipping 11421 matching lines @@
   uint32_t _w = w();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
 const intptr_t TypedData::element_size[] = {
-  1,  // kTypedDataInt8ArrayCid.
-  1,  // kTypedDataUint8ArrayCid.
-  1,  // kTypedDataUint8ClampedArrayCid.
-  2,  // kTypedDataInt16ArrayCid.
-  2,  // kTypedDataUint16ArrayCid.
-  4,  // kTypedDataInt32ArrayCid.
-  4,  // kTypedDataUint32ArrayCid.
-  8,  // kTypedDataInt64ArrayCid.
-  8,  // kTypedDataUint64ArrayCid.
-  4,  // kTypedDataFloat32ArrayCid.
-  8,  // kTypedDataFloat64ArrayCid.
+  1,   // kTypedDataInt8ArrayCid.
+  1,   // kTypedDataUint8ArrayCid.
+  1,   // kTypedDataUint8ClampedArrayCid.
+  2,   // kTypedDataInt16ArrayCid.
+  2,   // kTypedDataUint16ArrayCid.
+  4,   // kTypedDataInt32ArrayCid.
+  4,   // kTypedDataUint32ArrayCid.
+  8,   // kTypedDataInt64ArrayCid.
+  8,   // kTypedDataUint64ArrayCid.
+  4,   // kTypedDataFloat32ArrayCid.
+  8,   // kTypedDataFloat64ArrayCid.
+  16,  // kTypedDataFloat32x4ArrayCid.
 };
 
 
 RawTypedData* TypedData::New(intptr_t class_id,
                              intptr_t len,
                              Heap::Space space) {
   // TODO(asiva): Add a check for maximum elements.
   TypedData& result = TypedData::Handle();
   {
     // The len field has already been checked by the caller, we only assert
@@ skipping 1018 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart