Simd128Float32, Simd128Mask, and Simd128Float32List additions for dart:scalarlist

runtime/vm/raw_object_snapshot.cc

Index: runtime/vm/raw_object_snapshot.cc
diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc
index 2b4011d4e5579eb88ffb04877370f02edd8d125b..a87db86b8861800d463fc4c463eb96a2d57b8459 100644
--- a/runtime/vm/raw_object_snapshot.cc
+++ b/runtime/vm/raw_object_snapshot.cc
@@ -2045,6 +2045,101 @@ void RawGrowableObjectArray::WriteTo(SnapshotWriter* writer,
 }
 
 
+RawSimd128Float32* Simd128Float32::ReadFrom(SnapshotReader* reader,
+                                            intptr_t object_id,
+                                            intptr_t tags,
+                                            Snapshot::Kind kind) {
+  ASSERT(reader != NULL);
+  // Read the values.
+  float value0 = reader->Read<float>();
+  float value1 = reader->Read<float>();
+  float value2 = reader->Read<float>();
+  float value3 = reader->Read<float>();
+
+  // Create a Simd128Float32 object.
+  Simd128Float32& simd = Simd128Float32::ZoneHandle(reader->isolate(),
+                                                    Simd128Float32::null());
+  if (kind == Snapshot::kFull) {
+    simd = reader->NewSimd128Float32(value0, value1, value2, value3);
+  } else {
+    simd = Simd128Float32::New(value0, value1, value2, value3,
+                               HEAP_SPACE(kind));
+  }
+  reader->AddBackRef(object_id, &simd, kIsDeserialized);
+  // Set the object tags.
+  simd.set_tags(tags);
+  return simd.raw();
+}
+
+
+void RawSimd128Float32::WriteTo(SnapshotWriter* writer,
+                                intptr_t object_id,
+                                Snapshot::Kind kind) {
+  ASSERT(writer != NULL);
+
+  // Write out the serialization header value for this object.
+  writer->WriteInlinedObjectHeader(object_id);
+
+  // Write out the class and tags information.
+  writer->WriteIndexedObject(kSimd128Float32Cid);
+  writer->WriteIntptrValue(writer->GetObjectTags(this));
+
+  // Write out the float values.
+  writer->Write<float>(ptr()->value_[0]);
+  writer->Write<float>(ptr()->value_[1]);
+  writer->Write<float>(ptr()->value_[2]);
+  writer->Write<float>(ptr()->value_[3]);
+}
+
+
+RawSimd128Mask* Simd128Mask::ReadFrom(SnapshotReader* reader,
+                                      intptr_t object_id,
+                                      intptr_t tags,
+                                      Snapshot::Kind kind) {
+  ASSERT(reader != NULL);
+  // Read the values.
+  uint32_t value0 = reader->Read<uint32_t>();
+  uint32_t value1 = reader->Read<uint32_t>();
+  uint32_t value2 = reader->Read<uint32_t>();
+  uint32_t value3 = reader->Read<uint32_t>();
+
+  // Create a Simd128Float32 object.
+  Simd128Mask& simd = Simd128Mask::ZoneHandle(reader->isolate(),
+                                              Simd128Mask::null());
+
+  if (kind == Snapshot::kFull) {
+    simd = reader->NewSimd128Mask(value0, value1, value2, value3);
+  } else {
+    simd = Simd128Mask::New(value0, value1, value2, value3,
+                               HEAP_SPACE(kind));
+  }
+  reader->AddBackRef(object_id, &simd, kIsDeserialized);
+  // Set the object tags.
+  simd.set_tags(tags);
+  return simd.raw();
+}
+
+
+void RawSimd128Mask::WriteTo(SnapshotWriter* writer,
+                             intptr_t object_id,
+                             Snapshot::Kind kind) {
+  ASSERT(writer != NULL);
+
+  // Write out the serialization header value for this object.
+  writer->WriteInlinedObjectHeader(object_id);
+
+  // Write out the class and tags information.
+  writer->WriteIndexedObject(kSimd128MaskCid);
+  writer->WriteIntptrValue(writer->GetObjectTags(this));
+
+  // Write out the mask values.
+  writer->Write<uint32_t>(ptr()->value_[0]);
+  writer->Write<uint32_t>(ptr()->value_[1]);
+  writer->Write<uint32_t>(ptr()->value_[2]);
+  writer->Write<uint32_t>(ptr()->value_[3]);
+}
+
+
 RawByteArray* ByteArray::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
