Really remove SIMD types from dart:scalarlist. Fixes build.

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 1081 matching lines @@
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
 #define REGISTER_SCALARLIST_CLASS(name, object_store_name)                     \
   cls = Class::New<name>();                                                    \
   object_store->set_##object_store_name##_class(cls);                          \
 
-  REGISTER_SCALARLIST_CLASS(Float32x4, float32x4);
-  REGISTER_SCALARLIST_CLASS(Uint32x4, uint32x4);
   REGISTER_SCALARLIST_CLASS(Int8Array, int8_array);
   REGISTER_SCALARLIST_CLASS(Uint8Array, uint8_array);
   REGISTER_SCALARLIST_CLASS(Uint8ClampedArray, uint8_clamped_array);
   REGISTER_SCALARLIST_CLASS(Int16Array, int16_array);
   REGISTER_SCALARLIST_CLASS(Uint16Array, uint16_array);
   REGISTER_SCALARLIST_CLASS(Int32Array, int32_array);
   REGISTER_SCALARLIST_CLASS(Uint32Array, uint32_array);
   REGISTER_SCALARLIST_CLASS(Int64Array, int64_array);
   REGISTER_SCALARLIST_CLASS(Uint64Array, uint64_array);
-  REGISTER_SCALARLIST_CLASS(Float32x4Array, float32x4_array);
   REGISTER_SCALARLIST_CLASS(Float32Array, float32_array);
   REGISTER_SCALARLIST_CLASS(Float64Array, float64_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt8Array, external_int8_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint8Array, external_uint8_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint8ClampedArray,
                             external_uint8_clamped_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt16Array, external_int16_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint16Array, external_uint16_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt32Array, external_int32_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint32Array, external_uint32_array);
   REGISTER_SCALARLIST_CLASS(ExternalInt64Array, external_int64_array);
   REGISTER_SCALARLIST_CLASS(ExternalUint64Array, external_uint64_array);
-  REGISTER_SCALARLIST_CLASS(ExternalFloat32x4Array, external_float32x4_array);
   REGISTER_SCALARLIST_CLASS(ExternalFloat32Array, external_float32_array);
   REGISTER_SCALARLIST_CLASS(ExternalFloat64Array, external_float64_array);
 #undef REGISTER_SCALARLIST_CLASS
 
 #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)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
+  // Add Float32x4 and Uint32x4 to the object store.
+  cls = Class::New<Float32x4>();
+  object_store->set_float32x4_class(cls);
+  cls = Class::New<Uint32x4>();
+  object_store->set_uint32x4_class(cls);
 
   cls = Class::New<Integer>();
   object_store->set_integer_implementation_class(cls);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
@@ skipping 208 matching lines @@
       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 kFloat32x4ArrayCid:
-    case kExternalFloat32x4ArrayCid:
-      return Symbols::Float32x4List().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 11663 matching lines @@
          Class::null());
   return NewImpl<Uint64Array, RawUint64Array>(kClassId, data, len, space);
 }
 
 
 const char* Uint64Array::ToCString() const {
   return "_Uint64Array";
 }
 
 
-RawFloat32x4Array* Float32x4Array::New(intptr_t len,
-                                       Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->float32x4_array_class() !=
-         Class::null());
-  return NewImpl<Float32x4Array, RawFloat32x4Array>(kClassId, len,
-                                                              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";
-}
-
-
 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";
 }
 
 
-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);
-}
-
-
-const char* ExternalFloat32x4Array::ToCString() const {
-  return "_ExternalFloat32x4Array";
-}
-
-
 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 401 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart