You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
381 lines
14 KiB
381 lines
14 KiB
/*
|
|
* 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_OBJECT_ARRAY_INL_H_
|
|
#define ART_RUNTIME_MIRROR_OBJECT_ARRAY_INL_H_
|
|
|
|
#include "base/globals.h"
|
|
#include "object_array.h"
|
|
|
|
#include <string>
|
|
|
|
#include "android-base/stringprintf.h"
|
|
|
|
#include "array-inl.h"
|
|
#include "class.h"
|
|
#include "obj_ptr-inl.h"
|
|
#include "object-inl.h"
|
|
#include "read_barrier-inl.h"
|
|
#include "runtime.h"
|
|
#include "thread-current-inl.h"
|
|
#include "write_barrier-inl.h"
|
|
|
|
namespace art {
|
|
namespace mirror {
|
|
|
|
template<class T> template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
|
|
inline ObjPtr<T> ObjectArray<T>::Get(int32_t i) {
|
|
if (!CheckIsValidIndex<kVerifyFlags>(i)) {
|
|
DCHECK(Thread::Current()->IsExceptionPending());
|
|
return nullptr;
|
|
}
|
|
return GetFieldObject<T, kVerifyFlags, kReadBarrierOption>(OffsetOfElement(i));
|
|
}
|
|
|
|
template<class T> template<VerifyObjectFlags kVerifyFlags>
|
|
inline bool ObjectArray<T>::CheckAssignable(ObjPtr<T> object) {
|
|
if (object != nullptr) {
|
|
ObjPtr<Class> element_class = GetClass<kVerifyFlags>()->GetComponentType();
|
|
if (UNLIKELY(!object->InstanceOf(element_class))) {
|
|
ThrowArrayStoreException(object);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<class T>
|
|
inline void ObjectArray<T>::Set(int32_t i, ObjPtr<T> object) {
|
|
if (Runtime::Current()->IsActiveTransaction()) {
|
|
Set<true>(i, object);
|
|
} else {
|
|
Set<false>(i, object);
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
|
|
inline void ObjectArray<T>::Set(int32_t i, ObjPtr<T> object) {
|
|
if (CheckIsValidIndex(i) && CheckAssignable<kVerifyFlags>(object)) {
|
|
SetFieldObject<kTransactionActive, kCheckTransaction, kVerifyFlags>(OffsetOfElement(i), object);
|
|
} else {
|
|
DCHECK(Thread::Current()->IsExceptionPending());
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
|
|
inline void ObjectArray<T>::SetWithoutChecks(int32_t i, ObjPtr<T> object) {
|
|
DCHECK(CheckIsValidIndex<kVerifyFlags>(i)) << i << " vs " << GetLength();
|
|
DCHECK(CheckAssignable<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>(object));
|
|
SetFieldObject<kTransactionActive, kCheckTransaction, kVerifyFlags>(OffsetOfElement(i), object);
|
|
}
|
|
|
|
template<class T>
|
|
template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
|
|
inline void ObjectArray<T>::SetWithoutChecksAndWriteBarrier(int32_t i, ObjPtr<T> object) {
|
|
DCHECK(CheckIsValidIndex<kVerifyFlags>(i)) << i << " vs " << GetLength();
|
|
// TODO: enable this check. It fails when writing the image in ImageWriter::FixupObjectArray.
|
|
// DCHECK(CheckAssignable(object));
|
|
SetFieldObjectWithoutWriteBarrier<kTransactionActive, kCheckTransaction, kVerifyFlags>(
|
|
OffsetOfElement(i), object);
|
|
}
|
|
|
|
template<class T> template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
|
|
inline ObjPtr<T> ObjectArray<T>::GetWithoutChecks(int32_t i) {
|
|
DCHECK(CheckIsValidIndex(i)) << i << " vs " << GetLength();
|
|
return GetFieldObject<T, kVerifyFlags, kReadBarrierOption>(OffsetOfElement(i));
|
|
}
|
|
|
|
template<class T>
|
|
inline void ObjectArray<T>::AssignableMemmove(int32_t dst_pos,
|
|
ObjPtr<ObjectArray<T>> src,
|
|
int32_t src_pos,
|
|
int32_t count) {
|
|
if (kIsDebugBuild) {
|
|
for (int i = 0; i < count; ++i) {
|
|
// The get will perform the VerifyObject.
|
|
src->GetWithoutChecks(src_pos + i);
|
|
}
|
|
}
|
|
// Perform the memmove using int memmove then perform the write barrier.
|
|
static_assert(sizeof(HeapReference<T>) == sizeof(uint32_t),
|
|
"art::mirror::HeapReference<T> and uint32_t have different sizes.");
|
|
// TODO: Optimize this later?
|
|
// We can't use memmove since it does not handle read barriers and may do by per byte copying.
|
|
// See b/32012820.
|
|
const bool copy_forward = (src != this) || (dst_pos < src_pos) || (dst_pos - src_pos >= count);
|
|
if (copy_forward) {
|
|
// Forward copy.
|
|
bool baker_non_gray_case = false;
|
|
if (kUseReadBarrier && kUseBakerReadBarrier) {
|
|
uintptr_t fake_address_dependency;
|
|
if (!ReadBarrier::IsGray(src.Ptr(), &fake_address_dependency)) {
|
|
baker_non_gray_case = true;
|
|
DCHECK_EQ(fake_address_dependency, 0U);
|
|
src.Assign(reinterpret_cast<ObjectArray<T>*>(
|
|
reinterpret_cast<uintptr_t>(src.Ptr()) | fake_address_dependency));
|
|
for (int i = 0; i < count; ++i) {
|
|
// We can skip the RB here because 'src' isn't gray.
|
|
ObjPtr<T> obj = src->template GetWithoutChecks<kDefaultVerifyFlags, kWithoutReadBarrier>(
|
|
src_pos + i);
|
|
SetWithoutChecksAndWriteBarrier<false>(dst_pos + i, obj);
|
|
}
|
|
}
|
|
}
|
|
if (!baker_non_gray_case) {
|
|
for (int i = 0; i < count; ++i) {
|
|
// We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
|
|
ObjPtr<T> obj = src->GetWithoutChecks(src_pos + i);
|
|
SetWithoutChecksAndWriteBarrier<false>(dst_pos + i, obj);
|
|
}
|
|
}
|
|
} else {
|
|
// Backward copy.
|
|
bool baker_non_gray_case = false;
|
|
if (kUseReadBarrier && kUseBakerReadBarrier) {
|
|
uintptr_t fake_address_dependency;
|
|
if (!ReadBarrier::IsGray(src.Ptr(), &fake_address_dependency)) {
|
|
baker_non_gray_case = true;
|
|
DCHECK_EQ(fake_address_dependency, 0U);
|
|
src.Assign(reinterpret_cast<ObjectArray<T>*>(
|
|
reinterpret_cast<uintptr_t>(src.Ptr()) | fake_address_dependency));
|
|
for (int i = count - 1; i >= 0; --i) {
|
|
// We can skip the RB here because 'src' isn't gray.
|
|
ObjPtr<T> obj = src->template GetWithoutChecks<kDefaultVerifyFlags, kWithoutReadBarrier>(
|
|
src_pos + i);
|
|
SetWithoutChecksAndWriteBarrier<false>(dst_pos + i, obj);
|
|
}
|
|
}
|
|
}
|
|
if (!baker_non_gray_case) {
|
|
for (int i = count - 1; i >= 0; --i) {
|
|
// We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
|
|
ObjPtr<T> obj = src->GetWithoutChecks(src_pos + i);
|
|
SetWithoutChecksAndWriteBarrier<false>(dst_pos + i, obj);
|
|
}
|
|
}
|
|
}
|
|
WriteBarrier::ForArrayWrite(this, dst_pos, count);
|
|
if (kIsDebugBuild) {
|
|
for (int i = 0; i < count; ++i) {
|
|
// The get will perform the VerifyObject.
|
|
GetWithoutChecks(dst_pos + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
inline void ObjectArray<T>::AssignableMemcpy(int32_t dst_pos,
|
|
ObjPtr<ObjectArray<T>> src,
|
|
int32_t src_pos,
|
|
int32_t count) {
|
|
if (kIsDebugBuild) {
|
|
for (int i = 0; i < count; ++i) {
|
|
// The get will perform the VerifyObject.
|
|
src->GetWithoutChecks(src_pos + i);
|
|
}
|
|
}
|
|
// Perform the memmove using int memcpy then perform the write barrier.
|
|
static_assert(sizeof(HeapReference<T>) == sizeof(uint32_t),
|
|
"art::mirror::HeapReference<T> and uint32_t have different sizes.");
|
|
// TODO: Optimize this later?
|
|
// We can't use memmove since it does not handle read barriers and may do by per byte copying.
|
|
// See b/32012820.
|
|
bool baker_non_gray_case = false;
|
|
if (kUseReadBarrier && kUseBakerReadBarrier) {
|
|
uintptr_t fake_address_dependency;
|
|
if (!ReadBarrier::IsGray(src.Ptr(), &fake_address_dependency)) {
|
|
baker_non_gray_case = true;
|
|
DCHECK_EQ(fake_address_dependency, 0U);
|
|
src.Assign(reinterpret_cast<ObjectArray<T>*>(
|
|
reinterpret_cast<uintptr_t>(src.Ptr()) | fake_address_dependency));
|
|
for (int i = 0; i < count; ++i) {
|
|
// We can skip the RB here because 'src' isn't gray.
|
|
ObjPtr<Object> obj =
|
|
src->template GetWithoutChecks<kDefaultVerifyFlags, kWithoutReadBarrier>(src_pos + i);
|
|
SetWithoutChecksAndWriteBarrier<false>(dst_pos + i, obj);
|
|
}
|
|
}
|
|
}
|
|
if (!baker_non_gray_case) {
|
|
for (int i = 0; i < count; ++i) {
|
|
// We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
|
|
ObjPtr<T> obj = src->GetWithoutChecks(src_pos + i);
|
|
SetWithoutChecksAndWriteBarrier<false>(dst_pos + i, obj);
|
|
}
|
|
}
|
|
WriteBarrier::ForArrayWrite(this, dst_pos, count);
|
|
if (kIsDebugBuild) {
|
|
for (int i = 0; i < count; ++i) {
|
|
// The get will perform the VerifyObject.
|
|
GetWithoutChecks(dst_pos + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
template<bool kTransactionActive>
|
|
inline void ObjectArray<T>::AssignableCheckingMemcpy(int32_t dst_pos,
|
|
ObjPtr<ObjectArray<T>> src,
|
|
int32_t src_pos,
|
|
int32_t count,
|
|
bool throw_exception) {
|
|
DCHECK_NE(this, src)
|
|
<< "This case should be handled with memmove that handles overlaps correctly";
|
|
// We want to avoid redundant IsAssignableFrom checks where possible, so we cache a class that
|
|
// we know is assignable to the destination array's component type.
|
|
ObjPtr<Class> dst_class = GetClass()->GetComponentType();
|
|
ObjPtr<Class> lastAssignableElementClass = dst_class;
|
|
|
|
ObjPtr<T> o = nullptr;
|
|
int i = 0;
|
|
bool baker_non_gray_case = false;
|
|
if (kUseReadBarrier && kUseBakerReadBarrier) {
|
|
uintptr_t fake_address_dependency;
|
|
if (!ReadBarrier::IsGray(src.Ptr(), &fake_address_dependency)) {
|
|
baker_non_gray_case = true;
|
|
DCHECK_EQ(fake_address_dependency, 0U);
|
|
src.Assign(reinterpret_cast<ObjectArray<T>*>(
|
|
reinterpret_cast<uintptr_t>(src.Ptr()) | fake_address_dependency));
|
|
for (; i < count; ++i) {
|
|
// The follow get operations force the objects to be verified.
|
|
// We can skip the RB here because 'src' isn't gray.
|
|
o = src->template GetWithoutChecks<kDefaultVerifyFlags, kWithoutReadBarrier>(
|
|
src_pos + i);
|
|
if (o == nullptr) {
|
|
// Null is always assignable.
|
|
SetWithoutChecks<kTransactionActive>(dst_pos + i, nullptr);
|
|
} else {
|
|
// TODO: use the underlying class reference to avoid uncompression when not necessary.
|
|
ObjPtr<Class> o_class = o->GetClass();
|
|
if (LIKELY(lastAssignableElementClass == o_class)) {
|
|
SetWithoutChecks<kTransactionActive>(dst_pos + i, o);
|
|
} else if (LIKELY(dst_class->IsAssignableFrom(o_class))) {
|
|
lastAssignableElementClass = o_class;
|
|
SetWithoutChecks<kTransactionActive>(dst_pos + i, o);
|
|
} else {
|
|
// Can't put this element into the array, break to perform write-barrier and throw
|
|
// exception.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!baker_non_gray_case) {
|
|
for (; i < count; ++i) {
|
|
// The follow get operations force the objects to be verified.
|
|
// We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
|
|
o = src->GetWithoutChecks(src_pos + i);
|
|
if (o == nullptr) {
|
|
// Null is always assignable.
|
|
SetWithoutChecks<kTransactionActive>(dst_pos + i, nullptr);
|
|
} else {
|
|
// TODO: use the underlying class reference to avoid uncompression when not necessary.
|
|
ObjPtr<Class> o_class = o->GetClass();
|
|
if (LIKELY(lastAssignableElementClass == o_class)) {
|
|
SetWithoutChecks<kTransactionActive>(dst_pos + i, o);
|
|
} else if (LIKELY(dst_class->IsAssignableFrom(o_class))) {
|
|
lastAssignableElementClass = o_class;
|
|
SetWithoutChecks<kTransactionActive>(dst_pos + i, o);
|
|
} else {
|
|
// Can't put this element into the array, break to perform write-barrier and throw
|
|
// exception.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
WriteBarrier::ForArrayWrite(this, dst_pos, count);
|
|
if (UNLIKELY(i != count)) {
|
|
std::string actualSrcType(mirror::Object::PrettyTypeOf(o));
|
|
std::string dstType(PrettyTypeOf());
|
|
Thread* self = Thread::Current();
|
|
std::string msg = android::base::StringPrintf(
|
|
"source[%d] of type %s cannot be stored in destination array of type %s",
|
|
src_pos + i,
|
|
actualSrcType.c_str(),
|
|
dstType.c_str());
|
|
if (throw_exception) {
|
|
self->ThrowNewException("Ljava/lang/ArrayStoreException;", msg.c_str());
|
|
} else {
|
|
LOG(FATAL) << msg;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
inline MemberOffset ObjectArray<T>::OffsetOfElement(int32_t i) {
|
|
return MemberOffset(DataOffset(kHeapReferenceSize).Int32Value() + (i * kHeapReferenceSize));
|
|
}
|
|
|
|
template<class T> template<typename Visitor>
|
|
inline void ObjectArray<T>::VisitReferences(const Visitor& visitor) {
|
|
const size_t length = static_cast<size_t>(GetLength());
|
|
for (size_t i = 0; i < length; ++i) {
|
|
visitor(this, OffsetOfElement(i), false);
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
inline ConstObjPtrArrayIter<T> ObjectArray<T>::cbegin() const {
|
|
return ConstObjPtrArrayIter<T>(this, 0);
|
|
}
|
|
template <class T>
|
|
inline ConstObjPtrArrayIter<T> ObjectArray<T>::cend() const {
|
|
return ConstObjPtrArrayIter<T>(this, GetLength());
|
|
}
|
|
template <class T>
|
|
inline ConstHandleArrayIter<T> ObjectArray<T>::cbegin(const Handle<ObjectArray<T>>& h_this) {
|
|
return ConstHandleArrayIter<T>(h_this, 0);
|
|
}
|
|
template <class T>
|
|
inline ConstHandleArrayIter<T> ObjectArray<T>::cend(const Handle<ObjectArray<T>>& h_this) {
|
|
return ConstHandleArrayIter<T>(h_this, h_this->GetLength());
|
|
}
|
|
|
|
template <class T>
|
|
inline ObjPtrArrayIter<T> ObjectArray<T>::begin() {
|
|
return ObjPtrArrayIter<T>(this, 0);
|
|
}
|
|
template <class T>
|
|
inline ObjPtrArrayIter<T> ObjectArray<T>::end() {
|
|
return ObjPtrArrayIter<T>(this, GetLength());
|
|
}
|
|
template <class T>
|
|
inline HandleArrayIter<T> ObjectArray<T>::begin(Handle<ObjectArray<T>>& h_this) {
|
|
return HandleArrayIter<T>(h_this, 0);
|
|
}
|
|
template <class T>
|
|
inline HandleArrayIter<T> ObjectArray<T>::end(Handle<ObjectArray<T>>& h_this) {
|
|
return HandleArrayIter<T>(h_this, h_this->GetLength());
|
|
}
|
|
|
|
template<typename T, typename C>
|
|
inline void ArrayIter<T, C>::CheckIdx() const {
|
|
if (kIsDebugBuild) {
|
|
Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
|
|
}
|
|
DCHECK_LE(0, idx_);
|
|
DCHECK_LE(idx_, array_->GetLength());
|
|
}
|
|
|
|
} // namespace mirror
|
|
} // namespace art
|
|
|
|
#endif // ART_RUNTIME_MIRROR_OBJECT_ARRAY_INL_H_
|