@@ -2106,6 +2201,32 @@ Raw##name##Array* name##Array::ReadFrom(SnapshotReader* reader,                \
 BYTEARRAY_TYPE_LIST(BYTEARRAY_READ_FROM)
 #undef BYTEARRAY_READ_FROM
 
+RawSimd128Float32Array* Simd128Float32Array::ReadFrom(SnapshotReader* reader,
+                                                      intptr_t object_id,
+                                                      intptr_t tags,
+                                                      Snapshot::Kind kind) {
+  ASSERT(reader != NULL);
+
+  intptr_t len = reader->ReadSmiValue();
+  Simd128Float32Array& result = Simd128Float32Array::ZoneHandle(
+      reader->isolate(), Simd128Float32Array::New(len, HEAP_SPACE(kind)));
+  reader->AddBackRef(object_id, &result, kIsDeserialized);
+
+  // Set the object tags.
+  result.set_tags(tags);
+
+  // Setup the array elements.
+  float v[4];
+  for (intptr_t i = 0; i < len; ++i) {
+    v[0] = reader->Read<float>();
+    v[1] = reader->Read<float>();
+    v[2] = reader->Read<float>();
+    v[3] = reader->Read<float>();
+    result.SetAt(i, simd_value_safe_load(&v[0]));
+  }
+  return result.raw();
+}
+
 
 #define EXTERNALARRAY_READ_FROM(name, lname, type)                             \
 RawExternal##name##Array* External##name##Array::ReadFrom(                     \
@@ -2126,8 +2247,8 @@ RawExternal##name##Array* External##name##Array::ReadFrom(                     \
   return obj.raw();                                                            \
 }                                                                              \
 
-
 BYTEARRAY_TYPE_LIST(EXTERNALARRAY_READ_FROM)
+EXTERNALARRAY_READ_FROM(Simd128Float32, simd128float32, simd_value_t)
 #undef EXTERNALARRAY_READ_FROM
 
 
@@ -2183,6 +2304,28 @@ void Raw##name##Array::WriteTo(SnapshotWriter* writer,                         \
 BYTEARRAY_TYPE_LIST(BYTEARRAY_WRITE_TO)
 #undef BYTEARRAY_WRITE_TO
 
+void RawSimd128Float32Array::WriteTo(SnapshotWriter* writer, intptr_t object_id,
+                                     Snapshot::Kind kind) {
+  ASSERT(writer != NULL);
+  RawSmi* length = ptr()->length_;
+  float* data = reinterpret_cast<float*>(&ptr()->data_[0]);
+
+  // Write out the serialization header value for this object.
+  writer->WriteInlinedObjectHeader(object_id);
+
+  // Write out the class and tags information.
+  writer->WriteIndexedObject(kSimd128Float32ArrayCid);
+  writer->WriteIntptrValue(writer->GetObjectTags(this));
+
+  // Write out the length field.
+  writer->Write<RawObject*>(length);
+
+  // Write out the array elements as floats.
+  intptr_t len = Smi::Value(length)*4;
+  for (intptr_t i = 0; i < len; i++) {
+    writer->Write(data[i]);
+  }
+}
 
 #define EXTERNALARRAY_WRITE_TO(name, lname, type)                              \
 void RawExternal##name##Array::WriteTo(SnapshotWriter* writer,                 \
@@ -2200,6 +2343,30 @@ void RawExternal##name##Array::WriteTo(SnapshotWriter* writer,                 \
 
 BYTEARRAY_TYPE_LIST(EXTERNALARRAY_WRITE_TO)
 #undef BYTEARRAY_WRITE_TO
+void RawExternalSimd128Float32Array::WriteTo(SnapshotWriter* writer,
+                                             intptr_t object_id,
+                                             Snapshot::Kind kind) {
+  ASSERT(writer != NULL);
+  RawSmi* length = ptr()->length_;
+  float* data = reinterpret_cast<float*>(&ptr()->data_[0]);
+
+  // Write out the serialization header value for this object.
+  writer->WriteInlinedObjectHeader(object_id);
+
+  // Write out the class and tags information.
+  writer->WriteIndexedObject(kExternalSimd128Float32ArrayCid);
+  writer->WriteIntptrValue(writer->GetObjectTags(this));
+
+  // Write out the length field.
+  writer->Write<RawObject*>(length);
+
+  // Write out the array elements as floats.
+  intptr_t len = Smi::Value(length)*4;
+  for (intptr_t i = 0; i < len; i++) {
+    writer->Write(data[i]);
+  }
+}
+
 #undef BYTEARRAY_TYPE_LIST