runtime/mirror/array-inl.h - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef ART_RUNTIME_MIRROR_ARRAY_INL_H_
 #define ART_RUNTIME_MIRROR_ARRAY_INL_H_

 #include "array.h"

 #include "class.h"
 #include "gc/heap-inl.h"
 #include "thread.h"
 #include "utils.h"

 namespace art {
 namespace mirror {

 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
 inline size_t Array::SizeOf() {
   // This is safe from overflow because the array was already allocated, so we know it's sane.
   size_t component_size =
       GetClass<kVerifyFlags, kReadBarrierOption>()->template GetComponentSize<kReadBarrierOption>();
   // Don't need to check this since we already check this in GetClass.
   int32_t component_count =
       GetLength<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>();
   size_t header_size = DataOffset(component_size).SizeValue();
   size_t data_size = component_count * component_size;
   return header_size + data_size;
 }

 template<VerifyObjectFlags kVerifyFlags>
 inline bool Array::CheckIsValidIndex(int32_t index) {
   if (UNLIKELY(static_cast<uint32_t>(index) >=
                static_cast<uint32_t>(GetLength<kVerifyFlags>()))) {
     ThrowArrayIndexOutOfBoundsException(index);
     return false;
   }
   return true;
 }

 static inline size_t ComputeArraySize(Thread* self, Class* array_class, int32_t component_count,
                                       size_t component_size)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(array_class != NULL);
   DCHECK_GE(component_count, 0);
   DCHECK(array_class->IsArrayClass());

   size_t header_size = Array::DataOffset(component_size).SizeValue();
   size_t data_size = component_count * component_size;
   size_t size = header_size + data_size;

   // Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
   size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
   if (UNLIKELY(data_size >> component_shift != size_t(component_count) || size < data_size)) {
     self->ThrowOutOfMemoryError(StringPrintf("%s of length %d would overflow",
                                              PrettyDescriptor(array_class).c_str(),
                                              component_count).c_str());
     return 0;  // failure
   }
   return size;
 }

 // Used for setting the array length in the allocation code path to ensure it is guarded by a
 // StoreStore fence.
 class SetLengthVisitor {
  public:
   explicit SetLengthVisitor(int32_t length) : length_(length) {
   }

   void operator()(Object* obj, size_t usable_size) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     UNUSED(usable_size);
     // Avoid AsArray as object is not yet in live bitmap or allocation stack.
     Array* array = down_cast<Array*>(obj);
     // DCHECK(array->IsArrayInstance());
     array->SetLength(length_);
   }

  private:
   const int32_t length_;

   DISALLOW_COPY_AND_ASSIGN(SetLengthVisitor);
 };

 // Similar to SetLengthVisitor, used for setting the array length to fill the usable size of an
 // array.
 class SetLengthToUsableSizeVisitor {
  public:
   SetLengthToUsableSizeVisitor(int32_t min_length, size_t header_size, size_t component_size) :
       minimum_length_(min_length), header_size_(header_size), component_size_(component_size) {
   }

   void operator()(Object* obj, size_t usable_size) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     // Avoid AsArray as object is not yet in live bitmap or allocation stack.
     Array* array = down_cast<Array*>(obj);
     // DCHECK(array->IsArrayInstance());
     int32_t length = (usable_size - header_size_) / component_size_;
     DCHECK_GE(length, minimum_length_);
     byte* old_end = reinterpret_cast<byte*>(array->GetRawData(component_size_, minimum_length_));
     byte* new_end = reinterpret_cast<byte*>(array->GetRawData(component_size_, length));
     // Ensure space beyond original allocation is zeroed.
     memset(old_end, 0, new_end - old_end);
     array->SetLength(length);
   }

  private:
   const int32_t minimum_length_;
   const size_t header_size_;
   const size_t component_size_;

   DISALLOW_COPY_AND_ASSIGN(SetLengthToUsableSizeVisitor);
 };

 template <bool kIsInstrumented>
 inline Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count,
                            size_t component_size, gc::AllocatorType allocator_type,
                            bool fill_usable) {
   DCHECK(allocator_type != gc::kAllocatorTypeLOS);
   size_t size = ComputeArraySize(self, array_class, component_count, component_size);
   if (UNLIKELY(size == 0)) {
     return nullptr;
   }
   gc::Heap* heap = Runtime::Current()->GetHeap();
   Array* result;
   if (!fill_usable) {
     SetLengthVisitor visitor(component_count);
     result = down_cast<Array*>(
         heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, array_class, size,
                                                               allocator_type, visitor));
   } else {
     SetLengthToUsableSizeVisitor visitor(component_count, DataOffset(component_size).SizeValue(),
                                          component_size);
     result = down_cast<Array*>(
         heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, array_class, size,
                                                               allocator_type, visitor));
   }
   if (kIsDebugBuild && result != nullptr && Runtime::Current()->IsStarted()) {
     array_class = result->GetClass();  // In case the array class moved.
     CHECK_EQ(array_class->GetComponentSize(), component_size);
     if (!fill_usable) {
       CHECK_EQ(result->SizeOf(), size);
     } else {
       CHECK_GE(result->SizeOf(), size);
     }
   }
   return result;
 }

 template<class T>
 inline void PrimitiveArray<T>::VisitRoots(RootCallback* callback, void* arg) {
   if (array_class_ != nullptr) {
     callback(reinterpret_cast<mirror::Object**>(&array_class_), arg, 0, kRootStickyClass);
   }
 }

 template<typename T>
 inline PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) {
   DCHECK(array_class_ != NULL);
   Array* raw_array = Array::Alloc<true>(self, array_class_, length, sizeof(T),
                                         Runtime::Current()->GetHeap()->GetCurrentAllocator());
   return down_cast<PrimitiveArray<T>*>(raw_array);
 }

 template<typename T>
 inline T PrimitiveArray<T>::Get(int32_t i) {
   if (!CheckIsValidIndex(i)) {
     DCHECK(Thread::Current()->IsExceptionPending());
     return T(0);
   }
   return GetWithoutChecks(i);
 }

 template<typename T>
 inline void PrimitiveArray<T>::Set(int32_t i, T value) {
   if (Runtime::Current()->IsActiveTransaction()) {
     Set<true>(i, value);
   } else {
     Set<false>(i, value);
   }
 }

 template<typename T>
 template<bool kTransactionActive, bool kCheckTransaction>
 inline void PrimitiveArray<T>::Set(int32_t i, T value) {
   if (CheckIsValidIndex(i)) {
     SetWithoutChecks<kTransactionActive, kCheckTransaction>(i, value);
   } else {
     DCHECK(Thread::Current()->IsExceptionPending());
   }
 }

 template<typename T>
 template<bool kTransactionActive, bool kCheckTransaction>
 inline void PrimitiveArray<T>::SetWithoutChecks(int32_t i, T value) {
   if (kCheckTransaction) {
     DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction());
   }
   if (kTransactionActive) {
     Runtime::Current()->RecordWriteArray(this, i, GetWithoutChecks(i));
   }
   DCHECK(CheckIsValidIndex(i));
   GetData()[i] = value;
 }
 // Backward copy where elements are of aligned appropriately for T. Count is in T sized units.
 // Copies are guaranteed not to tear when the sizeof T is less-than 64bit.
 template<typename T>
 static inline void ArrayBackwardCopy(T* d, const T* s, int32_t count) {
   d += count;
   s += count;
   for (int32_t i = 0; i < count; ++i) {
     d--;
     s--;
     *d = *s;
   }
 }

 // Forward copy where elements are of aligned appropriately for T. Count is in T sized units.
 // Copies are guaranteed not to tear when the sizeof T is less-than 64bit.
 template<typename T>
 static inline void ArrayForwardCopy(T* d, const T* s, int32_t count) {
   for (int32_t i = 0; i < count; ++i) {
     *d = *s;
     d++;
     s++;
   }
 }

 template<class T>
 inline void PrimitiveArray<T>::Memmove(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos,
                                        int32_t count) {
   if (UNLIKELY(count == 0)) {
     return;
   }
   DCHECK_GE(dst_pos, 0);
   DCHECK_GE(src_pos, 0);
   DCHECK_GT(count, 0);
   DCHECK(src != nullptr);
   DCHECK_LT(dst_pos, GetLength());
   DCHECK_LE(dst_pos, GetLength() - count);
   DCHECK_LT(src_pos, src->GetLength());
   DCHECK_LE(src_pos, src->GetLength() - count);

   // Note for non-byte copies we can't rely on standard libc functions like memcpy(3) and memmove(3)
   // in our implementation, because they may copy byte-by-byte.
   if (LIKELY(src != this)) {
     // Memcpy ok for guaranteed non-overlapping distinct arrays.
     Memcpy(dst_pos, src, src_pos, count);
   } else {
     // Handle copies within the same array using the appropriate direction copy.
     void* dst_raw = GetRawData(sizeof(T), dst_pos);
     const void* src_raw = src->GetRawData(sizeof(T), src_pos);
     if (sizeof(T) == sizeof(uint8_t)) {
       uint8_t* d = reinterpret_cast<uint8_t*>(dst_raw);
       const uint8_t* s = reinterpret_cast<const uint8_t*>(src_raw);
       memmove(d, s, count);
     } else {
       const bool copy_forward = (dst_pos < src_pos) || (dst_pos - src_pos >= count);
       if (sizeof(T) == sizeof(uint16_t)) {
         uint16_t* d = reinterpret_cast<uint16_t*>(dst_raw);
         const uint16_t* s = reinterpret_cast<const uint16_t*>(src_raw);
         if (copy_forward) {
           ArrayForwardCopy<uint16_t>(d, s, count);
         } else {
           ArrayBackwardCopy<uint16_t>(d, s, count);
         }
       } else if (sizeof(T) == sizeof(uint32_t)) {
         uint32_t* d = reinterpret_cast<uint32_t*>(dst_raw);
         const uint32_t* s = reinterpret_cast<const uint32_t*>(src_raw);
         if (copy_forward) {
           ArrayForwardCopy<uint32_t>(d, s, count);
         } else {
           ArrayBackwardCopy<uint32_t>(d, s, count);
         }
       } else {
         DCHECK_EQ(sizeof(T), sizeof(uint64_t));
         uint64_t* d = reinterpret_cast<uint64_t*>(dst_raw);
         const uint64_t* s = reinterpret_cast<const uint64_t*>(src_raw);
         if (copy_forward) {
           ArrayForwardCopy<uint64_t>(d, s, count);
         } else {
           ArrayBackwardCopy<uint64_t>(d, s, count);
         }
       }
     }
   }
 }

 template<class T>
 inline void PrimitiveArray<T>::Memcpy(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos,
                                       int32_t count) {
   if (UNLIKELY(count == 0)) {
     return;
   }
   DCHECK_GE(dst_pos, 0);
   DCHECK_GE(src_pos, 0);
   DCHECK_GT(count, 0);
   DCHECK(src != nullptr);
   DCHECK_LT(dst_pos, GetLength());
   DCHECK_LE(dst_pos, GetLength() - count);
   DCHECK_LT(src_pos, src->GetLength());
   DCHECK_LE(src_pos, src->GetLength() - count);

   // Note for non-byte copies we can't rely on standard libc functions like memcpy(3) and memmove(3)
   // in our implementation, because they may copy byte-by-byte.
   void* dst_raw = GetRawData(sizeof(T), dst_pos);
   const void* src_raw = src->GetRawData(sizeof(T), src_pos);
   if (sizeof(T) == sizeof(uint8_t)) {
     memcpy(dst_raw, src_raw, count);
   } else if (sizeof(T) == sizeof(uint16_t)) {
     uint16_t* d = reinterpret_cast<uint16_t*>(dst_raw);
     const uint16_t* s = reinterpret_cast<const uint16_t*>(src_raw);
     ArrayForwardCopy<uint16_t>(d, s, count);
   } else if (sizeof(T) == sizeof(uint32_t)) {
     uint32_t* d = reinterpret_cast<uint32_t*>(dst_raw);
     const uint32_t* s = reinterpret_cast<const uint32_t*>(src_raw);
     ArrayForwardCopy<uint32_t>(d, s, count);
   } else {
     DCHECK_EQ(sizeof(T), sizeof(uint64_t));
     uint64_t* d = reinterpret_cast<uint64_t*>(dst_raw);
     const uint64_t* s = reinterpret_cast<const uint64_t*>(src_raw);
     ArrayForwardCopy<uint64_t>(d, s, count);
   }
 }

 }  // namespace mirror
 }  // namespace art

 #endif  // ART_RUNTIME_MIRROR_ARRAY_INL_H_
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef ART_RUNTIME_MIRROR_ARRAY_INL_H_
	#define ART_RUNTIME_MIRROR_ARRAY_INL_H_

	#include "array.h"

	#include "class.h"
	#include "gc/heap-inl.h"
	#include "thread.h"
	#include "utils.h"

	namespace art {
	namespace mirror {

	template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
	inline size_t Array::SizeOf() {
	// This is safe from overflow because the array was already allocated, so we know it's sane.
	size_t component_size =
	GetClass<kVerifyFlags, kReadBarrierOption>()->template GetComponentSize<kReadBarrierOption>();
	// Don't need to check this since we already check this in GetClass.
	int32_t component_count =
	GetLength<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>();
	size_t header_size = DataOffset(component_size).SizeValue();
	size_t data_size = component_count * component_size;
	return header_size + data_size;
	}

	template<VerifyObjectFlags kVerifyFlags>
	inline bool Array::CheckIsValidIndex(int32_t index) {
	if (UNLIKELY(static_cast<uint32_t>(index) >=
	static_cast<uint32_t>(GetLength<kVerifyFlags>()))) {
	ThrowArrayIndexOutOfBoundsException(index);
	return false;
	}
	return true;
	}

	static inline size_t ComputeArraySize(Thread* self, Class* array_class, int32_t component_count,
	size_t component_size)
	SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
	DCHECK(array_class != NULL);
	DCHECK_GE(component_count, 0);
	DCHECK(array_class->IsArrayClass());

	size_t header_size = Array::DataOffset(component_size).SizeValue();
	size_t data_size = component_count * component_size;
	size_t size = header_size + data_size;

	// Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
	size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
	if (UNLIKELY(data_size >> component_shift != size_t(component_count) \|\| size < data_size)) {
	self->ThrowOutOfMemoryError(StringPrintf("%s of length %d would overflow",
	PrettyDescriptor(array_class).c_str(),
	component_count).c_str());
	return 0; // failure
	}
	return size;
	}

	// Used for setting the array length in the allocation code path to ensure it is guarded by a
	// StoreStore fence.
	class SetLengthVisitor {
	public:
	explicit SetLengthVisitor(int32_t length) : length_(length) {
	}

	void operator()(Object* obj, size_t usable_size) const
	SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
	UNUSED(usable_size);
	// Avoid AsArray as object is not yet in live bitmap or allocation stack.
	Array* array = down_cast<Array*>(obj);
	// DCHECK(array->IsArrayInstance());
	array->SetLength(length_);
	}

	private:
	const int32_t length_;

	DISALLOW_COPY_AND_ASSIGN(SetLengthVisitor);
	};

	// Similar to SetLengthVisitor, used for setting the array length to fill the usable size of an
	// array.
	class SetLengthToUsableSizeVisitor {
	public:
	SetLengthToUsableSizeVisitor(int32_t min_length, size_t header_size, size_t component_size) :
	minimum_length_(min_length), header_size_(header_size), component_size_(component_size) {
	}

	void operator()(Object* obj, size_t usable_size) const
	SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
	// Avoid AsArray as object is not yet in live bitmap or allocation stack.
	Array* array = down_cast<Array*>(obj);
	// DCHECK(array->IsArrayInstance());
	int32_t length = (usable_size - header_size_) / component_size_;
	DCHECK_GE(length, minimum_length_);
	byte* old_end = reinterpret_cast<byte*>(array->GetRawData(component_size_, minimum_length_));
	byte* new_end = reinterpret_cast<byte*>(array->GetRawData(component_size_, length));
	// Ensure space beyond original allocation is zeroed.
	memset(old_end, 0, new_end - old_end);
	array->SetLength(length);
	}

	private:
	const int32_t minimum_length_;
	const size_t header_size_;
	const size_t component_size_;

	DISALLOW_COPY_AND_ASSIGN(SetLengthToUsableSizeVisitor);
	};

	template <bool kIsInstrumented>
	inline Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count,
	size_t component_size, gc::AllocatorType allocator_type,
	bool fill_usable) {
	DCHECK(allocator_type != gc::kAllocatorTypeLOS);
	size_t size = ComputeArraySize(self, array_class, component_count, component_size);
	if (UNLIKELY(size == 0)) {
	return nullptr;
	}
	gc::Heap* heap = Runtime::Current()->GetHeap();
	Array* result;
	if (!fill_usable) {
	SetLengthVisitor visitor(component_count);
	result = down_cast<Array*>(
	heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, array_class, size,
	allocator_type, visitor));
	} else {
	SetLengthToUsableSizeVisitor visitor(component_count, DataOffset(component_size).SizeValue(),
	component_size);
	result = down_cast<Array*>(
	heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, array_class, size,
	allocator_type, visitor));
	}
	if (kIsDebugBuild && result != nullptr && Runtime::Current()->IsStarted()) {
	array_class = result->GetClass(); // In case the array class moved.
	CHECK_EQ(array_class->GetComponentSize(), component_size);
	if (!fill_usable) {
	CHECK_EQ(result->SizeOf(), size);
	} else {
	CHECK_GE(result->SizeOf(), size);
	}
	}
	return result;
	}

	template<class T>
	inline void PrimitiveArray<T>::VisitRoots(RootCallback* callback, void* arg) {
	if (array_class_ != nullptr) {
	callback(reinterpret_cast<mirror::Object**>(&array_class_), arg, 0, kRootStickyClass);
	}
	}

	template<typename T>
	inline PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) {
	DCHECK(array_class_ != NULL);
	Array* raw_array = Array::Alloc<true>(self, array_class_, length, sizeof(T),
	Runtime::Current()->GetHeap()->GetCurrentAllocator());
	return down_cast<PrimitiveArray<T>*>(raw_array);
	}

	template<typename T>
	inline T PrimitiveArray<T>::Get(int32_t i) {
	if (!CheckIsValidIndex(i)) {
	DCHECK(Thread::Current()->IsExceptionPending());
	return T(0);
	}
	return GetWithoutChecks(i);
	}

	template<typename T>
	inline void PrimitiveArray<T>::Set(int32_t i, T value) {
	if (Runtime::Current()->IsActiveTransaction()) {
	Set<true>(i, value);
	} else {
	Set<false>(i, value);
	}
	}

	template<typename T>
	template<bool kTransactionActive, bool kCheckTransaction>
	inline void PrimitiveArray<T>::Set(int32_t i, T value) {
	if (CheckIsValidIndex(i)) {
	SetWithoutChecks<kTransactionActive, kCheckTransaction>(i, value);
	} else {
	DCHECK(Thread::Current()->IsExceptionPending());
	}
	}

	template<typename T>
	template<bool kTransactionActive, bool kCheckTransaction>
	inline void PrimitiveArray<T>::SetWithoutChecks(int32_t i, T value) {
	if (kCheckTransaction) {
	DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction());
	}
	if (kTransactionActive) {
	Runtime::Current()->RecordWriteArray(this, i, GetWithoutChecks(i));
	}
	DCHECK(CheckIsValidIndex(i));
	GetData()[i] = value;
	}
	// Backward copy where elements are of aligned appropriately for T. Count is in T sized units.
	// Copies are guaranteed not to tear when the sizeof T is less-than 64bit.
	template<typename T>
	static inline void ArrayBackwardCopy(T* d, const T* s, int32_t count) {
	d += count;
	s += count;
	for (int32_t i = 0; i < count; ++i) {
	d--;
	s--;
	d = s;
	}
	}

	// Forward copy where elements are of aligned appropriately for T. Count is in T sized units.
	// Copies are guaranteed not to tear when the sizeof T is less-than 64bit.
	template<typename T>
	static inline void ArrayForwardCopy(T* d, const T* s, int32_t count) {
	for (int32_t i = 0; i < count; ++i) {
	d = s;
	d++;
	s++;
	}
	}

	template<class T>
	inline void PrimitiveArray<T>::Memmove(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos,
	int32_t count) {
	if (UNLIKELY(count == 0)) {
	return;
	}
	DCHECK_GE(dst_pos, 0);
	DCHECK_GE(src_pos, 0);
	DCHECK_GT(count, 0);
	DCHECK(src != nullptr);
	DCHECK_LT(dst_pos, GetLength());
	DCHECK_LE(dst_pos, GetLength() - count);
	DCHECK_LT(src_pos, src->GetLength());
	DCHECK_LE(src_pos, src->GetLength() - count);

	// Note for non-byte copies we can't rely on standard libc functions like memcpy(3) and memmove(3)
	// in our implementation, because they may copy byte-by-byte.
	if (LIKELY(src != this)) {
	// Memcpy ok for guaranteed non-overlapping distinct arrays.
	Memcpy(dst_pos, src, src_pos, count);
	} else {
	// Handle copies within the same array using the appropriate direction copy.
	void* dst_raw = GetRawData(sizeof(T), dst_pos);
	const void* src_raw = src->GetRawData(sizeof(T), src_pos);
	if (sizeof(T) == sizeof(uint8_t)) {
	uint8_t* d = reinterpret_cast<uint8_t*>(dst_raw);
	const uint8_t* s = reinterpret_cast<const uint8_t*>(src_raw);
	memmove(d, s, count);
	} else {
	const bool copy_forward = (dst_pos < src_pos) \|\| (dst_pos - src_pos >= count);
	if (sizeof(T) == sizeof(uint16_t)) {
	uint16_t* d = reinterpret_cast<uint16_t*>(dst_raw);
	const uint16_t* s = reinterpret_cast<const uint16_t*>(src_raw);
	if (copy_forward) {
	ArrayForwardCopy<uint16_t>(d, s, count);
	} else {
	ArrayBackwardCopy<uint16_t>(d, s, count);
	}
	} else if (sizeof(T) == sizeof(uint32_t)) {
	uint32_t* d = reinterpret_cast<uint32_t*>(dst_raw);
	const uint32_t* s = reinterpret_cast<const uint32_t*>(src_raw);
	if (copy_forward) {
	ArrayForwardCopy<uint32_t>(d, s, count);
	} else {
	ArrayBackwardCopy<uint32_t>(d, s, count);
	}
	} else {
	DCHECK_EQ(sizeof(T), sizeof(uint64_t));
	uint64_t* d = reinterpret_cast<uint64_t*>(dst_raw);
	const uint64_t* s = reinterpret_cast<const uint64_t*>(src_raw);
	if (copy_forward) {
	ArrayForwardCopy<uint64_t>(d, s, count);
	} else {
	ArrayBackwardCopy<uint64_t>(d, s, count);
	}
	}
	}
	}
	}

	template<class T>
	inline void PrimitiveArray<T>::Memcpy(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos,
	int32_t count) {
	if (UNLIKELY(count == 0)) {
	return;
	}
	DCHECK_GE(dst_pos, 0);
	DCHECK_GE(src_pos, 0);
	DCHECK_GT(count, 0);
	DCHECK(src != nullptr);
	DCHECK_LT(dst_pos, GetLength());
	DCHECK_LE(dst_pos, GetLength() - count);
	DCHECK_LT(src_pos, src->GetLength());
	DCHECK_LE(src_pos, src->GetLength() - count);

	// Note for non-byte copies we can't rely on standard libc functions like memcpy(3) and memmove(3)
	// in our implementation, because they may copy byte-by-byte.
	void* dst_raw = GetRawData(sizeof(T), dst_pos);
	const void* src_raw = src->GetRawData(sizeof(T), src_pos);
	if (sizeof(T) == sizeof(uint8_t)) {
	memcpy(dst_raw, src_raw, count);
	} else if (sizeof(T) == sizeof(uint16_t)) {
	uint16_t* d = reinterpret_cast<uint16_t*>(dst_raw);
	const uint16_t* s = reinterpret_cast<const uint16_t*>(src_raw);
	ArrayForwardCopy<uint16_t>(d, s, count);
	} else if (sizeof(T) == sizeof(uint32_t)) {
	uint32_t* d = reinterpret_cast<uint32_t*>(dst_raw);
	const uint32_t* s = reinterpret_cast<const uint32_t*>(src_raw);
	ArrayForwardCopy<uint32_t>(d, s, count);
	} else {
	DCHECK_EQ(sizeof(T), sizeof(uint64_t));
	uint64_t* d = reinterpret_cast<uint64_t*>(dst_raw);
	const uint64_t* s = reinterpret_cast<const uint64_t*>(src_raw);
	ArrayForwardCopy<uint64_t>(d, s, count);
	}
	}

	} // namespace mirror
	} // namespace art

	#endif // ART_RUNTIME_MIRROR_ARRAY_INL_H_