SIMD plumbing

runtime/vm/raw_object_snapshot.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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 2243 matching lines @@
 
   intptr_t len = reader->ReadSmiValue();
   Float32x4Array& result = Float32x4Array::ZoneHandle(
       reader->isolate(), Float32x4Array::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];
+  simd128_value_t v;
   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]));
+    v.storage[0] = reader->Read<float>();
+    v.storage[1] = reader->Read<float>();
+    v.storage[2] = reader->Read<float>();
+    v.storage[3] = reader->Read<float>();
+    result.SetAt(i, v);
   }
   return result.raw();
 }
 
 
 #define EXTERNALARRAY_READ_FROM(name, lname, type)                             \
 RawExternal##name##Array* External##name##Array::ReadFrom(                     \
     SnapshotReader* reader,                                                    \
     intptr_t object_id,                                                        \
     intptr_t tags,                                                             \
     Snapshot::Kind kind) {                                                     \
   ASSERT(kind != Snapshot::kFull);                                             \
   intptr_t length = reader->ReadSmiValue();                                    \
   type* data = reinterpret_cast<type*>(reader->ReadIntptrValue());             \
   const External##name##Array& obj = External##name##Array::Handle(            \
       External##name##Array::New(data, length));                               \
   void* peer = reinterpret_cast<void*>(reader->ReadIntptrValue());             \
   Dart_WeakPersistentHandleFinalizer callback =                                \
       reinterpret_cast<Dart_WeakPersistentHandleFinalizer>(                    \
           reader->ReadIntptrValue());                                          \
   obj.AddFinalizer(peer, callback);                                            \
   return obj.raw();                                                            \
 }                                                                              \
 
 BYTEARRAY_TYPE_LIST(EXTERNALARRAY_READ_FROM)
-EXTERNALARRAY_READ_FROM(Float32x4, Float32x4, simd_value_t)
+EXTERNALARRAY_READ_FROM(Float32x4, Float32x4, simd128_value_t)
 #undef EXTERNALARRAY_READ_FROM
 
 
 template<typename ElementT>
 static void ByteArrayWriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              intptr_t byte_array_kind,
                              intptr_t tags,
                              RawSmi* length,
@@ skipping 485 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart