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 796 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<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);
 
   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<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);
 
   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<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);
 
   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 212 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<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);
 
   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<Simd128Float32Array>();
+  object_store->set_simd128_float32_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<ExternalSimd128Float32Array>();
+  object_store->set_external_simd128_float32_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 kSimd128Float32Cid:
+      return Symbols::Simd128Float32().raw();
+    case kSimd128MaskCid:
+      return Symbols::Simd128Mask().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 kSimd128Float32ArrayCid:
+    case kExternalSimd128Float32ArrayCid:
+      return Symbols::Simd128Float32List().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 10612 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   return "GrowableObjectArray";
 }
 
 
+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,
                      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";
 }
 
 
+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());
   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";
 }
 
 
+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) {
   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