Simd128Float32, Simd128Mask, and Simd128Float32List additions for dart:scalarlist

runtime/vm/object.cc

Index: runtime/vm/object.cc
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index ac6ee8cd0ca469affeeba9fb14d9a5e0c4ffae58..24f6fd221d0ecd5a156f344700565cd909f04646 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -814,6 +814,14 @@ RawError* Object::Init(Isolate* isolate) {
   Library::InitScalarlistLibrary(isolate);
   Library& scalarlist_lib = Library::Handle(Library::ScalarlistLibrary());
 
+  cls = Class::New<Simd128Float32>();
+  object_store->set_simd128_float32_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Simd128Float32(), scalarlist_lib);
+
+  cls = Class::New<Simd128Mask>();
+  object_store->set_simd128_mask_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Simd128Mask(), scalarlist_lib);
+
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Int8Array(), scalarlist_lib);
@@ -850,6 +858,10 @@ RawError* Object::Init(Isolate* isolate) {
   object_store->set_uint64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint64Array(), scalarlist_lib);
 
+  cls = Class::New<Simd128Float32Array>();
+  object_store->set_simd128_float32_array_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Simd128Float32Array(), scalarlist_lib);
+
   cls = Class::New<Float32Array>();
   object_store->set_float32_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32Array(), scalarlist_lib);
@@ -896,6 +908,11 @@ RawError* Object::Init(Isolate* isolate) {
   object_store->set_external_uint64_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_ExternalUint64Array(), scalarlist_lib);
 
+  cls = Class::New<ExternalSimd128Float32Array>();
+  object_store->set_external_simd128_float32_array_class(cls);
+  RegisterPrivateClass(cls, Symbols::_ExternalSimd128Float32Array(),
+                       scalarlist_lib);
+
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
   RegisterPrivateClass(cls, Symbols::_ExternalFloat32Array(), scalarlist_lib);
@@ -1128,6 +1145,12 @@ void Object::InitFromSnapshot(Isolate* isolate) {
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
+  cls = Class::New<Simd128Float32>();
+  object_store->set_simd128_float32_class(cls);
+
+  cls = Class::New<Simd128Mask>();
+  object_store->set_simd128_mask_class(cls);
+
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
 
@@ -1155,6 +1178,9 @@ void Object::InitFromSnapshot(Isolate* isolate) {
   cls = Class::New<Uint64Array>();
   object_store->set_uint64_array_class(cls);
 
+  cls = Class::New<Simd128Float32Array>();
+  object_store->set_simd128_float32_array_class(cls);
+
   cls = Class::New<Float32Array>();
   object_store->set_float32_array_class(cls);
 
@@ -1188,6 +1214,9 @@ void Object::InitFromSnapshot(Isolate* isolate) {
   cls = Class::New<ExternalUint64Array>();
   object_store->set_external_uint64_array_class(cls);
 
+  cls = Class::New<ExternalSimd128Float32Array>();
+  object_store->set_external_simd128_float32_array_class(cls);
+
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
 
@@ -1390,6 +1419,10 @@ RawString* Class::UserVisibleName() const {
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
       return Symbols::List().raw();
+    case kSimd128Float32Cid:
+      return Symbols::Simd128Float32().raw();
+    case kSimd128MaskCid:
+      return Symbols::Simd128Mask().raw();
     case kInt8ArrayCid:
     case kExternalInt8ArrayCid:
       return Symbols::Int8List().raw();
@@ -1417,6 +1450,9 @@ RawString* Class::UserVisibleName() const {
     case kUint64ArrayCid:
     case kExternalUint64ArrayCid:
       return Symbols::Uint64List().raw();
+    case kSimd128Float32ArrayCid:
+    case kExternalSimd128Float32ArrayCid:
+      return Symbols::Simd128Float32List().raw();
     case kFloat32ArrayCid:
     case kExternalFloat32ArrayCid:
       return Symbols::Float32List().raw();
@@ -12049,6 +12085,181 @@ const char* GrowableObjectArray::ToCString() const {
 }
 
 
+RawSimd128Float32* Simd128Float32::New(float v0, float v1, float v2, float v3,
+                                       Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->simd128_float32_class() !=
+         Class::null());
+  Simd128Float32& result = Simd128Float32::Handle();
+  {
+    RawObject* raw = Object::Allocate(Simd128Float32::kClassId,
+                                      Simd128Float32::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();
+}
+
+
+RawSimd128Float32* Simd128Float32::New(simd_value_t value,
+                                       Heap::Space space) {
+ASSERT(Isolate::Current()->object_store()->simd128_float32_class() !=
+         Class::null());
+  Simd128Float32& result = Simd128Float32::Handle();
+  {
+    RawObject* raw = Object::Allocate(Simd128Float32::kClassId,
+                                      Simd128Float32::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_value(value);
+  return result.raw();
+}
+
+
+simd_value_t Simd128Float32::value() const {
+  return simd_value_safe_load(&raw_ptr()->value_[0]);
+}
+
+
+void Simd128Float32::set_value(simd_value_t value) const {
+  simd_value_safe_store(&raw_ptr()->value_[0], value);
+}
+
+
+void Simd128Float32::set_x(float value) const {
+  raw_ptr()->value_[0] = value;
+}
+
+
+void Simd128Float32::set_y(float value) const {
+  raw_ptr()->value_[1] = value;
+}
+
+
+void Simd128Float32::set_z(float value) const {
+  raw_ptr()->value_[2] = value;
+}
+
+
+void Simd128Float32::set_w(float value) const {
+  raw_ptr()->value_[3] = value;
+}
+
+
+float Simd128Float32::x() const {
+  return raw_ptr()->value_[0];
+}
+
+
+float Simd128Float32::y() const {
+  return raw_ptr()->value_[1];
+}
+
+
+float Simd128Float32::z() const {
+  return raw_ptr()->value_[2];
+}
+
+
+float Simd128Float32::w() const {
+  return raw_ptr()->value_[3];
+}
+
+
+const char* Simd128Float32::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;
+}
+
+
+RawSimd128Mask* Simd128Mask::New(uint32_t v0, uint32_t v1, uint32_t v2,
+                                 uint32_t v3, Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->simd128_mask_class() !=
+         Class::null());
+  Simd128Mask& result = Simd128Mask::Handle();
+  {
+    RawObject* raw = Object::Allocate(Simd128Mask::kClassId,
+                                      Simd128Mask::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();
+}
+
+
+void Simd128Mask::set_x(uint32_t value) const {
+  raw_ptr()->value_[0] = value;
+}
+
+
+void Simd128Mask::set_y(uint32_t value) const {
+  raw_ptr()->value_[1] = value;
+}
+
+
+void Simd128Mask::set_z(uint32_t value) const {
+  raw_ptr()->value_[2] = value;
+}
+
+
+void Simd128Mask::set_w(uint32_t value) const {
+  raw_ptr()->value_[3] = value;
+}
+
+
+uint32_t Simd128Mask::x() const {
+  return raw_ptr()->value_[0];
+}
+
+
+uint32_t Simd128Mask::y() const {
+  return raw_ptr()->value_[1];
+}
+
+
+uint32_t Simd128Mask::z() const {
+  return raw_ptr()->value_[2];
+}
+
+
+uint32_t Simd128Mask::w() const {
+  return raw_ptr()->value_[3];
+}
+
+
+const char* Simd128Mask::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,
@@ -12381,6 +12592,30 @@ const char* Uint64Array::ToCString() const {
 }
 
 
+RawSimd128Float32Array* Simd128Float32Array::New(intptr_t len,
+                                                 Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->simd128_float32_array_class() !=
+         Class::null());
+  return NewImpl<Simd128Float32Array, RawSimd128Float32Array>(kClassId, len,
+                                                              space);
+}
+
+
+RawSimd128Float32Array* Simd128Float32Array::New(const simd_value_t* data,
+                                                 intptr_t len,
+                                                 Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float32_array_class() !=
+         Class::null());
+  return NewImpl<Simd128Float32Array, RawSimd128Float32Array>(kClassId, data,
+                                                              len, space);
+}
+
+
+const char* Simd128Float32Array::ToCString() const {
+  return "_Simd128Float32Array";
+}
+
+
 RawFloat32Array* Float32Array::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->float32_array_class() !=
          Class::null());
@@ -12561,6 +12796,24 @@ const char* ExternalUint64Array::ToCString() const {
 }
 
 
+RawExternalSimd128Float32Array* ExternalSimd128Float32Array::New(
+    simd_value_t* data,
+    intptr_t len,
+    Heap::Space space) {
+  RawClass* cls =
+     Isolate::Current()->object_store()->external_simd128_float32_array_class();
+  ASSERT(cls != Class::null());
+  return NewExternalImpl<ExternalSimd128Float32Array,
+                         RawExternalSimd128Float32Array>(kClassId, data, len,
+                                                         space);
+}
+
+
+const char* ExternalSimd128Float32Array::ToCString() const {
+  return "_ExternalSimd128Float32Array";
+}
+
+
 RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
                                                    intptr_t len,
                                                    Heap::Space space) {