Add Float64x2, Float64x2List, etc... with runtime and dart2js implementations

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/cpu.h"
@@ skipping 1171 matching lines @@
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
   // Register Float32x4 and Int32x4 in the object store.
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
   cls = Class::New<Int32x4>();
   object_store->set_int32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Int32x4(), lib);
+  cls = Class::New<Float64x2>();
+  object_store->set_float64x2_class(cls);
+  RegisterPrivateClass(cls, Symbols::_Float64x2(), lib);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Float32x4(), lib);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_float32x4_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Int32x4(), lib);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int32x4_type(type);
 
+  cls = Class::New<Instance>(kIllegalCid);
+  RegisterClass(cls, Symbols::Float64x2(), lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
+  cls.set_is_prefinalized();
+  pending_classes.Add(cls);
+  type = Type::NewNonParameterizedType(cls);
+  object_store->set_float64x2_type(type);
+
   object_store->set_typed_data_classes(typed_data_classes);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   type = object_store->object_type();
   cls.set_super_type(type);
 
   // Abstract class that represents the Dart class Function.
   cls = Class::New<Instance>(kIllegalCid);
@@ skipping 120 matching lines @@
 
   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<Int32x4>();
   object_store->set_int32x4_class(cls);
 
+  cls = Class::New<Float64x2>();
+  object_store->set_float64x2_class(cls);
+
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
@@ skipping 14998 matching lines @@
   }
   result.set_x(v0);
   result.set_y(v1);
   result.set_z(v2);
   result.set_w(v3);
   return result.raw();
 }
 
 
 RawFloat32x4* Float32x4::New(simd128_value_t value, Heap::Space space) {
-ASSERT(Isolate::Current()->object_store()->float32x4_class() !=
+  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);
@@ skipping 168 matching lines @@
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
 void Int32x4::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
+RawFloat64x2* Float64x2::New(double value0, double value1, Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
+         Class::null());
+  Float64x2& result = Float64x2::Handle();
+  {
+    RawObject* raw = Object::Allocate(Float64x2::kClassId,
+                                      Float64x2::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_x(value0);
+  result.set_y(value1);
+  return result.raw();
+}
+
+
+RawFloat64x2* Float64x2::New(simd128_value_t value, Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->float64x2_class() !=
+         Class::null());
+  Float64x2& result = Float64x2::Handle();
+  {
+    RawObject* raw = Object::Allocate(Float64x2::kClassId,
+                                      Float64x2::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_value(value);
+  return result.raw();
+}
+
+
+double Float64x2::x() const {
+  return raw_ptr()->value_[0];
+}
+
+
+double Float64x2::y() const {
+  return raw_ptr()->value_[1];
+}
+
+
+void Float64x2::set_x(double x) const {
+  raw_ptr()->value_[0] = x;
+}
+
+
+void Float64x2::set_y(double y) const {
+  raw_ptr()->value_[1] = y;
+}
+
+
+simd128_value_t Float64x2::value() const {
+  return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
+}
+
+
+void Float64x2::set_value(simd128_value_t value) const {
+  value.writeTo(&raw_ptr()->value_[0]);
+}
+
+
+const char* Float64x2::ToCString() const {
+  const char* kFormat = "[%f, %f]";
+  double _x = x();
+  double _y = y();
+  // Calculate the size of the string.
+  intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, kFormat, _x, _y);
+  return chars;
+}
+
+
+void Float64x2::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  Instance::PrintToJSONStream(stream, ref);
+}
+
+
 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.
   16,  // kTypedDataFloat32x4ArrayCid.
   16,  // kTypedDataInt32x4ArrayCid.
+  16,  // kTypedDataFloat64x2ArrayCid,
 };
 
 
 RawTypedData* TypedData::New(intptr_t class_id,
                              intptr_t len,
                              Heap::Space space) {
   if (len < 0 || len > TypedData::MaxElements(class_id)) {
     FATAL1("Fatal error in TypedData::New: invalid len %" Pd "\n", len);
   }
   TypedData& result = TypedData::Handle();
@@ skipping 531 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart