323 lines
12 KiB
C++
323 lines
12 KiB
C++
/*
|
|
* 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 <android-base/logging.h>
|
|
|
|
#include "base/bit_utils.h"
|
|
#include "base/casts.h"
|
|
#include "class.h"
|
|
#include "obj_ptr-inl.h"
|
|
#include "runtime.h"
|
|
#include "thread-current-inl.h"
|
|
|
|
namespace art {
|
|
namespace mirror {
|
|
|
|
inline uint32_t Array::ClassSize(PointerSize pointer_size) {
|
|
uint32_t vtable_entries = Object::kVTableLength;
|
|
return Class::ComputeClassSize(true, vtable_entries, 0, 0, 0, 0, 0, pointer_size);
|
|
}
|
|
|
|
template<VerifyObjectFlags kVerifyFlags>
|
|
inline size_t Array::SizeOf() {
|
|
// No read barrier is needed for reading a constant primitive field through
|
|
// constant reference field chain. See ReadBarrierOption.
|
|
size_t component_size_shift =
|
|
GetClass<kVerifyFlags, kWithoutReadBarrier>()->GetComponentSizeShift();
|
|
// Don't need to check this since we already check this in GetClass.
|
|
int32_t component_count =
|
|
GetLength<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>();
|
|
// This is safe from overflow because the array was already allocated.
|
|
size_t header_size = DataOffset(1U << component_size_shift).SizeValue();
|
|
size_t data_size = component_count << component_size_shift;
|
|
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;
|
|
}
|
|
|
|
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, VerifyObjectFlags kVerifyFlags>
|
|
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<kVerifyFlags>(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,
|
|
ObjPtr<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,
|
|
ObjPtr<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);
|
|
}
|
|
}
|
|
|
|
template<typename T, PointerSize kPointerSize, VerifyObjectFlags kVerifyFlags>
|
|
inline T PointerArray::GetElementPtrSize(uint32_t idx) {
|
|
if (kPointerSize == PointerSize::k64) {
|
|
DCHECK(IsLongArray<kVerifyFlags>());
|
|
} else {
|
|
DCHECK(IsIntArray<kVerifyFlags>());
|
|
}
|
|
return GetElementPtrSizeUnchecked<T, kPointerSize, kVerifyFlags>(idx);
|
|
}
|
|
|
|
template<typename T, PointerSize kPointerSize, VerifyObjectFlags kVerifyFlags>
|
|
inline T PointerArray::GetElementPtrSizeUnchecked(uint32_t idx) {
|
|
// C style casts here since we sometimes have T be a pointer, or sometimes an integer
|
|
// (for stack traces).
|
|
using ConversionType = typename std::conditional_t<std::is_pointer_v<T>, uintptr_t, T>;
|
|
if (kPointerSize == PointerSize::k64) {
|
|
uint64_t value =
|
|
static_cast<uint64_t>(AsLongArrayUnchecked<kVerifyFlags>()->GetWithoutChecks(idx));
|
|
return (T) dchecked_integral_cast<ConversionType>(value);
|
|
} else {
|
|
uint32_t value =
|
|
static_cast<uint32_t>(AsIntArrayUnchecked<kVerifyFlags>()->GetWithoutChecks(idx));
|
|
return (T) dchecked_integral_cast<ConversionType>(value);
|
|
}
|
|
}
|
|
|
|
template<typename T, VerifyObjectFlags kVerifyFlags>
|
|
inline T PointerArray::GetElementPtrSize(uint32_t idx, PointerSize ptr_size) {
|
|
if (ptr_size == PointerSize::k64) {
|
|
return GetElementPtrSize<T, PointerSize::k64, kVerifyFlags>(idx);
|
|
}
|
|
return GetElementPtrSize<T, PointerSize::k32, kVerifyFlags>(idx);
|
|
}
|
|
|
|
template<bool kTransactionActive, bool kCheckTransaction, bool kUnchecked>
|
|
inline void PointerArray::SetElementPtrSize(uint32_t idx, uint64_t element, PointerSize ptr_size) {
|
|
if (ptr_size == PointerSize::k64) {
|
|
(kUnchecked ? ObjPtr<LongArray>::DownCast(ObjPtr<Object>(this)) : AsLongArray())->
|
|
SetWithoutChecks<kTransactionActive, kCheckTransaction>(idx, element);
|
|
} else {
|
|
uint32_t element32 = dchecked_integral_cast<uint32_t>(element);
|
|
(kUnchecked ? ObjPtr<IntArray>::DownCast(ObjPtr<Object>(this)) : AsIntArray())
|
|
->SetWithoutChecks<kTransactionActive, kCheckTransaction>(idx, element32);
|
|
}
|
|
}
|
|
|
|
template<bool kTransactionActive, bool kCheckTransaction, bool kUnchecked, typename T>
|
|
inline void PointerArray::SetElementPtrSize(uint32_t idx, T* element, PointerSize ptr_size) {
|
|
SetElementPtrSize<kTransactionActive, kCheckTransaction, kUnchecked>(
|
|
idx, reinterpret_cast<uintptr_t>(element), ptr_size);
|
|
}
|
|
|
|
template <VerifyObjectFlags kVerifyFlags, typename Visitor>
|
|
inline void PointerArray::Fixup(ObjPtr<mirror::PointerArray> dest,
|
|
PointerSize pointer_size,
|
|
const Visitor& visitor) {
|
|
for (size_t i = 0, count = GetLength(); i < count; ++i) {
|
|
void* ptr = GetElementPtrSize<void*, kVerifyFlags>(i, pointer_size);
|
|
void* new_ptr = visitor(ptr);
|
|
if (ptr != new_ptr) {
|
|
dest->SetElementPtrSize</*kActiveTransaction=*/ false,
|
|
/*kCheckTransaction=*/ true,
|
|
/*kUnchecked=*/ true>(i, new_ptr, pointer_size);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<bool kUnchecked>
|
|
void PointerArray::Memcpy(int32_t dst_pos,
|
|
ObjPtr<PointerArray> src,
|
|
int32_t src_pos,
|
|
int32_t count,
|
|
PointerSize ptr_size) {
|
|
DCHECK(!Runtime::Current()->IsActiveTransaction());
|
|
DCHECK(!src.IsNull());
|
|
if (ptr_size == PointerSize::k64) {
|
|
ObjPtr<LongArray> l_this = (kUnchecked ? ObjPtr<LongArray>::DownCast(ObjPtr<Object>(this))
|
|
: AsLongArray());
|
|
ObjPtr<LongArray> l_src = (kUnchecked ? ObjPtr<LongArray>::DownCast(ObjPtr<Object>(src))
|
|
: src->AsLongArray());
|
|
l_this->Memcpy(dst_pos, l_src, src_pos, count);
|
|
} else {
|
|
ObjPtr<IntArray> i_this = (kUnchecked ? ObjPtr<IntArray>::DownCast(ObjPtr<Object>(this))
|
|
: AsIntArray());
|
|
ObjPtr<IntArray> i_src = (kUnchecked ? ObjPtr<IntArray>::DownCast(ObjPtr<Object>(src.Ptr()))
|
|
: src->AsIntArray());
|
|
i_this->Memcpy(dst_pos, i_src, src_pos, count);
|
|
}
|
|
}
|
|
|
|
} // namespace mirror
|
|
} // namespace art
|
|
|
|
#endif // ART_RUNTIME_MIRROR_ARRAY_INL_H_
|