Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1730)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/object.h

Issue 10375007: Revert "Implement {Int,Uint}{8,16,32,64} and Float{32,64} typed arrays." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 8 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/intrinsifier_x64.cc ('k') | runtime/vm/object.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/object.h
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 34c1380f719ba9af8a58725693e406bf06ad4e32..e6b9a8b0dffe5250cafc1de0d68298341de05f5a 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -331,11 +331,6 @@ CLASS_LIST_NO_OBJECT(DEFINE_CLASS_TESTER);
const Script& script,
const Library& lib);
- static void RegisterPrivateClass(const Class& cls,
- const char* cname,
- const Script& script,
- const Library& lib);
-
static RawError* Init(Isolate* isolate);
static void InitFromSnapshot(Isolate* isolate);
static void InitOnce();
@@ -620,9 +615,6 @@ class Class : public Object {
RawArray* fields() const { return raw_ptr()->fields_; }
void SetFields(const Array& value) const;
- // Returns true if non-static fields are defined.
- bool HasInstanceFields() const;
-
RawArray* functions() const { return raw_ptr()->functions_; }
void SetFunctions(const Array& value) const;
@@ -3669,25 +3661,16 @@ class GrowableObjectArray : public Instance {
class ByteArray : public Instance {
public:
- intptr_t Length() const {
- ASSERT(!IsNull());
- return Smi::Value(raw_ptr()->length_);
- }
-
- static intptr_t length_offset() {
- return OFFSET_OF(RawByteArray, length_);
- }
-
- virtual intptr_t ByteLength() const;
+ virtual intptr_t Length() const;
- static void Copy(void* dst,
+ static void Copy(uint8_t* dst,
const ByteArray& src,
intptr_t src_offset,
intptr_t length);
static void Copy(const ByteArray& dst,
intptr_t dst_offset,
- const void* src,
+ const uint8_t* src,
intptr_t length);
static void Copy(const ByteArray& dst,
@@ -3696,1034 +3679,166 @@ class ByteArray : public Instance {
intptr_t src_offset,
intptr_t length);
- protected:
+ private:
virtual uint8_t* ByteAddr(intptr_t byte_offset) const;
- template<typename HandleT, typename RawT>
- static RawT* NewImpl(const Class& cls,
- intptr_t len,
- Heap::Space space);
-
- template<typename HandleT, typename RawT, typename ElementT>
- static RawT* NewImpl(const Class& cls,
- const ElementT* data,
- intptr_t len,
- Heap::Space space);
-
- template<typename HandleT, typename RawT, typename ElementT>
- static RawT* NewExternalImpl(const Class& cls,
- 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);
- }
-
- private:
HEAP_OBJECT_IMPLEMENTATION(ByteArray, Instance);
friend class Class;
};
-class Int8Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length();
- }
-
- int8_t At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
- }
-
- void SetAt(intptr_t index, int8_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
- }
-
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawInt8Array) == OFFSET_OF(RawInt8Array, data_));
- return 0;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- return RoundedAllocationSize(sizeof(RawInt8Array) + len);
- }
-
- static RawInt8Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawInt8Array* New(const int8_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Int8Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Uint8Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length();
- }
-
- uint8_t At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
- }
-
- void SetAt(intptr_t index, uint8_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
- }
-
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawUint8Array) == OFFSET_OF(RawUint8Array, data_));
- return 0;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- return RoundedAllocationSize(sizeof(RawUint8Array) + len);
- }
-
- static RawUint8Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawUint8Array* New(const uint8_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Uint8Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Int16Array : public ByteArray {
+class InternalByteArray : 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()->data_[index];
+ intptr_t Length() const {
+ ASSERT(!IsNull());
+ return Smi::Value(raw_ptr()->length_);
}
- void SetAt(intptr_t index, int16_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
+ static intptr_t length_offset() {
+ return OFFSET_OF(RawInternalByteArray, length_);
}
static intptr_t data_offset() {
return length_offset() + kWordSize;
}
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawInt16Array) == OFFSET_OF(RawInt16Array, data_));
- return 0;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawInt16Array) + data_size);
- }
-
- static RawInt16Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawInt16Array* New(const int16_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 2;
-
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Int16Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Uint16Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length() * kBytesPerElement;
+ template<typename T>
+ T At(intptr_t byte_offset) const {
+ T* addr = Addr<T>(byte_offset);
+ ASSERT(Utils::IsAligned(reinterpret_cast<intptr_t>(addr), sizeof(T)));
+ return *addr;
}
- uint16_t At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
+ template<typename T>
+ void SetAt(intptr_t byte_offset, T value) const {
+ T* addr = Addr<T>(byte_offset);
+ ASSERT(Utils::IsAligned(reinterpret_cast<intptr_t>(addr), sizeof(T)));
+ *addr = value;
}
- void SetAt(intptr_t index, uint16_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
+ template<typename T>
+ T UnalignedAt(intptr_t byte_offset) const {
+ T result;
+ memmove(&result, Addr<T>(byte_offset), sizeof(T));
+ return result;
}
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
+ template<typename T>
+ void SetUnalignedAt(intptr_t byte_offset, T value) const {
+ memmove(Addr<T>(byte_offset), &value, sizeof(T));
}
static intptr_t InstanceSize() {
- ASSERT(sizeof(RawUint16Array) == OFFSET_OF(RawUint16Array, data_));
+ ASSERT(sizeof(RawInternalByteArray) ==
+ OFFSET_OF_RETURNED_VALUE(RawInternalByteArray, data));
return 0;
}
static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawUint16Array) + data_size);
+ return RoundedAllocationSize(sizeof(RawInternalByteArray) + len);
}
- static RawUint16Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawUint16Array* New(const uint16_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
+ static RawInternalByteArray* New(intptr_t len,
+ Heap::Space space = Heap::kNew);
+ static RawInternalByteArray* New(const uint8_t* data,
+ intptr_t len,
+ Heap::Space space = Heap::kNew);
private:
- static const intptr_t kBytesPerElement = 2;
-
uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Uint16Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Int32Array : 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()->data_[index];
- }
-
- void SetAt(intptr_t index, int32_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
- }
-
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawInt32Array) == OFFSET_OF(RawInt32Array, data_));
- return 0;
+ return Addr<uint8_t>(byte_offset);
}
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawInt32Array) + data_size);
+ template<typename T>
+ T* Addr(intptr_t byte_offset) const {
+ intptr_t limit = byte_offset + sizeof(T);
+ // TODO(iposva): Determine if we should throw an exception here.
+ ASSERT((byte_offset >= 0) && (limit <= Length()));
+ uint8_t* addr = &raw_ptr()->data()[byte_offset];
+ return reinterpret_cast<T*>(addr);
}
- static RawInt32Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawInt32Array* New(const int32_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 4;
-
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
+ void SetLength(intptr_t value) const {
+ raw_ptr()->length_ = Smi::New(value);
}
- HEAP_OBJECT_IMPLEMENTATION(Int32Array, ByteArray);
- friend class ByteArray;
+ HEAP_OBJECT_IMPLEMENTATION(InternalByteArray, ByteArray);
friend class Class;
};
-class Uint32Array : public ByteArray {
+class ExternalByteArray : public ByteArray {
public:
- intptr_t ByteLength() const {
- return Length() * kBytesPerElement;
- }
-
- uint32_t At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
- }
-
- void SetAt(intptr_t index, uint32_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
- }
-
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawUint32Array) == OFFSET_OF(RawUint32Array, data_));
- return 0;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawUint32Array) + data_size);
+ intptr_t Length() const {
+ ASSERT(!IsNull());
+ return Smi::Value(raw_ptr()->length_);
}
- static RawUint32Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawUint32Array* New(const uint32_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 4;
-
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
+ void* GetPeer() const {
+ return raw_ptr()->external_data_->peer();
}
- HEAP_OBJECT_IMPLEMENTATION(Uint32Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Int64Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length() * kBytesPerElement;
+ template<typename T>
+ T At(intptr_t byte_offset) const {
+ T* addr = Addr<T>(byte_offset);
+ ASSERT(Utils::IsAligned(reinterpret_cast<intptr_t>(addr), sizeof(T)));
+ return *addr;
}
- int64_t At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
+ template<typename T>
+ void SetAt(intptr_t byte_offset, T value) const {
+ T* addr = Addr<T>(byte_offset);
+ ASSERT(Utils::IsAligned(reinterpret_cast<intptr_t>(addr), sizeof(T)));
+ *addr = value;
}
- void SetAt(intptr_t index, int64_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
+ template<typename T>
+ T UnalignedAt(intptr_t byte_offset) const {
+ T result;
+ memmove(&result, Addr<T>(byte_offset), sizeof(T));
+ return result;
}
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
+ template<typename T>
+ void SetUnalignedAt(intptr_t byte_offset, T value) const {
+ memmove(Addr<T>(byte_offset), &value, sizeof(T));
}
static intptr_t InstanceSize() {
- ASSERT(sizeof(RawInt64Array) == OFFSET_OF(RawInt64Array, data_));
- return 0;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawInt64Array) + data_size);
+ return RoundedAllocationSize(sizeof(RawExternalByteArray));
}
- static RawInt64Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawInt64Array* New(const int64_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
+ static RawExternalByteArray* New(uint8_t* data,
+ intptr_t len,
+ void* peer,
+ Dart_PeerFinalizer callback,
+ Heap::Space space = Heap::kNew);
private:
- static const intptr_t kBytesPerElement = 8;
-
uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Int64Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Uint64Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length() * sizeof(uint64_t);
- }
-
- uint64_t At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
- }
-
- void SetAt(intptr_t index, uint64_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
+ return Addr<uint8_t>(byte_offset);
}
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawUint64Array) == OFFSET_OF(RawUint64Array, data_));
- return 0;
+ template<typename T>
+ T* Addr(intptr_t byte_offset) const {
+ intptr_t limit = byte_offset + sizeof(T);
+ // TODO(iposva): Determine if we should throw an exception here.
+ ASSERT((byte_offset >= 0) && (limit <= Length()));
+ uint8_t* addr = &raw_ptr()->external_data_->data()[byte_offset];
+ return reinterpret_cast<T*>(addr);
}
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawUint64Array) + data_size);
+ void SetLength(intptr_t value) const {
+ raw_ptr()->length_ = Smi::New(value);
}
- static RawUint64Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawUint64Array* New(const uint64_t* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 8;
-
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
+ void SetExternalData(ExternalByteArrayData* data) const {
+ raw_ptr()->external_data_ = data;
}
- HEAP_OBJECT_IMPLEMENTATION(Uint64Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Float32Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length() * kBytesPerElement;
- }
-
- float At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
- }
-
- void SetAt(intptr_t index, float value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
- }
-
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawFloat32Array) == OFFSET_OF(RawFloat32Array, data_));
- return 0;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawFloat32Array) + data_size);
- }
-
- static RawFloat32Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawFloat32Array* New(const float* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 4;
-
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Float32Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-class Float64Array : public ByteArray {
- public:
- intptr_t ByteLength() const {
- return Length() * kBytesPerElement;
- }
-
- double At(intptr_t index) const {
- ASSERT((index >= 0) && (index < Length()));
- return raw_ptr()->data_[index];
- }
-
- void SetAt(intptr_t index, double value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->data_[index] = value;
- }
-
- static intptr_t InstanceSize() {
- ASSERT(sizeof(RawFloat64Array) == OFFSET_OF(RawFloat64Array, data_));
- return 0;
- }
-
- static intptr_t data_offset() {
- return length_offset() + kWordSize;
- }
-
- static intptr_t InstanceSize(intptr_t len) {
- intptr_t data_size = len * kBytesPerElement;
- return RoundedAllocationSize(sizeof(RawFloat64Array) + data_size);
- }
-
- static RawFloat64Array* New(intptr_t len,
- Heap::Space space = Heap::kNew);
- static RawFloat64Array* New(const double* data,
- intptr_t len,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 8;
-
- uint8_t* ByteAddr(intptr_t byte_offset) const {
- ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
- return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(Float64Array, ByteArray);
- friend class ByteArray;
- friend class Class;
-};
-
-
-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];
- }
-
- void SetAt(intptr_t index, int8_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- static intptr_t InstanceSize() {
- return RoundedAllocationSize(sizeof(RawExternalInt8Array));
- }
-
- static RawExternalInt8Array* New(int8_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 1;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<int8_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, uint8_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- static intptr_t InstanceSize() {
- return RoundedAllocationSize(sizeof(RawExternalUint8Array));
- }
-
- static RawExternalUint8Array* New(uint8_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space = Heap::kNew);
-
- private:
- static const intptr_t kBytesPerElement = 1;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<uint8_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- HEAP_OBJECT_IMPLEMENTATION(ExternalUint8Array, ByteArray);
- friend class ByteArray;
- 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];
- }
-
- void SetAt(intptr_t index, int16_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 2;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<int16_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, int16_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 2;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<uint16_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, int32_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 4;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<int32_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, int32_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 4;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<uint32_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, int64_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 8;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<int64_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, int64_t value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 8;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<uint64_t>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, float value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 4;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<float>* data) {
- raw_ptr()->external_data_ = data;
- }
-
- 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];
- }
-
- void SetAt(intptr_t index, double value) const {
- ASSERT((index >= 0) && (index < Length()));
- raw_ptr()->external_data_->data()[index] = value;
- }
-
- void* GetPeer() const {
- return raw_ptr()->external_data_->peer();
- }
-
- 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:
- static const intptr_t kBytesPerElement = 8;
-
- 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());
- return data + byte_offset;
- }
-
- void SetExternalData(ExternalByteArrayData<double>* data) {
- raw_ptr()->external_data_ = data;
- }
+ static void Finalize(Dart_Handle handle, void* peer);
- HEAP_OBJECT_IMPLEMENTATION(ExternalFloat64Array, ByteArray);
- friend class ByteArray;
+ HEAP_OBJECT_IMPLEMENTATION(ExternalByteArray, ByteArray);
friend class Class;
};
« no previous file with comments | « runtime/vm/intrinsifier_x64.cc ('k') | runtime/vm/object.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698