Simd128Float32, Simd128Mask, and Simd128Float32List additions for dart:scalarlist

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 806 matching lines @@
   RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   Library::InitScalarlistLibrary(isolate);
   Library& scalarlist_lib = Library::Handle(Library::ScalarlistLibrary());
 
+  cls = Class::New<Float32x4>();
+  object_store->set_float32x4_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Float32x4(), scalarlist_lib);
+
+  cls = Class::New<Uint32x4>();
+  object_store->set_uint32x4_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Uint32x4(), scalarlist_lib);
+
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Int8Array(), scalarlist_lib);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint8Array(), scalarlist_lib);
 
   cls = Class::New<Uint8ClampedArray>();
   object_store->set_uint8_clamped_array_class(cls);
@@ skipping 16 matching lines @@
   RegisterPrivateClass(cls, Symbols::_Uint32Array(), scalarlist_lib);
 
   cls = Class::New<Int64Array>();
   object_store->set_int64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Int64Array(), scalarlist_lib);
 
   cls = Class::New<Uint64Array>();
   object_store->set_uint64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint64Array(), scalarlist_lib);
 
+  cls = Class::New<Float32x4Array>();
+  object_store->set_float32x4_array_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Float32x4Array(), scalarlist_lib);
+
   cls = Class::New<Float32Array>();
   object_store->set_float32_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32Array(), scalarlist_lib);
 
   cls = Class::New<Float64Array>();
   object_store->set_float64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float64Array(), scalarlist_lib);
 
   cls = Class::New<ExternalInt8Array>();
   object_store->set_external_int8_array_class(cls);
@@ skipping 26 matching lines @@
   RegisterPrivateClass(cls, Symbols::_ExternalUint32Array(), scalarlist_lib);
 
   cls = Class::New<ExternalInt64Array>();
   object_store->set_external_int64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_ExternalInt64Array(), scalarlist_lib);
 
   cls = Class::New<ExternalUint64Array>();
   object_store->set_external_uint64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_ExternalUint64Array(), scalarlist_lib);
 
+  cls = Class::New<ExternalFloat32x4Array>();
+  object_store->set_external_float32x4_array_class(cls);
+  RegisterPrivateClass(cls, Symbols::_ExternalFloat32x4Array(),
+                       scalarlist_lib);
+
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_ExternalFloat32Array(), scalarlist_lib);
 
   cls = Class::New<ExternalFloat64Array>();
   object_store->set_external_float64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_ExternalFloat64Array(), scalarlist_lib);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
@@ skipping 230 matching lines @@
 
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
+  cls = Class::New<Float32x4>();
+  object_store->set_float32x4_class(cls);
+
+  cls = Class::New<Uint32x4>();
+  object_store->set_uint32x4_class(cls);
+
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
 
   cls = Class::New<Uint8ClampedArray>();
   object_store->set_uint8_clamped_array_class(cls);
 
   cls = Class::New<Int16Array>();
   object_store->set_int16_array_class(cls);
 
   cls = Class::New<Uint16Array>();
   object_store->set_uint16_array_class(cls);
 
   cls = Class::New<Int32Array>();
   object_store->set_int32_array_class(cls);
 
   cls = Class::New<Uint32Array>();
   object_store->set_uint32_array_class(cls);
 
   cls = Class::New<Int64Array>();
   object_store->set_int64_array_class(cls);
 
   cls = Class::New<Uint64Array>();
   object_store->set_uint64_array_class(cls);
 
+  cls = Class::New<Float32x4Array>();
+  object_store->set_float32x4_array_class(cls);
+
   cls = Class::New<Float32Array>();
   object_store->set_float32_array_class(cls);
 
   cls = Class::New<Float64Array>();
   object_store->set_float64_array_class(cls);
 
   cls = Class::New<ExternalInt8Array>();
   object_store->set_external_int8_array_class(cls);
 
   cls = Class::New<ExternalUint8Array>();
@@ skipping 13 matching lines @@
 
   cls = Class::New<ExternalUint32Array>();
   object_store->set_external_uint32_array_class(cls);
 
   cls = Class::New<ExternalInt64Array>();
   object_store->set_external_int64_array_class(cls);
 
   cls = Class::New<ExternalUint64Array>();
   object_store->set_external_uint64_array_class(cls);
 
+  cls = Class::New<ExternalFloat32x4Array>();
+  object_store->set_external_float32x4_array_class(cls);
+
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
 
   cls = Class::New<ExternalFloat64Array>();
   object_store->set_external_float64_array_class(cls);
 
   cls = Class::New<Integer>();
   object_store->set_integer_implementation_class(cls);
 
   cls = Class::New<Smi>();
@@ skipping 182 matching lines @@
       return Symbols::Double().raw();
     case kOneByteStringCid:
     case kTwoByteStringCid:
     case kExternalOneByteStringCid:
     case kExternalTwoByteStringCid:
       return Symbols::New("String");
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
       return Symbols::List().raw();
+    case kFloat32x4Cid:
+      return Symbols::Float32x4().raw();
+    case kUint32x4Cid:
+      return Symbols::Uint32x4().raw();
     case kInt8ArrayCid:
     case kExternalInt8ArrayCid:
       return Symbols::Int8List().raw();
     case kUint8ArrayCid:
     case kExternalUint8ArrayCid:
       return Symbols::Uint8List().raw();
     case kUint8ClampedArrayCid:
     case kExternalUint8ClampedArrayCid:
       return Symbols::Uint8ClampedList().raw();
     case kInt16ArrayCid:
     case kExternalInt16ArrayCid:
       return Symbols::Int16List().raw();
     case kUint16ArrayCid:
     case kExternalUint16ArrayCid:
       return Symbols::Uint16List().raw();
     case kInt32ArrayCid:
     case kExternalInt32ArrayCid:
       return Symbols::Int32List().raw();
     case kUint32ArrayCid:
     case kExternalUint32ArrayCid:
       return Symbols::Uint32List().raw();
     case kInt64ArrayCid:
     case kExternalInt64ArrayCid:
       return Symbols::Int64List().raw();
     case kUint64ArrayCid:
     case kExternalUint64ArrayCid:
       return Symbols::Uint64List().raw();
+    case kFloat32x4ArrayCid:
+    case kExternalFloat32x4ArrayCid:
+      return Symbols::Float32x4List().raw();
     case kFloat32ArrayCid:
     case kExternalFloat32ArrayCid:
       return Symbols::Float32List().raw();
     case kFloat64ArrayCid:
     case kExternalFloat64ArrayCid:
       return Symbols::Float64List().raw();
     default:
       if (!IsSignatureClass()) {
         const String& name = String::Handle(Name());
         return IdentifierPrettyName(name);
@@ skipping 10712 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   return "GrowableObjectArray";
 }
 
 
+RawFloat32x4* Float32x4::New(float v0, float v1, float v2, float v3,
+                                       Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
+         Class::null());
+  Float32x4& result = Float32x4::Handle();
+  {
+    RawObject* raw = Object::Allocate(Float32x4::kClassId,
+                                      Float32x4::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_x(v0);
+  result.set_y(v1);
+  result.set_z(v2);
+  result.set_w(v3);
+  return result.raw();
+}
+
+
+RawFloat32x4* Float32x4::New(simd_value_t value, Heap::Space space) {
+ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
+         Class::null());
+  Float32x4& result = Float32x4::Handle();
+  {
+    RawObject* raw = Object::Allocate(Float32x4::kClassId,
+                                      Float32x4::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_value(value);
+  return result.raw();
+}
+
+
+simd_value_t Float32x4::value() const {
+  return simd_value_safe_load(&raw_ptr()->value_[0]);
+}
+
+
+void Float32x4::set_value(simd_value_t value) const {
+  simd_value_safe_store(&raw_ptr()->value_[0], value);
+}
+
+
+void Float32x4::set_x(float value) const {
+  raw_ptr()->value_[0] = value;
+}
+
+
+void Float32x4::set_y(float value) const {
+  raw_ptr()->value_[1] = value;
+}
+
+
+void Float32x4::set_z(float value) const {
+  raw_ptr()->value_[2] = value;
+}
+
+
+void Float32x4::set_w(float value) const {
+  raw_ptr()->value_[3] = value;
+}
+
+
+float Float32x4::x() const {
+  return raw_ptr()->value_[0];
+}
+
+
+float Float32x4::y() const {
+  return raw_ptr()->value_[1];
+}
+
+
+float Float32x4::z() const {
+  return raw_ptr()->value_[2];
+}
+
+
+float Float32x4::w() const {
+  return raw_ptr()->value_[3];
+}
+
+
+const char* Float32x4::ToCString() const {
+  const char* kFormat = "[%f, %f, %f, %f]";
+  float _x = x();
+  float _y = y();
+  float _z = z();
+  float _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;
+}
+
+
+RawUint32x4* Uint32x4::New(uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3,
+                           Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->uint32x4_class() !=
+         Class::null());
+  Uint32x4& result = Uint32x4::Handle();
+  {
+    RawObject* raw = Object::Allocate(Uint32x4::kClassId,
+                                      Uint32x4::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_x(v0);
+  result.set_y(v1);
+  result.set_z(v2);
+  result.set_w(v3);
+  return result.raw();
+}
+
+
+RawUint32x4* Uint32x4::New(simd_value_t value, Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
+         Class::null());
+  Uint32x4& result = Uint32x4::Handle();
+  {
+    RawObject* raw = Object::Allocate(Uint32x4::kClassId,
+                                      Uint32x4::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_value(value);
+  return result.raw();
+}
+
+
+void Uint32x4::set_x(uint32_t value) const {
+  raw_ptr()->value_[0] = value;
+}
+
+
+void Uint32x4::set_y(uint32_t value) const {
+  raw_ptr()->value_[1] = value;
+}
+
+
+void Uint32x4::set_z(uint32_t value) const {
+  raw_ptr()->value_[2] = value;
+}
+
+
+void Uint32x4::set_w(uint32_t value) const {
+  raw_ptr()->value_[3] = value;
+}
+
+
+uint32_t Uint32x4::x() const {
+  return raw_ptr()->value_[0];
+}
+
+
+uint32_t Uint32x4::y() const {
+  return raw_ptr()->value_[1];
+}
+
+
+uint32_t Uint32x4::z() const {
+  return raw_ptr()->value_[2];
+}
+
+
+uint32_t Uint32x4::w() const {
+  return raw_ptr()->value_[3];
+}
+
+
+simd_value_t Uint32x4::value() const {
+  return simd_value_safe_load(&raw_ptr()->value_[0]);
+}
+
+
+void Uint32x4::set_value(simd_value_t value) const {
+  simd_value_safe_store(&raw_ptr()->value_[0], value);
+}
+
+
+const char* Uint32x4::ToCString() const {
+  const char* kFormat = "[%08x, %08x, %08x, %08x]";
+  uint32_t _x = x();
+  uint32_t _y = y();
+  uint32_t _z = z();
+  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;
+}
+
+
 void ByteArray::Copy(void* dst,
                      const ByteArray& src,
                      intptr_t src_offset,
                      intptr_t length) {
   ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
   {
     NoGCScope no_gc;
     if (length > 0) {
       memmove(dst, src.ByteAddr(src_offset), length);
     }
@@ skipping 312 matching lines @@
          Class::null());
   return NewImpl<Uint64Array, RawUint64Array>(kClassId, data, len, space);
 }
 
 
 const char* Uint64Array::ToCString() const {
   return "_Uint64Array";
 }
 
 
+RawFloat32x4Array* Float32x4Array::New(intptr_t len,
+                                                 Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float32x4_array_class() !=
+         Class::null());
+  return NewImpl<Float32x4Array, RawFloat32x4Array>(kClassId, len,
+                                                              space);
+}
+
+
+RawFloat32x4Array* Float32x4Array::New(const simd_value_t* data,
+                                                 intptr_t len,
+                                                 Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float32_array_class() !=
+         Class::null());
+  return NewImpl<Float32x4Array, RawFloat32x4Array>(kClassId, data,
+                                                              len, space);
+}
+
+
+const char* Float32x4Array::ToCString() const {
+  return "_Float32x4Array";
+}
+
+
 RawFloat32Array* Float32Array::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32_array_class() !=
          Class::null());
   return NewImpl<Float32Array, RawFloat32Array>(kClassId, len, space);
 }
 
 
 RawFloat32Array* Float32Array::New(const float* data,
                                    intptr_t len,
                                    Heap::Space space) {
@@ skipping 160 matching lines @@
   return NewExternalImpl<ExternalUint64Array,
                          RawExternalUint64Array>(kClassId, data, len, space);
 }
 
 
 const char* ExternalUint64Array::ToCString() const {
   return "_ExternalUint64Array";
 }
 
 
+RawExternalFloat32x4Array* ExternalFloat32x4Array::New(
+    simd_value_t* data,
+    intptr_t len,
+    Heap::Space space) {
+  RawClass* cls =
+     Isolate::Current()->object_store()->external_float32x4_array_class();
+  ASSERT(cls != Class::null());
+  return NewExternalImpl<ExternalFloat32x4Array,
+                         RawExternalFloat32x4Array>(kClassId, data, len,
+                                                         space);
+}
+
+
+const char* ExternalFloat32x4Array::ToCString() const {
+  return "_ExternalFloat32x4Array";
+}
+
+
 RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
                                                    intptr_t len,
                                                    Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_float32_array_class() !=
          Class::null());
   return NewExternalImpl<ExternalFloat32Array,
                          RawExternalFloat32Array>(kClassId, data, len, space);
 }
 
 
@@ skipping 318 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart