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

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 12 matching lines @@
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class Assembler;
 class Closure;
 class Code;
 class DeoptInstr;
+class FinalizablePersistentHandle;
 class LocalScope;
 class Symbols;
 
 #if defined(DEBUG)
 #define CHECK_HANDLE() CheckHandle();
 #else
 #define CHECK_HANDLE()
 #endif
 
 #define BASE_OBJECT_IMPLEMENTATION(object, super)                              \
@@ skipping 1845 matching lines @@
     Object& obj_;
     intptr_t cur_token_pos_;
     Token::Kind cur_token_kind_;
     intptr_t cur_token_obj_index_;
   };
 
  private:
   void SetPrivateKey(const String& value) const;
 
   static RawTokenStream* New();
-  static void DataFinalizer(void *peer);
+  static void DataFinalizer(Dart_Handle handle, void *peer);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
   friend class Class;
 };
 
 
 class Script : public Object {
  public:
   RawString* url() const { return raw_ptr()->url_; }
   bool HasSource() const;
@@ skipping 2834 matching lines @@
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawByteArray, length_);
   }
 
   virtual intptr_t ByteLength() const;
 
+  virtual void* GetPeer() const { return NULL; }
+
+  FinalizablePersistentHandle* AddFinalizer(
+      void* peer, Dart_WeakPersistentHandleFinalizer callback) const;
+
   static void Copy(void* dst,
                    const ByteArray& src,
                    intptr_t src_offset,
                    intptr_t length);
 
   static void Copy(const ByteArray& dst,
                    intptr_t dst_offset,
                    const void* src,
                    intptr_t length);
 
   static void Copy(const ByteArray& dst,
                    intptr_t dst_offset,
                    const ByteArray& src,
                    intptr_t src_offset,
                    intptr_t length);
 
  protected:
   virtual uint8_t* ByteAddr(intptr_t byte_offset) const;
+  virtual void SetPeer(void* peer) const { }
 
   template<typename HandleT, typename RawT>
   static RawT* NewImpl(intptr_t class_id,
                        intptr_t len,
                        Heap::Space space);
 
   template<typename HandleT, typename RawT, typename ElementT>
   static RawT* NewImpl(intptr_t class_id,
                        const ElementT* data,
                        intptr_t len,
                        Heap::Space space);
 
   template<typename HandleT, typename RawT, typename ElementT>
   static RawT* NewExternalImpl(intptr_t class_id,
                                ElementT* data,
                                intptr_t len,
-                               void* peer,
-                               Dart_PeerFinalizer callback,
                                Heap::Space space);
 
   template<typename HandleT, typename RawT, typename ElementT>
   static RawT* ReadFromImpl(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind);
 
   void SetLength(intptr_t value) const {
     raw_ptr()->length_ = Smi::New(value);
@@ skipping 579 matching lines @@
 
 
 class ExternalInt8Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int8_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int8_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  int8_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 1;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Int8Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalInt8Array));
   }
 
+  static intptr_t data_offset() {
+    return OFFSET_OF(RawExternalInt8Array, data_);
+  }
+
   static RawExternalInt8Array* New(int8_t* data,
                                    intptr_t len,
-                                   void* peer,
-                                   Dart_PeerFinalizer callback,
                                    Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<int8_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(int8_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint8Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   uint8_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, uint8_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  uint8_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 1;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Uint8Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalUint8Array));
   }
 
-  static intptr_t external_data_offset() {
-    return OFFSET_OF(RawExternalUint8Array, external_data_);
+  static intptr_t data_offset() {
+    return OFFSET_OF(RawExternalUint8Array, data_);
   }
 
   static RawExternalUint8Array* New(uint8_t* data,
                                     intptr_t len,
-                                    void* peer,
-                                    Dart_PeerFinalizer callback,
                                     Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+        reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<uint8_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(uint8_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   HEAP_OBJECT_IMPLEMENTATION(ExternalUint8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
   friend class TokenStream;
 };
 
 
 class ExternalUint8ClampedArray : public ExternalUint8Array {
  public:
   static RawExternalUint8ClampedArray* New(uint8_t* data,
                                            intptr_t len,
-                                           void* peer,
-                                           Dart_PeerFinalizer callback,
                                            Heap::Space space = Heap::kNew);
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint8ClampedArray,
                                    ExternalUint8Array);
   friend class Class;
 };
 
 
 class ExternalInt16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int16_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int16_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  int16_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 2;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Int16Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalInt16Array));
   }
 
   static RawExternalInt16Array* New(int16_t* data,
                                     intptr_t len,
-                                    void* peer,
-                                    Dart_PeerFinalizer callback,
                                     Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<int16_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(int16_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt16Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int16_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int16_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  uint16_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 2;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Uint16Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalUint16Array));
   }
 
   static RawExternalUint16Array* New(uint16_t* data,
                                      intptr_t len,
-                                     void* peer,
-                                     Dart_PeerFinalizer callback,
                                      Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<uint16_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(uint16_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint16Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalInt32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int32_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int32_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  int32_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 4;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Int32Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalInt32Array));
   }
 
   static RawExternalInt32Array* New(int32_t* data,
                                     intptr_t len,
-                                    void* peer,
-                                    Dart_PeerFinalizer callback,
                                     Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<int32_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(int32_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int32_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int32_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  uint32_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 4;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Uint32Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalUint32Array));
   }
 
   static RawExternalUint32Array* New(uint32_t* data,
                                      intptr_t len,
-                                     void* peer,
-                                     Dart_PeerFinalizer callback,
                                      Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<uint32_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(uint32_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalInt64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int64_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int64_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  int64_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 8;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Int64Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalInt64Array));
   }
 
   static RawExternalInt64Array* New(int64_t* data,
                                     intptr_t len,
-                                    void* peer,
-                                    Dart_PeerFinalizer callback,
                                     Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<int64_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(int64_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalInt64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalUint64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int64_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, int64_t value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  uint64_t* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 8;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Uint64Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalUint64Array));
   }
 
   static RawExternalUint64Array* New(uint64_t* data,
                                      intptr_t len,
-                                     void* peer,
-                                     Dart_PeerFinalizer callback,
                                      Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<uint64_t>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(uint64_t* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalUint64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalFloat32Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   float At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, float value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  float* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 4;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Float32Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalFloat32Array));
   }
 
   static RawExternalFloat32Array* New(float* data,
                                       intptr_t len,
-                                      void* peer,
-                                      Dart_PeerFinalizer callback,
                                       Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<float>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(float* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalFloat32Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 class ExternalFloat64Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   double At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
-    return raw_ptr()->external_data_->data()[index];
+    return raw_ptr()->data_[index];
   }
 
   void SetAt(intptr_t index, double value) const {
     ASSERT((index >= 0) && (index < Length()));
-    raw_ptr()->external_data_->data()[index] = value;
+    raw_ptr()->data_[index] = value;
   }
 
-  void* GetData() const {
-    return raw_ptr()->external_data_->data();
+  double* GetData() const {
+    return raw_ptr()->data_;
   }
 
   void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+    return raw_ptr()->peer_;
   }
 
   static const intptr_t kBytesPerElement = 8;
 
   // Since external arrays may be serialized to non-external ones,
   // enforce the same maximum element count.
   static const intptr_t kMaxElements = Float64Array::kMaxElements;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalFloat64Array));
   }
 
   static RawExternalFloat64Array* New(double* data,
                                       intptr_t len,
-                                      void* peer,
-                                      Dart_PeerFinalizer callback,
                                       Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
-    uint8_t* data =
-        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    uint8_t* data = reinterpret_cast<uint8_t*>(raw_ptr()->data_);
     return data + byte_offset;
   }
 
-  void SetExternalData(ExternalByteArrayData<double>* data) {
-    raw_ptr()->external_data_ = data;
+  void SetData(double* data) const {
+    raw_ptr()->data_ = data;
+  }
+
+  void SetPeer(void* peer) const {
+    raw_ptr()->peer_ = peer;
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalFloat64Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
 // DartFunction represents the abstract Dart class 'Function'.
 class DartFunction : public Instance {
@@ skipping 340 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_