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 <string>
21 
22 #include "object_array.h"
23 
24 #include "array-inl.h"
25 #include "base/stringprintf.h"
26 #include "gc/heap.h"
27 #include "mirror/class.h"
28 #include "runtime.h"
29 #include "handle_scope-inl.h"
30 #include "thread.h"
31 #include "utils.h"
32 
33 namespace art {
34 namespace mirror {
35 
36 template<class T>
Alloc(Thread * self,Class * object_array_class,int32_t length,gc::AllocatorType allocator_type)37 inline ObjectArray<T>* ObjectArray<T>::Alloc(Thread* self, Class* object_array_class,
38                                              int32_t length, gc::AllocatorType allocator_type) {
39   Array* array = Array::Alloc<true>(self, object_array_class, length,
40                                     ComponentSizeShiftWidth(sizeof(HeapReference<Object>)),
41                                     allocator_type);
42   if (UNLIKELY(array == nullptr)) {
43     return nullptr;
44   } else {
45     DCHECK_EQ(array->GetClass()->GetComponentSizeShift(),
46               ComponentSizeShiftWidth(sizeof(HeapReference<Object>)));
47     return array->AsObjectArray<T>();
48   }
49 }
50 
51 template<class T>
Alloc(Thread * self,Class * object_array_class,int32_t length)52 inline ObjectArray<T>* ObjectArray<T>::Alloc(Thread* self, Class* object_array_class,
53                                              int32_t length) {
54   return Alloc(self, object_array_class, length,
55                Runtime::Current()->GetHeap()->GetCurrentAllocator());
56 }
57 
58 template<class T>
Get(int32_t i)59 inline T* ObjectArray<T>::Get(int32_t i) {
60   if (!CheckIsValidIndex(i)) {
61     DCHECK(Thread::Current()->IsExceptionPending());
62     return nullptr;
63   }
64   return GetFieldObject<T>(OffsetOfElement(i));
65 }
66 
67 template<class T> template<VerifyObjectFlags kVerifyFlags>
CheckAssignable(T * object)68 inline bool ObjectArray<T>::CheckAssignable(T* object) {
69   if (object != nullptr) {
70     Class* element_class = GetClass<kVerifyFlags>()->GetComponentType();
71     if (UNLIKELY(!object->InstanceOf(element_class))) {
72       ThrowArrayStoreException(object);
73       return false;
74     }
75   }
76   return true;
77 }
78 
79 template<class T>
Set(int32_t i,T * object)80 inline void ObjectArray<T>::Set(int32_t i, T* object) {
81   if (Runtime::Current()->IsActiveTransaction()) {
82     Set<true>(i, object);
83   } else {
84     Set<false>(i, object);
85   }
86 }
87 
88 template<class T>
89 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
Set(int32_t i,T * object)90 inline void ObjectArray<T>::Set(int32_t i, T* object) {
91   if (CheckIsValidIndex(i) && CheckAssignable<kVerifyFlags>(object)) {
92     SetFieldObject<kTransactionActive, kCheckTransaction, kVerifyFlags>(OffsetOfElement(i), object);
93   } else {
94     DCHECK(Thread::Current()->IsExceptionPending());
95   }
96 }
97 
98 template<class T>
99 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
SetWithoutChecks(int32_t i,T * object)100 inline void ObjectArray<T>::SetWithoutChecks(int32_t i, T* object) {
101   DCHECK(CheckIsValidIndex<kVerifyFlags>(i));
102   DCHECK(CheckAssignable<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>(object));
103   SetFieldObject<kTransactionActive, kCheckTransaction, kVerifyFlags>(OffsetOfElement(i), object);
104 }
105 
106 template<class T>
107 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
SetWithoutChecksAndWriteBarrier(int32_t i,T * object)108 inline void ObjectArray<T>::SetWithoutChecksAndWriteBarrier(int32_t i, T* object) {
109   DCHECK(CheckIsValidIndex<kVerifyFlags>(i));
110   // TODO:  enable this check. It fails when writing the image in ImageWriter::FixupObjectArray.
111   // DCHECK(CheckAssignable(object));
112   SetFieldObjectWithoutWriteBarrier<kTransactionActive, kCheckTransaction, kVerifyFlags>(
113       OffsetOfElement(i), object);
114 }
115 
116 template<class T>
GetWithoutChecks(int32_t i)117 inline T* ObjectArray<T>::GetWithoutChecks(int32_t i) {
118   DCHECK(CheckIsValidIndex(i));
119   return GetFieldObject<T>(OffsetOfElement(i));
120 }
121 
122 template<class T>
AssignableMemmove(int32_t dst_pos,ObjectArray<T> * src,int32_t src_pos,int32_t count)123 inline void ObjectArray<T>::AssignableMemmove(int32_t dst_pos, ObjectArray<T>* src,
124                                               int32_t src_pos, int32_t count) {
125   if (kIsDebugBuild) {
126     for (int i = 0; i < count; ++i) {
127       // The get will perform the VerifyObject.
128       src->GetWithoutChecks(src_pos + i);
129     }
130   }
131   // Perform the memmove using int memmove then perform the write barrier.
132   CHECK_EQ(sizeof(HeapReference<T>), sizeof(uint32_t));
133   IntArray* dstAsIntArray = reinterpret_cast<IntArray*>(this);
134   IntArray* srcAsIntArray = reinterpret_cast<IntArray*>(src);
135   if (kUseReadBarrier) {
136     // TODO: Optimize this later?
137     const bool copy_forward = (src != this) || (dst_pos < src_pos) || (dst_pos - src_pos >= count);
138     if (copy_forward) {
139       // Forward copy.
140       for (int i = 0; i < count; ++i) {
141         // We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
142         Object* obj = src->GetWithoutChecks(src_pos + i);
143         SetWithoutChecks<false>(dst_pos + i, obj);
144       }
145     } else {
146       // Backward copy.
147       for (int i = count - 1; i >= 0; --i) {
148         // We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
149         Object* obj = src->GetWithoutChecks(src_pos + i);
150         SetWithoutChecks<false>(dst_pos + i, obj);
151       }
152     }
153   } else {
154     dstAsIntArray->Memmove(dst_pos, srcAsIntArray, src_pos, count);
155   }
156   Runtime::Current()->GetHeap()->WriteBarrierArray(this, dst_pos, count);
157   if (kIsDebugBuild) {
158     for (int i = 0; i < count; ++i) {
159       // The get will perform the VerifyObject.
160       GetWithoutChecks(dst_pos + i);
161     }
162   }
163 }
164 
165 template<class T>
AssignableMemcpy(int32_t dst_pos,ObjectArray<T> * src,int32_t src_pos,int32_t count)166 inline void ObjectArray<T>::AssignableMemcpy(int32_t dst_pos, ObjectArray<T>* src,
167                                              int32_t src_pos, int32_t count) {
168   if (kIsDebugBuild) {
169     for (int i = 0; i < count; ++i) {
170       // The get will perform the VerifyObject.
171       src->GetWithoutChecks(src_pos + i);
172     }
173   }
174   // Perform the memmove using int memcpy then perform the write barrier.
175   CHECK_EQ(sizeof(HeapReference<T>), sizeof(uint32_t));
176   IntArray* dstAsIntArray = reinterpret_cast<IntArray*>(this);
177   IntArray* srcAsIntArray = reinterpret_cast<IntArray*>(src);
178   if (kUseReadBarrier) {
179     // TODO: Optimize this later?
180     for (int i = 0; i < count; ++i) {
181       // We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
182       T* obj = src->GetWithoutChecks(src_pos + i);
183       SetWithoutChecks<false>(dst_pos + i, obj);
184     }
185   } else {
186     dstAsIntArray->Memcpy(dst_pos, srcAsIntArray, src_pos, count);
187   }
188   Runtime::Current()->GetHeap()->WriteBarrierArray(this, dst_pos, count);
189   if (kIsDebugBuild) {
190     for (int i = 0; i < count; ++i) {
191       // The get will perform the VerifyObject.
192       GetWithoutChecks(dst_pos + i);
193     }
194   }
195 }
196 
197 template<class T>
AssignableCheckingMemcpy(int32_t dst_pos,ObjectArray<T> * src,int32_t src_pos,int32_t count,bool throw_exception)198 inline void ObjectArray<T>::AssignableCheckingMemcpy(int32_t dst_pos, ObjectArray<T>* src,
199                                                      int32_t src_pos, int32_t count,
200                                                      bool throw_exception) {
201   DCHECK_NE(this, src)
202       << "This case should be handled with memmove that handles overlaps correctly";
203   // We want to avoid redundant IsAssignableFrom checks where possible, so we cache a class that
204   // we know is assignable to the destination array's component type.
205   Class* dst_class = GetClass()->GetComponentType();
206   Class* lastAssignableElementClass = dst_class;
207 
208   Object* o = nullptr;
209   int i = 0;
210   for (; i < count; ++i) {
211     // The follow get operations force the objects to be verified.
212     // We need a RB here. ObjectArray::GetWithoutChecks() contains a RB.
213     o = src->GetWithoutChecks(src_pos + i);
214     if (o == nullptr) {
215       // Null is always assignable.
216       SetWithoutChecks<false>(dst_pos + i, nullptr);
217     } else {
218       // TODO: use the underlying class reference to avoid uncompression when not necessary.
219       Class* o_class = o->GetClass();
220       if (LIKELY(lastAssignableElementClass == o_class)) {
221         SetWithoutChecks<false>(dst_pos + i, o);
222       } else if (LIKELY(dst_class->IsAssignableFrom(o_class))) {
223         lastAssignableElementClass = o_class;
224         SetWithoutChecks<false>(dst_pos + i, o);
225       } else {
226         // Can't put this element into the array, break to perform write-barrier and throw
227         // exception.
228         break;
229       }
230     }
231   }
232   Runtime::Current()->GetHeap()->WriteBarrierArray(this, dst_pos, count);
233   if (UNLIKELY(i != count)) {
234     std::string actualSrcType(PrettyTypeOf(o));
235     std::string dstType(PrettyTypeOf(this));
236     Thread* self = Thread::Current();
237     if (throw_exception) {
238       self->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
239                                "source[%d] of type %s cannot be stored in destination array of type %s",
240                                src_pos + i, actualSrcType.c_str(), dstType.c_str());
241     } else {
242       LOG(FATAL) << StringPrintf("source[%d] of type %s cannot be stored in destination array of type %s",
243                                  src_pos + i, actualSrcType.c_str(), dstType.c_str());
244     }
245   }
246 }
247 
248 template<class T>
CopyOf(Thread * self,int32_t new_length)249 inline ObjectArray<T>* ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
250   DCHECK_GE(new_length, 0);
251   // We may get copied by a compacting GC.
252   StackHandleScope<1> hs(self);
253   Handle<ObjectArray<T>> h_this(hs.NewHandle(this));
254   gc::Heap* heap = Runtime::Current()->GetHeap();
255   gc::AllocatorType allocator_type = heap->IsMovableObject(this) ? heap->GetCurrentAllocator() :
256       heap->GetCurrentNonMovingAllocator();
257   ObjectArray<T>* new_array = Alloc(self, GetClass(), new_length, allocator_type);
258   if (LIKELY(new_array != nullptr)) {
259     new_array->AssignableMemcpy(0, h_this.Get(), 0, std::min(h_this->GetLength(), new_length));
260   }
261   return new_array;
262 }
263 
264 template<class T>
OffsetOfElement(int32_t i)265 inline MemberOffset ObjectArray<T>::OffsetOfElement(int32_t i) {
266   return MemberOffset(DataOffset(sizeof(HeapReference<Object>)).Int32Value() +
267                       (i * sizeof(HeapReference<Object>)));
268 }
269 
270 template<class T> template<const bool kVisitClass, typename Visitor>
VisitReferences(const Visitor & visitor)271 void ObjectArray<T>::VisitReferences(const Visitor& visitor) {
272   if (kVisitClass) {
273     visitor(this, ClassOffset(), false);
274   }
275   const size_t length = static_cast<size_t>(GetLength());
276   for (size_t i = 0; i < length; ++i) {
277     visitor(this, OffsetOfElement(i), false);
278   }
279 }
280 
281 }  // namespace mirror
282 }  // namespace art
283 
284 #endif  // ART_RUNTIME_MIRROR_OBJECT_ARRAY_INL_H_
285