- Change the layout of external typed array objects to avoid the extra indirection when accessing e…

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 255 matching lines @@
   } else if (value == '\v') {
     return 'v';
   } else if (value == '\r') {
     return 'r';
   }
   UNREACHABLE();
   return '\0';
 }
 
 
+static void DeleteWeakPersistentHandle(Dart_Handle handle) {
+  ApiState* state = Isolate::Current()->api_state();
+  ASSERT(state != NULL);
+  FinalizablePersistentHandle* weak_ref =
+      reinterpret_cast<FinalizablePersistentHandle*>(handle);
+  ASSERT(state->IsValidWeakPersistentHandle(handle));
+  state->weak_persistent_handles().FreeHandle(weak_ref);
+}
+
+
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
@@ skipping 4456 matching lines @@
 RawExternalUint8Array* TokenStream::GetStream() const {
   return raw_ptr()->stream_;
 }
 
 
 void TokenStream::SetStream(const ExternalUint8Array& value) const {
   StorePointer(&raw_ptr()->stream_, value.raw());
 }
 
 
-void TokenStream::DataFinalizer(void *peer) {
+void TokenStream::DataFinalizer(Dart_Handle handle, void *peer) {
   ASSERT(peer != NULL);
   ::free(peer);
+  DeleteWeakPersistentHandle(handle);
 }
 
 
 RawString* TokenStream::PrivateKey() const {
   return raw_ptr()->private_key_;
 }
 
 
 void TokenStream::SetPrivateKey(const String& value) const {
   StorePointer(&raw_ptr()->private_key_, value.raw());
@@ skipping 195 matching lines @@
 
 
 RawTokenStream* TokenStream::New(intptr_t len) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TokenStream::New: invalid len %"Pd"\n", len);
   }
   uint8_t* data = reinterpret_cast<uint8_t*>(::malloc(len));
   ASSERT(data != NULL);
   const ExternalUint8Array& stream = ExternalUint8Array::Handle(
-      ExternalUint8Array::New(data, len, data, DataFinalizer, Heap::kOld));
+      ExternalUint8Array::New(data, len, Heap::kOld));
+  stream.AddFinalizer(data, DataFinalizer);
   const TokenStream& result = TokenStream::Handle(TokenStream::New());
   result.SetStream(stream);
   return result.raw();
 }
 
 
 // Helper class for creation of compressed token stream data.
 class CompressedTokenStreamData : public ValueObject {
  public:
   static const intptr_t kIncrementSize = 16 * KB;
@@ skipping 152 matching lines @@
       data.AddSimpleToken(token.kind);
     }
   }
   if (FLAG_compiler_stats) {
     CompilerStats::num_tokens_total += len;
   }
   data.AddSimpleToken(Token::kEOS);  // End of stream.
 
   // Create and setup the token stream object.
   const ExternalUint8Array& stream = ExternalUint8Array::Handle(
-      ExternalUint8Array::New(data.GetStream(),
-                              data.Length(),
-                              data.GetStream(),
-                              DataFinalizer,
-                              Heap::kOld));
+      ExternalUint8Array::New(data.GetStream(), data.Length(), Heap::kOld));
+  stream.AddFinalizer(data.GetStream(), DataFinalizer);
   const TokenStream& result = TokenStream::Handle(New());
   result.SetPrivateKey(private_key);
   {
     NoGCScope no_gc;
     result.SetStream(stream);
     const Array& tokens = Array::Handle(Array::MakeArray(data.TokenObjects()));
     result.SetTokenObjects(tokens);
   }
   return result.raw();
 }
@@ skipping 5837 matching lines @@
   return reinterpret_cast<const char*>(result);
 }
 
 
 void String::ToUTF8(uint8_t* utf8_array, intptr_t array_len) const {
   ASSERT(array_len >= Utf8::Length(*this));
   Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
 }
 
 
-static void AddFinalizer(const Object& referent,
-                         void* peer,
-                         Dart_WeakPersistentHandleFinalizer callback) {
-  ASSERT(callback != NULL);
+static FinalizablePersistentHandle* AddFinalizer(
+    const Object& referent,
+    void* peer,
+    Dart_WeakPersistentHandleFinalizer callback) {
+  ASSERT((callback != NULL && peer != NULL) ||
+         (callback == NULL && peer == NULL));
   ApiState* state = Isolate::Current()->api_state();
   ASSERT(state != NULL);
   FinalizablePersistentHandle* weak_ref =
       state->weak_persistent_handles().AllocateHandle();
   weak_ref->set_raw(referent);
   weak_ref->set_peer(peer);
   weak_ref->set_callback(callback);
+  return weak_ref;
 }
 
 
 RawString* String::MakeExternal(void* array,
                                 intptr_t length,
                                 void* peer,
                                 Dart_PeerFinalizer cback) const {
   NoGCScope no_gc;
   ASSERT(array != NULL);
   intptr_t str_length = this->Length();
@@ skipping 583 matching lines @@
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     SetExternalData(result, external_data);
   }
   AddFinalizer(result, external_data, ExternalOneByteString::Finalize);
   return ExternalOneByteString::raw(result);
 }
 
 
-static void DeleteWeakPersistentHandle(Dart_Handle handle) {
-  ApiState* state = Isolate::Current()->api_state();
-  ASSERT(state != NULL);
-  FinalizablePersistentHandle* weak_ref =
-      reinterpret_cast<FinalizablePersistentHandle*>(handle);
-  ASSERT(state->IsValidWeakPersistentHandle(handle));
-  state->weak_persistent_handles().FreeHandle(weak_ref);
-}
-
-
 void ExternalOneByteString::Finalize(Dart_Handle handle, void* peer) {
   delete reinterpret_cast<ExternalStringData<uint8_t>*>(peer);
   DeleteWeakPersistentHandle(handle);
 }
 
 
 RawExternalTwoByteString* ExternalTwoByteString::New(
     const uint16_t* data,
     intptr_t len,
     void* peer,
@@ skipping 335 matching lines @@
   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(intptr_t class_id,
                                  ElementT* data,
                                  intptr_t len,
-                                 void* peer,
-                                 Dart_PeerFinalizer callback,
                                  Heap::Space space) {
   if (len < 0 || len > HandleT::kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ByteArray::NewExternalImpl: invalid len %"Pd"\n",
            len);
   }
   HandleT& result = HandleT::Handle();
-  ExternalByteArrayData<ElementT>* external_data =
-      new ExternalByteArrayData<ElementT>(data, peer, callback);
   {
     RawObject* raw = Object::Allocate(class_id, HandleT::InstanceSize(), space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
-    result.SetExternalData(external_data);
+    result.SetData(data);
   }
-  AddFinalizer(result, external_data, ExternalByteArrayFinalize<ElementT>);
   return result.raw();
 }
 
 
 intptr_t ByteArray::ByteLength() const {
   // ByteArray is an abstract class.
   UNREACHABLE();
   return 0;
 }
 
 
+FinalizablePersistentHandle* ByteArray::AddFinalizer(
+    void* peer,
+    Dart_WeakPersistentHandleFinalizer callback) const {
+  SetPeer(peer);
+  return dart::AddFinalizer(*this, peer, callback);
+}
+
+
 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();
@@ skipping 275 matching lines @@
 }
 
 
 const char* Float64Array::ToCString() const {
   return "_Float64Array";
 }
 
 
 RawExternalInt8Array* ExternalInt8Array::New(int8_t* data,
                                              intptr_t len,
-                                             void* peer,
-                                             Dart_PeerFinalizer callback,
                                              Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int8_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt8Array, RawExternalInt8Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt8Array,
+                         RawExternalInt8Array>(kClassId, data, len, 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) {
   ASSERT(Isolate::Current()->object_store()->external_uint8_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint8Array, RawExternalUint8Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint8Array,
+                         RawExternalUint8Array>(kClassId, data, len, space);
 }
 
 
 const char* ExternalUint8Array::ToCString() const {
   return "_ExternalUint8Array";
 }
 
 
 RawExternalUint8ClampedArray* ExternalUint8ClampedArray::New(
     uint8_t* data,
     intptr_t len,
-    void* peer,
-    Dart_PeerFinalizer callback,
     Heap::Space space) {
   ASSERT(Isolate::Current()->
-             object_store()->external_uint8_clamped_array_class() !=
+         object_store()->external_uint8_clamped_array_class() !=
          Class::null());
   return NewExternalImpl<ExternalUint8ClampedArray,
-      RawExternalUint8ClampedArray>(kClassId, data, len, peer, callback, space);
+                         RawExternalUint8ClampedArray>(kClassId, data,
+                                                       len, space);
 }
 
 
 const char* ExternalUint8ClampedArray::ToCString() const {
   return "_ExternalUint8ClampedArray";
 }
 
 
 RawExternalInt16Array* ExternalInt16Array::New(int16_t* data,
                                                intptr_t len,
-                                               void* peer,
-                                               Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int16_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt16Array, RawExternalInt16Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt16Array,
+                         RawExternalInt16Array>(kClassId, data, len, 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) {
   ASSERT(Isolate::Current()->object_store()->external_uint16_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint16Array, RawExternalUint16Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint16Array,
+                         RawExternalUint16Array>(kClassId, data, len, 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) {
   ASSERT(Isolate::Current()->object_store()->external_int32_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt32Array, RawExternalInt32Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt32Array,
+                         RawExternalInt32Array>(kClassId, data, len, 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) {
   ASSERT(Isolate::Current()->object_store()->external_uint32_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint32Array, RawExternalUint32Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint32Array,
+                         RawExternalUint32Array>(kClassId, data, len, 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) {
   ASSERT(Isolate::Current()->object_store()->external_int64_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalInt64Array, RawExternalInt64Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalInt64Array,
+                         RawExternalInt64Array>(kClassId, data, len, 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) {
   ASSERT(Isolate::Current()->object_store()->external_uint64_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalUint64Array, RawExternalUint64Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalUint64Array,
+                         RawExternalUint64Array>(kClassId, data, len, space);
 }
 
 
 const char* ExternalUint64Array::ToCString() const {
   return "_ExternalUint64Array";
 }
 
 
 RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
                                                    intptr_t len,
-                                                   void* peer,
-                                                   Dart_PeerFinalizer callback,
                                                    Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_float32_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalFloat32Array, RawExternalFloat32Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalFloat32Array,
+                         RawExternalFloat32Array>(kClassId, data, len, space);
 }
 
 
 const char* ExternalFloat32Array::ToCString() const {
   return "_ExternalFloat32Array";
 }
 
 
 RawExternalFloat64Array* ExternalFloat64Array::New(double* data,
                                                    intptr_t len,
-                                                   void* peer,
-                                                   Dart_PeerFinalizer callback,
                                                    Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_float64_array_class() !=
          Class::null());
-  return NewExternalImpl<ExternalFloat64Array, RawExternalFloat64Array>(
-      kClassId, data, len, peer, callback, space);
+  return NewExternalImpl<ExternalFloat64Array,
+                         RawExternalFloat64Array>(kClassId, data, len, space);
 }
 
 
 const char* ExternalFloat64Array::ToCString() const {
   return "_ExternalFloat64Array";
 }
 
 
 const char* Closure::ToCString(const Instance& closure) {
   const Function& fun = Function::Handle(Closure::function(closure));
@@ skipping 296 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart