SIMD plumbing

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 12200 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) {
+                             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) {
+RawFloat32x4* Float32x4::New(simd128_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]);
+simd128_value_t Float32x4::value() const {
+  return simd128_value_t().readFrom(&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_value(simd128_value_t value) const {
+  value.writeTo(&raw_ptr()->value_[0]);
 }
 
 
 void Float32x4::set_x(float value) const {
   raw_ptr()->value_[0] = value;
 }
 
 
 void Float32x4::set_y(float value) const {
   raw_ptr()->value_[1] = value;
@@ skipping 57 matching lines @@
     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) {
+RawUint32x4* Uint32x4::New(simd128_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;
   }
@@ skipping 35 matching lines @@
 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]);
+simd128_value_t Uint32x4::value() const {
+  return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
-void Uint32x4::set_value(simd_value_t value) const {
-  simd_value_safe_store(&raw_ptr()->value_[0], value);
+void Uint32x4::set_value(simd128_value_t value) const {
+  value.writeTo(&raw_ptr()->value_[0]);
 }
 
 
 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.
@@ skipping 449 matching lines @@
   return NewImpl<Uint64Array, RawUint64Array>(kClassId, data, len, space);
 }
 
 
 const char* Uint64Array::ToCString() const {
   return "_Uint64Array";
 }
 
 
 RawFloat32x4Array* Float32x4Array::New(intptr_t len,
-                                                 Heap::Space space) {
+                                       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) {
+RawFloat32x4Array* Float32x4Array::New(const simd128_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";
 }
@@ skipping 172 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) {
+RawExternalFloat32x4Array* ExternalFloat32x4Array::New(simd128_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);
+                                                    space);
 }
 
 
 const char* ExternalFloat32x4Array::ToCString() const {
   return "_ExternalFloat32x4Array";
 }
 
 
 RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
                                                    intptr_t len,
@@ skipping 409 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart