Implement {Int,Uint}{8,16,32,64} and Float{32,64} typed arrays.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 435 matching lines @@
                            const char* cname,
                            const Script& script,
                            const Library& lib) {
   const String& name = String::Handle(String::NewSymbol(cname));
   cls.set_name(name);
   cls.set_script(script);
   lib.AddClass(cls);
 }
 
 
+void Object::RegisterPrivateClass(const Class& cls,
+                                  const char* public_class_name,
+                                  const Script& script,
+                                  const Library& lib) {
+  String& str = String::Handle();
+  str ^= String::NewSymbol(public_class_name);
+  str ^= lib.PrivateName(str);
+  cls.set_name(str);
+  cls.set_script(script);
+  lib.AddClass(cls);
+}
+
+
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
   Type& type = Type::Handle();
   Array& array = Array::Handle();
 
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
@@ skipping 131 matching lines @@
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   RegisterClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadScript());
 
-  // Allocate and initialize the Object class and type.
-  // The Object and ExternalByteArray classes are the only pre-allocated
+  // Allocate and initialize the Object class and type.  The Object
+  // class and ByteArray subclasses are the only pre-allocated,
   // non-interface classes in the core library.
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
   cls.set_name(String::Handle(String::NewSymbol("Object")));
   cls.set_script(script);
   cls.set_class_state(RawClass::kPreFinalized);
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
-  cls = Class::New<InternalByteArray>();
-  object_store->set_internal_byte_array_class(cls);
-  String& public_class_name = String::Handle();
-  public_class_name = String::New("_InternalByteArray");
-  cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
-  cls.set_script(script);
-  core_lib.AddClass(cls);
+  cls = Class::New<Int8Array>();
+  object_store->set_int8_array_class(cls);
+  RegisterPrivateClass(cls, "_Int8Array", script, core_lib);
 
-  cls = Class::New<ExternalByteArray>();
-  object_store->set_external_byte_array_class(cls);
-  public_class_name = String::New("_ExternalByteArray");
-  cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
-  cls.set_script(script);
-  core_lib.AddClass(cls);
+  cls = Class::New<Uint8Array>();
+  object_store->set_uint8_array_class(cls);
+  RegisterPrivateClass(cls, "_Uint8Array", script, core_lib);
+
+  cls = Class::New<Int16Array>();
+  object_store->set_int16_array_class(cls);
+  RegisterPrivateClass(cls, "_Int16Array", script, core_lib);
+
+  cls = Class::New<Uint16Array>();
+  object_store->set_uint16_array_class(cls);
+  RegisterPrivateClass(cls, "_Uint16Array", script, core_lib);
+
+  cls = Class::New<Int32Array>();
+  object_store->set_int32_array_class(cls);
+  RegisterPrivateClass(cls, "_Int32Array", script, core_lib);
+
+  cls = Class::New<Uint32Array>();
+  object_store->set_uint32_array_class(cls);
+  RegisterPrivateClass(cls, "_Uint32Array", script, core_lib);
+
+  cls = Class::New<Int64Array>();
+  object_store->set_int64_array_class(cls);
+  RegisterPrivateClass(cls, "_Int64Array", script, core_lib);
+
+  cls = Class::New<Uint64Array>();
+  object_store->set_uint64_array_class(cls);
+  RegisterPrivateClass(cls, "_Uint64Array", script, core_lib);
+
+  cls = Class::New<Float32Array>();
+  object_store->set_float32_array_class(cls);
+  RegisterPrivateClass(cls, "_Float32Array", script, core_lib);
+
+  cls = Class::New<Float64Array>();
+  object_store->set_float64_array_class(cls);
+  RegisterPrivateClass(cls, "_Float64Array", script, core_lib);
+
+  cls = Class::New<ExternalInt8Array>();
+  object_store->set_external_int8_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalInt8Array", script, core_lib);
+
+  cls = Class::New<ExternalUint8Array>();
+  object_store->set_external_uint8_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalUint8Array", script, core_lib);
+
+  cls = Class::New<ExternalInt16Array>();
+  object_store->set_external_int16_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalInt16Array", script, core_lib);
+
+  cls = Class::New<ExternalUint16Array>();
+  object_store->set_external_uint16_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalUint16Array", script, core_lib);
+
+  cls = Class::New<ExternalInt32Array>();
+  object_store->set_external_int32_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalInt32Array", script, core_lib);
+
+  cls = Class::New<ExternalUint32Array>();
+  object_store->set_external_uint32_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalUint32Array", script, core_lib);
+
+  cls = Class::New<ExternalInt64Array>();
+  object_store->set_external_int64_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalInt64Array", script, core_lib);
+
+  cls = Class::New<ExternalUint64Array>();
+  object_store->set_external_uint64_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalUint64Array", script, core_lib);
+
+  cls = Class::New<ExternalFloat32Array>();
+  object_store->set_external_float32_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalFloat32Array", script, core_lib);
+
+  cls = Class::New<ExternalFloat64Array>();
+  object_store->set_external_float64_array_class(cls);
+  RegisterPrivateClass(cls, "_ExternalFloat64Array", script, core_lib);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
   cls = CreateAndRegisterInterface("Function", script, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_interface(type);
@@ skipping 120 matching lines @@
   Array& empty_array = Array::Handle();
   empty_array = Array::New(0);
   object_store->set_empty_array(empty_array);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
-  cls = Class::New<InternalByteArray>();
-  object_store->set_internal_byte_array_class(cls);
+  cls = Class::New<Int8Array>();
+  object_store->set_int8_array_class(cls);
 
-  cls = Class::New<ExternalByteArray>();
-  object_store->set_external_byte_array_class(cls);
+  cls = Class::New<Uint8Array>();
+  object_store->set_uint8_array_class(cls);
+
+  cls = Class::New<Int16Array>();
+  object_store->set_int16_array_class(cls);
+
+  cls = Class::New<Uint16Array>();
+  object_store->set_uint16_array_class(cls);
+
+  cls = Class::New<Int32Array>();
+  object_store->set_int32_array_class(cls);
+
+  cls = Class::New<Uint32Array>();
+  object_store->set_uint32_array_class(cls);
+
+  cls = Class::New<Int64Array>();
+  object_store->set_int64_array_class(cls);
+
+  cls = Class::New<Uint64Array>();
+  object_store->set_uint64_array_class(cls);
+
+  cls = Class::New<Float32Array>();
+  object_store->set_float32_array_class(cls);
+
+  cls = Class::New<Float64Array>();
+  object_store->set_float64_array_class(cls);
+
+  cls = Class::New<ExternalInt8Array>();
+  object_store->set_external_int8_array_class(cls);
+
+  cls = Class::New<ExternalUint8Array>();
+  object_store->set_external_uint8_array_class(cls);
+
+  cls = Class::New<ExternalInt16Array>();
+  object_store->set_external_int16_array_class(cls);
+
+  cls = Class::New<ExternalUint16Array>();
+  object_store->set_external_uint16_array_class(cls);
+
+  cls = Class::New<ExternalInt32Array>();
+  object_store->set_external_int32_array_class(cls);
+
+  cls = Class::New<ExternalUint32Array>();
+  object_store->set_external_uint32_array_class(cls);
+
+  cls = Class::New<ExternalInt64Array>();
+  object_store->set_external_int64_array_class(cls);
+
+  cls = Class::New<ExternalUint64Array>();
+  object_store->set_external_uint64_array_class(cls);
+
+  cls = Class::New<ExternalFloat32Array>();
+  object_store->set_external_float32_array_class(cls);
+
+  cls = Class::New<ExternalFloat64Array>();
+  object_store->set_external_float64_array_class(cls);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
 
@@ skipping 167 matching lines @@
   // TODO(srdjan): Make functions_cache growable and start with a smaller size.
   Array& fcache =
       Array::Handle(Array::New(FunctionsCache::kNumEntries * 32, Heap::kOld));
   StorePointer(&raw_ptr()->functions_cache_, fcache.raw());
   StorePointer(&raw_ptr()->constants_, empty_array.raw());
   StorePointer(&raw_ptr()->canonical_types_, empty_array.raw());
   StorePointer(&raw_ptr()->functions_, empty_array.raw());
   StorePointer(&raw_ptr()->fields_, empty_array.raw());
 }
 
