1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ART_RUNTIME_MIRROR_OBJECT_ARRAY_INL_H_
18 #define ART_RUNTIME_MIRROR_OBJECT_ARRAY_INL_H_
19
20 #include "object_array.h"
21
22 #include "gc/heap.h"
23 #include "mirror/art_field.h"
24 #include "mirror/class.h"
25 #include "runtime.h"
26 #include "thread.h"
27
28 namespace art {
29 namespace mirror {
30
31 template<class T>
Alloc(Thread * self,Class * object_array_class,int32_t length)32 inline ObjectArray<T>* ObjectArray<T>::Alloc(Thread* self, Class* object_array_class, int32_t length) {
33 Array* array = Array::Alloc(self, object_array_class, length, sizeof(Object*));
34 if (UNLIKELY(array == NULL)) {
35 return NULL;
36 } else {
37 return array->AsObjectArray<T>();
38 }
39 }
40
41 template<class T>
Get(int32_t i)42 inline T* ObjectArray<T>::Get(int32_t i) const {
43 if (UNLIKELY(!IsValidIndex(i))) {
44 return NULL;
45 }
46 MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
47 return GetFieldObject<T*>(data_offset, false);
48 }
49
50 template<class T>
CheckAssignable(T * object)51 inline bool ObjectArray<T>::CheckAssignable(T* object) {
52 if (object != NULL) {
53 Class* element_class = GetClass()->GetComponentType();
54 if (UNLIKELY(!object->InstanceOf(element_class))) {
55 ThrowArrayStoreException(object);
56 return false;
57 }
58 }
59 return true;
60 }
61
62 template<class T>
Set(int32_t i,T * object)63 inline void ObjectArray<T>::Set(int32_t i, T* object) {
64 if (LIKELY(IsValidIndex(i) && CheckAssignable(object))) {
65 MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
66 SetFieldObject(data_offset, object, false);
67 } else {
68 DCHECK(Thread::Current()->IsExceptionPending());
69 }
70 }
71
72 template<class T>
SetWithoutChecks(int32_t i,T * object)73 inline void ObjectArray<T>::SetWithoutChecks(int32_t i, T* object) {
74 DCHECK(IsValidIndex(i));
75 MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
76 SetFieldObject(data_offset, object, false);
77 }
78
79 template<class T>
SetPtrWithoutChecks(int32_t i,T * object)80 inline void ObjectArray<T>::SetPtrWithoutChecks(int32_t i, T* object) {
81 DCHECK(IsValidIndex(i));
82 MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
83 SetFieldPtr(data_offset, object, false);
84 }
85
86 template<class T>
GetWithoutChecks(int32_t i)87 inline T* ObjectArray<T>::GetWithoutChecks(int32_t i) const {
88 DCHECK(IsValidIndex(i));
89 MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
90 return GetFieldObject<T*>(data_offset, false);
91 }
92
93 template<class T>
Copy(const ObjectArray<T> * src,int src_pos,ObjectArray<T> * dst,int dst_pos,size_t length)94 inline void ObjectArray<T>::Copy(const ObjectArray<T>* src, int src_pos,
95 ObjectArray<T>* dst, int dst_pos,
96 size_t length) {
97 if (src->IsValidIndex(src_pos) &&
98 src->IsValidIndex(src_pos+length-1) &&
99 dst->IsValidIndex(dst_pos) &&
100 dst->IsValidIndex(dst_pos+length-1)) {
101 MemberOffset src_offset(DataOffset(sizeof(Object*)).Int32Value() + src_pos * sizeof(Object*));
102 MemberOffset dst_offset(DataOffset(sizeof(Object*)).Int32Value() + dst_pos * sizeof(Object*));
103 Class* array_class = dst->GetClass();
104 gc::Heap* heap = Runtime::Current()->GetHeap();
105 if (array_class == src->GetClass()) {
106 // No need for array store checks if arrays are of the same type
107 for (size_t i = 0; i < length; i++) {
108 Object* object = src->GetFieldObject<Object*>(src_offset, false);
109 heap->VerifyObject(object);
110 // directly set field, we do a bulk write barrier at the end
111 dst->SetField32(dst_offset, reinterpret_cast<uint32_t>(object), false, true);
112 src_offset = MemberOffset(src_offset.Uint32Value() + sizeof(Object*));
113 dst_offset = MemberOffset(dst_offset.Uint32Value() + sizeof(Object*));
114 }
115 } else {
116 Class* element_class = array_class->GetComponentType();
117 CHECK(!element_class->IsPrimitive());
118 for (size_t i = 0; i < length; i++) {
119 Object* object = src->GetFieldObject<Object*>(src_offset, false);
120 if (object != NULL && !object->InstanceOf(element_class)) {
121 dst->ThrowArrayStoreException(object);
122 return;
123 }
124 heap->VerifyObject(object);
125 // directly set field, we do a bulk write barrier at the end
126 dst->SetField32(dst_offset, reinterpret_cast<uint32_t>(object), false, true);
127 src_offset = MemberOffset(src_offset.Uint32Value() + sizeof(Object*));
128 dst_offset = MemberOffset(dst_offset.Uint32Value() + sizeof(Object*));
129 }
130 }
131 heap->WriteBarrierArray(dst, dst_pos, length);
132 }
133 }
134
135 template<class T>
CopyOf(Thread * self,int32_t new_length)136 inline ObjectArray<T>* ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
137 ObjectArray<T>* new_array = Alloc(self, GetClass(), new_length);
138 if (LIKELY(new_array != NULL)) {
139 Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
140 }
141 return new_array;
142 }
143
144 } // namespace mirror
145 } // namespace art
146
147 #endif // ART_RUNTIME_MIRROR_OBJECT_ARRAY_INL_H_
148