+
+bool Class::HasInstanceFields() const {
+  const Array& field_array = Array::Handle(fields());
+  Field& field = Field::Handle();
+  for (intptr_t i = 0; i < field_array.Length(); ++i) {
+    field ^= field_array.At(i);
+    if (!field.is_static()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 void Class::SetFunctions(const Array& value) const {
   ASSERT(!value.IsNull());
   // Bind all the functions in the array to this class.
   Function& func = Function::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
     func ^= value.At(i);
     func.set_owner(*this);
   }
   StorePointer(&raw_ptr()->functions_, value.raw());
@@ skipping 410 matching lines @@
       return object_store->bool_class();
     case kArray:
       ASSERT(object_store->array_class() != Class::null());
       return object_store->array_class();
     case kImmutableArray:
       ASSERT(object_store->immutable_array_class() != Class::null());
       return object_store->immutable_array_class();
     case kGrowableObjectArray:
       ASSERT(object_store->growable_object_array_class() != Class::null());
       return object_store->growable_object_array_class();
-    case kInternalByteArray:
-      ASSERT(object_store->internal_byte_array_class() != Class::null());
-      return object_store->internal_byte_array_class();
-    case kExternalByteArray:
-      ASSERT(object_store->external_byte_array_class() != Class::null());
-      return object_store->external_byte_array_class();
+    case kInt8Array:
+      ASSERT(object_store->int8_array_class() != Class::null());
+      return object_store->int8_array_class();
+    case kUint8Array:
+      ASSERT(object_store->uint8_array_class() != Class::null());
+      return object_store->uint8_array_class();
+    case kInt16Array:
+      ASSERT(object_store->int16_array_class() != Class::null());
+      return object_store->int16_array_class();
+    case kUint16Array:
+      ASSERT(object_store->uint16_array_class() != Class::null());
+      return object_store->uint16_array_class();
+    case kInt32Array:
+      ASSERT(object_store->int32_array_class() != Class::null());
+      return object_store->int32_array_class();
+    case kUint32Array:
+      ASSERT(object_store->uint32_array_class() != Class::null());
+      return object_store->uint32_array_class();
+    case kInt64Array:
+      ASSERT(object_store->int64_array_class() != Class::null());
+      return object_store->int64_array_class();
+    case kUint64Array:
+      ASSERT(object_store->uint64_array_class() != Class::null());
+      return object_store->uint64_array_class();
+    case kFloat32Array:
+      ASSERT(object_store->float32_array_class() != Class::null());
+      return object_store->float32_array_class();
+    case kFloat64Array:
+      ASSERT(object_store->float64_array_class() != Class::null());
+      return object_store->float64_array_class();
+    case kExternalInt8Array:
+      ASSERT(object_store->external_int8_array_class() != Class::null());
+      return object_store->external_int8_array_class();
+    case kExternalUint8Array:
+      ASSERT(object_store->external_uint8_array_class() != Class::null());
+      return object_store->external_uint8_array_class();
+    case kExternalInt16Array:
+      ASSERT(object_store->external_int16_array_class() != Class::null());
+      return object_store->external_int16_array_class();
+    case kExternalUint16Array:
+      ASSERT(object_store->external_uint16_array_class() != Class::null());
+      return object_store->external_uint16_array_class();
+    case kExternalInt32Array:
+      ASSERT(object_store->external_int32_array_class() != Class::null());
+      return object_store->external_int32_array_class();
+    case kExternalUint32Array:
+      ASSERT(object_store->external_uint32_array_class() != Class::null());
+      return object_store->external_uint32_array_class();
+    case kExternalInt64Array:
+      ASSERT(object_store->external_int64_array_class() != Class::null());
+      return object_store->external_int64_array_class();
+    case kExternalUint64Array:
+      ASSERT(object_store->external_uint64_array_class() != Class::null());
+      return object_store->external_uint64_array_class();
+    case kExternalFloat32Array:
+      ASSERT(object_store->external_float32_array_class() != Class::null());
+      return object_store->external_float32_array_class();
+    case kExternalFloat64Array:
+      ASSERT(object_store->external_float64_array_class() != Class::null());
+      return object_store->external_float64_array_class();
     case kStacktrace:
       ASSERT(object_store->stacktrace_class() != Class::null());
       return object_store->stacktrace_class();
     case kJSRegExp:
       ASSERT(object_store->jsregexp_class() != Class::null());
       return object_store->jsregexp_class();
     case kClosure:
       return Class::New<Closure>();
     case kInstance:
       return Class::New<Instance>();
@@ skipping 7495 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   return "GrowableObjectArray";
 }
 
 
-intptr_t ByteArray::Length() const {
-  // ByteArray is an abstract class.
-  UNREACHABLE();
-  return 0;
-}
-
-
-void ByteArray::Copy(uint8_t* dst,
+void ByteArray::Copy(void* dst,
                      const ByteArray& src,
                      intptr_t src_offset,
                      intptr_t length) {
-  ASSERT(Utils::RangeCheck(src_offset, length, src.Length()));
+  ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
   {
     NoGCScope no_gc;
     if (length > 0) {
       memmove(dst, src.ByteAddr(src_offset), length);
     }
   }
 }
 
 
 void ByteArray::Copy(const ByteArray& dst,
                      intptr_t dst_offset,
-                     const uint8_t* src,
+                     const void* src,
                      intptr_t length) {
-  ASSERT(Utils::RangeCheck(dst_offset, length, dst.Length()));
+  ASSERT(Utils::RangeCheck(dst_offset, length, dst.ByteLength()));
   {
     NoGCScope no_gc;
     if (length > 0) {
       memmove(dst.ByteAddr(dst_offset), src, length);
     }
   }
 }
 
 
 void ByteArray::Copy(const ByteArray& dst,
                      intptr_t dst_offset,
                      const ByteArray& src,
                      intptr_t src_offset,
                      intptr_t length) {
-  ASSERT(Utils::RangeCheck(src_offset, length, src.Length()));
-  ASSERT(Utils::RangeCheck(dst_offset, length, dst.Length()));
+  ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
+  ASSERT(Utils::RangeCheck(dst_offset, length, dst.ByteLength()));
   {
     NoGCScope no_gc;
     if (length > 0) {
       memmove(dst.ByteAddr(dst_offset), src.ByteAddr(src_offset), length);
     }
   }
 }
 
 
+template<typename T>
+static void ExternalByteArrayFinalize(Dart_Handle handle, void* peer) {
+  delete reinterpret_cast<ExternalByteArrayData<T>*>(peer);
+  DeleteWeakPersistentHandle(handle);
+}
+
+
+template<typename HandleT, typename RawT, typename ElementT>
+RawT* ByteArray::NewExternalImpl(const Class& cls,
+                                 ElementT* data,
+                                 intptr_t len,
+                                 void* peer,
+                                 Dart_PeerFinalizer callback,
+                                 Heap::Space space) {
+  HandleT& result = HandleT::Handle();
+  ExternalByteArrayData<ElementT>* external_data =
+      new ExternalByteArrayData<ElementT>(data, peer, callback);
+  {
+    RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(), space);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(len);
+    result.SetExternalData(external_data);
+  }
+  AddFinalizer(result, external_data, ExternalByteArrayFinalize<ElementT>);
+  return result.raw();
+}
+
+
+intptr_t ByteArray::ByteLength() const {
+  // ByteArray is an abstract class.
+  UNREACHABLE();
+  return 0;
+}
+
+
 uint8_t* ByteArray::ByteAddr(intptr_t byte_offset) const {
   // ByteArray is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 const char* ByteArray::ToCString() const {
   // ByteArray is an abstract class.
   UNREACHABLE();
   return "ByteArray";
 }
 
 
-RawInternalByteArray* InternalByteArray::New(intptr_t len,
-                                             Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-  const Class& internal_byte_array_class =
-      Class::Handle(isolate->object_store()->internal_byte_array_class());
-  InternalByteArray& result = InternalByteArray::Handle();
+template<typename HandleT, typename RawT>
+RawT* ByteArray::NewImpl(const Class& cls, intptr_t len, Heap::Space space) {
+  HandleT& result = HandleT::Handle();
   {
-    RawObject* raw = Object::Allocate(internal_byte_array_class,
-                                      InternalByteArray::InstanceSize(len),
-                                      space);
+    RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     if (len > 0) {
-      memset(result.Addr<uint8_t>(0), 0, len);
+      memset(result.ByteAddr(0), 0, result.ByteLength());
     }
   }
   return result.raw();
 }
 
 
-RawInternalByteArray* InternalByteArray::New(const uint8_t* data,
-                                             intptr_t len,
-                                             Heap::Space space) {
-  InternalByteArray& result =
-      InternalByteArray::Handle(InternalByteArray::New(len, space));
+template<typename HandleT, typename RawT, typename ElementT>
+RawT* ByteArray::NewImpl(const Class& cls,
+                         const ElementT* data,
+                         intptr_t len,
+                         Heap::Space space) {
+  HandleT& result = HandleT::Handle();
   {
+    RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
     NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(len);
     if (len > 0) {
-      memmove(result.Addr<uint8_t>(0), data, len);
+      memmove(result.ByteAddr(0), data, result.ByteLength());
     }
   }
   return result.raw();
 }
 
 
-const char* InternalByteArray::ToCString() const {
-  return "_InternalByteArray";
-}
-
-
-void ExternalByteArray::Finalize(Dart_Handle handle, void* peer) {
-  delete reinterpret_cast<ExternalByteArrayData*>(peer);
-  DeleteWeakPersistentHandle(handle);
-}
-
-
-RawExternalByteArray* ExternalByteArray::New(uint8_t* data,
+RawInt8Array* Int8Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int8_array_class());
+  return NewImpl<Int8Array, RawInt8Array>(cls, len, space);
+}
+
+
+RawInt8Array* Int8Array::New(const int8_t* data,
+                             intptr_t len,
+                             Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int8_array_class());
+  return NewImpl<Int8Array, RawInt8Array>(cls, data, len, space);
+}
+
+
+const char* Int8Array::ToCString() const {
+  return "_Int8Array";
+}
+
+
+RawUint8Array* Uint8Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint8_array_class());
+  return NewImpl<Uint8Array, RawUint8Array>(cls, len, space);
+}
+
+
+RawUint8Array* Uint8Array::New(const uint8_t* data,
+                               intptr_t len,
+                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint8_array_class());
+  return NewImpl<Uint8Array, RawUint8Array>(cls, data, len, space);
+}
+
+
+const char* Uint8Array::ToCString() const {
+  return "_Uint8Array";
+}
+
+
+RawInt16Array* Int16Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int16_array_class());
+  return NewImpl<Int16Array, RawInt16Array>(cls, len, space);
+}
+
+
+RawInt16Array* Int16Array::New(const int16_t* data,
+                               intptr_t len,
+                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int16_array_class());
+  return NewImpl<Int16Array, RawInt16Array>(cls, data, len, space);
+}
+
+
+const char* Int16Array::ToCString() const {
+  return "_Int16Array";
+}
+
+
+RawUint16Array* Uint16Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint16_array_class());
+  return NewImpl<Uint16Array, RawUint16Array>(cls, len, space);
+}
+
+
+RawUint16Array* Uint16Array::New(const uint16_t* data,
+                                 intptr_t len,
+                                 Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint16_array_class());
+  return NewImpl<Uint16Array, RawUint16Array>(cls, data, len, space);
+}
+
+
+const char* Uint16Array::ToCString() const {
+  return "_Uint16Array";
+}
+
+
+RawInt32Array* Int32Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int32_array_class());
+  return NewImpl<Int32Array, RawInt32Array>(cls, len, space);
+}
+
+
+RawInt32Array* Int32Array::New(const int32_t* data,
+                               intptr_t len,
+                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int32_array_class());
+  return NewImpl<Int32Array, RawInt32Array>(cls, data, len, space);
+}
+
+
+const char* Int32Array::ToCString() const {
+  return "_Int32Array";
+}
+
+
+RawUint32Array* Uint32Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint32_array_class());
+  return NewImpl<Uint32Array, RawUint32Array>(cls, len, space);
+}
+
+
+RawUint32Array* Uint32Array::New(const uint32_t* data,
+                                 intptr_t len,
+                                 Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint32_array_class());
+  return NewImpl<Uint32Array, RawUint32Array>(cls, data, len, space);
+}
+
+
+const char* Uint32Array::ToCString() const {
+  return "_Uint32Array";
+}
+
+
+RawInt64Array* Int64Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int64_array_class());
+  return NewImpl<Int64Array, RawInt64Array>(cls, len, space);
+}
+
+
+RawInt64Array* Int64Array::New(const int64_t* data,
+                               intptr_t len,
+                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->int64_array_class());
+  return NewImpl<Int64Array, RawInt64Array>(cls, data, len, space);
+}
+
+
+const char* Int64Array::ToCString() const {
+  return "_Int64Array";
+}
+
+
+RawUint64Array* Uint64Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint64_array_class());
+  return NewImpl<Uint64Array, RawUint64Array>(cls, len, space);
+}
+
+
+RawUint64Array* Uint64Array::New(const uint64_t* data,
+                                 intptr_t len,
+                                 Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->uint64_array_class());
+  return NewImpl<Uint64Array, RawUint64Array>(cls, data, len, space);
+}
+
+
+const char* Uint64Array::ToCString() const {
+  return "_Uint64Array";
+}
+
+
+RawFloat32Array* Float32Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->float32_array_class());
+  return NewImpl<Float32Array, RawFloat32Array>(cls, len, space);
+}
+
+
+RawFloat32Array* Float32Array::New(const float* data,
+                                   intptr_t len,
+                                   Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->float32_array_class());
+  return NewImpl<Float32Array, RawFloat32Array>(cls, data, len, space);
+}
+
+
+const char* Float32Array::ToCString() const {
+  return "_Float32Array";
+}
+
+
+RawFloat64Array* Float64Array::New(intptr_t len, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->float64_array_class());
+  return NewImpl<Float64Array, RawFloat64Array>(cls, len, space);
+}
+
+
+RawFloat64Array* Float64Array::New(const double* data,
+                                   intptr_t len,
+                                   Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->float64_array_class());
+  return NewImpl<Float64Array, RawFloat64Array>(cls, data, len, space);
+}
+
+
+const char* Float64Array::ToCString() const {
+  return "_Float64Array";
+}
+
+
+RawExternalInt8Array* ExternalInt8Array::New(int8_t* data,
                                              intptr_t len,
                                              void* peer,
                                              Dart_PeerFinalizer callback,
                                              Heap::Space space) {
   Isolate* isolate = Isolate::Current();
-  const Class& external_byte_array_class =
-      Class::Handle(isolate->object_store()->external_byte_array_class());
-  ExternalByteArray& result = ExternalByteArray::Handle();
-  ExternalByteArrayData* external_data =
-        new ExternalByteArrayData(data, peer, callback);
-  {
-    RawObject* raw = Object::Allocate(external_byte_array_class,
-                                      ExternalByteArray::InstanceSize(),
-                                      space);
-    NoGCScope no_gc;
-    result ^= raw;
-    result.SetLength(len);
-    result.SetExternalData(external_data);
-  }
-  AddFinalizer(result, external_data, ExternalByteArray::Finalize);
-  return result.raw();
-}
-
-
-const char* ExternalByteArray::ToCString() const {
-  return "_ExternalByteArray";
-}
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_int8_array_class());
+  return NewExternalImpl<ExternalInt8Array, RawExternalInt8Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalInt8Array::ToCString() const {
+  return "_ExternalInt8Array";
+}
+
+
+RawExternalUint8Array* ExternalUint8Array::New(uint8_t* data,
+                                               intptr_t len,
+                                               void* peer,
+                                               Dart_PeerFinalizer callback,
+                                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_uint8_array_class());
+  return NewExternalImpl<ExternalUint8Array, RawExternalUint8Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalUint8Array::ToCString() const {
+  return "_ExternalUint8Array";
+}
+
+
+RawExternalInt16Array* ExternalInt16Array::New(int16_t* data,
+                                               intptr_t len,
+                                               void* peer,
+                                               Dart_PeerFinalizer callback,
+                                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_int16_array_class());
+  return NewExternalImpl<ExternalInt16Array, RawExternalInt16Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalInt16Array::ToCString() const {
+  return "_ExternalInt16Array";
+}
+
+
+RawExternalUint16Array* ExternalUint16Array::New(uint16_t* data,
+                                                 intptr_t len,
+                                                 void* peer,
+                                                 Dart_PeerFinalizer callback,
+                                                 Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_uint16_array_class());
+  return NewExternalImpl<ExternalUint16Array, RawExternalUint16Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalUint16Array::ToCString() const {
+  return "_ExternalUint16Array";
+}
+
+
+RawExternalInt32Array* ExternalInt32Array::New(int32_t* data,
+                                               intptr_t len,
+                                               void* peer,
+                                               Dart_PeerFinalizer callback,
+                                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_int32_array_class());
+  return NewExternalImpl<ExternalInt32Array, RawExternalInt32Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalInt32Array::ToCString() const {
+  return "_ExternalInt32Array";
+}
+
+
+RawExternalUint32Array* ExternalUint32Array::New(uint32_t* data,
+                                                 intptr_t len,
+                                                 void* peer,
+                                                 Dart_PeerFinalizer callback,
+                                                 Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_uint32_array_class());
+  return NewExternalImpl<ExternalUint32Array, RawExternalUint32Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalUint32Array::ToCString() const {
+  return "_ExternalUint32Array";
+}
+
+
+RawExternalInt64Array* ExternalInt64Array::New(int64_t* data,
+                                               intptr_t len,
+                                               void* peer,
+                                               Dart_PeerFinalizer callback,
+                                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_int64_array_class());
+  return NewExternalImpl<ExternalInt64Array, RawExternalInt64Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalInt64Array::ToCString() const {
+  return "_ExternalInt64Array";
+}
+
+
+RawExternalUint64Array* ExternalUint64Array::New(uint64_t* data,
+                                                 intptr_t len,
+                                                 void* peer,
+                                                 Dart_PeerFinalizer callback,
+                                                 Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_uint64_array_class());
+  return NewExternalImpl<ExternalUint64Array, RawExternalUint64Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalUint64Array::ToCString() const {
+  return "_ExternalUint64Array";
+}
+
+
+RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
+                                                   intptr_t len,
+                                                   void* peer,
+                                                   Dart_PeerFinalizer callback,
+                                                   Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_float32_array_class());
+  return NewExternalImpl<ExternalFloat32Array, RawExternalFloat32Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalFloat32Array::ToCString() const {
+  return "_ExternalFloat32Array";
+}
+
+
+RawExternalFloat64Array* ExternalFloat64Array::New(double* data,
+                                                   intptr_t len,
+                                                   void* peer,
+                                                   Dart_PeerFinalizer callback,
+                                                   Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_float64_array_class());
+  return NewExternalImpl<ExternalFloat64Array, RawExternalFloat64Array>(
+      cls, data, len, peer, callback, space);
+}
+
+
+const char* ExternalFloat64Array::ToCString() const {
+  return "_ExternalFloat64Array";
+}
+
 
 
 RawClosure* Closure::New(const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   ASSERT(context.isolate() == isolate);
 
   const Class& cls = Class::Handle(function.signature_class());
   Closure& result = Closure::Handle();
@@ skipping 301 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart