blob: 43bdf49c78e5a1260ac105fa121764799045bc36 [file] [log] [blame]
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001/*
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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_MIRROR_ARRAY_INL_H_
18#define ART_RUNTIME_MIRROR_ARRAY_INL_H_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080019
20#include "array.h"
21
22#include "class.h"
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070023#include "gc/heap-inl.h"
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070024#include "thread.h"
25#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026
27namespace art {
28namespace mirror {
29
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -070030template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
Ian Rogersef7d42f2014-01-06 12:55:46 -080031inline size_t Array::SizeOf() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080032 // This is safe from overflow because the array was already allocated, so we know it's sane.
Hiroshi Yamauchi9103c862014-04-22 13:51:07 -070033 size_t component_size =
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -070034 GetClass<kVerifyFlags, kReadBarrierOption>()->template GetComponentSize<kReadBarrierOption>();
Mathieu Chartier4e305412014-02-19 10:54:44 -080035 // Don't need to check this since we already check this in GetClass.
36 int32_t component_count =
37 GetLength<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>();
Hiroshi Yamauchiaa866f52014-03-21 16:18:30 -070038 size_t header_size = DataOffset(component_size).SizeValue();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080039 size_t data_size = component_count * component_size;
40 return header_size + data_size;
41}
42
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070043template<VerifyObjectFlags kVerifyFlags>
44inline bool Array::CheckIsValidIndex(int32_t index) {
45 if (UNLIKELY(static_cast<uint32_t>(index) >=
46 static_cast<uint32_t>(GetLength<kVerifyFlags>()))) {
47 ThrowArrayIndexOutOfBoundsException(index);
48 return false;
49 }
50 return true;
51}
52
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070053static inline size_t ComputeArraySize(Thread* self, Class* array_class, int32_t component_count,
54 size_t component_size)
55 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070056 DCHECK(array_class != NULL);
57 DCHECK_GE(component_count, 0);
58 DCHECK(array_class->IsArrayClass());
59
Hiroshi Yamauchiaa866f52014-03-21 16:18:30 -070060 size_t header_size = Array::DataOffset(component_size).SizeValue();
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070061 size_t data_size = component_count * component_size;
62 size_t size = header_size + data_size;
63
64 // Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
65 size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
66 if (UNLIKELY(data_size >> component_shift != size_t(component_count) || size < data_size)) {
67 self->ThrowOutOfMemoryError(StringPrintf("%s of length %d would overflow",
68 PrettyDescriptor(array_class).c_str(),
69 component_count).c_str());
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070070 return 0; // failure
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070071 }
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070072 return size;
73}
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070074
Ian Rogers6fac4472014-02-25 17:01:10 -080075// Used for setting the array length in the allocation code path to ensure it is guarded by a
76// StoreStore fence.
Mathieu Chartier1febddf2013-11-20 12:33:14 -080077class SetLengthVisitor {
78 public:
79 explicit SetLengthVisitor(int32_t length) : length_(length) {
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -070080 }
Mathieu Chartier1febddf2013-11-20 12:33:14 -080081
Ian Rogers6fac4472014-02-25 17:01:10 -080082 void operator()(Object* obj, size_t usable_size) const
83 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
84 UNUSED(usable_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -080085 // Avoid AsArray as object is not yet in live bitmap or allocation stack.
86 Array* array = down_cast<Array*>(obj);
87 // DCHECK(array->IsArrayInstance());
Mathieu Chartier1febddf2013-11-20 12:33:14 -080088 array->SetLength(length_);
89 }
90
91 private:
92 const int32_t length_;
Ian Rogers6fac4472014-02-25 17:01:10 -080093
94 DISALLOW_COPY_AND_ASSIGN(SetLengthVisitor);
95};
96
97// Similar to SetLengthVisitor, used for setting the array length to fill the usable size of an
98// array.
99class SetLengthToUsableSizeVisitor {
100 public:
Ian Rogersa55cf412014-02-27 00:31:26 -0800101 SetLengthToUsableSizeVisitor(int32_t min_length, size_t header_size, size_t component_size) :
102 minimum_length_(min_length), header_size_(header_size), component_size_(component_size) {
Ian Rogers6fac4472014-02-25 17:01:10 -0800103 }
104
105 void operator()(Object* obj, size_t usable_size) const
106 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
107 // Avoid AsArray as object is not yet in live bitmap or allocation stack.
108 Array* array = down_cast<Array*>(obj);
Ian Rogers6fac4472014-02-25 17:01:10 -0800109 // DCHECK(array->IsArrayInstance());
Ian Rogersa55cf412014-02-27 00:31:26 -0800110 int32_t length = (usable_size - header_size_) / component_size_;
111 DCHECK_GE(length, minimum_length_);
112 byte* old_end = reinterpret_cast<byte*>(array->GetRawData(component_size_, minimum_length_));
113 byte* new_end = reinterpret_cast<byte*>(array->GetRawData(component_size_, length));
114 // Ensure space beyond original allocation is zeroed.
115 memset(old_end, 0, new_end - old_end);
Ian Rogers6fac4472014-02-25 17:01:10 -0800116 array->SetLength(length);
117 }
118
119 private:
Ian Rogersa55cf412014-02-27 00:31:26 -0800120 const int32_t minimum_length_;
Ian Rogers6fac4472014-02-25 17:01:10 -0800121 const size_t header_size_;
122 const size_t component_size_;
123
124 DISALLOW_COPY_AND_ASSIGN(SetLengthToUsableSizeVisitor);
Mathieu Chartier1febddf2013-11-20 12:33:14 -0800125};
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700126
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800127template <bool kIsInstrumented>
Mathieu Chartier590fee92013-09-13 13:46:47 -0700128inline Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count,
Ian Rogers6fac4472014-02-25 17:01:10 -0800129 size_t component_size, gc::AllocatorType allocator_type,
130 bool fill_usable) {
131 DCHECK(allocator_type != gc::kAllocatorTypeLOS);
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -0700132 size_t size = ComputeArraySize(self, array_class, component_count, component_size);
133 if (UNLIKELY(size == 0)) {
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800134 return nullptr;
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -0700135 }
136 gc::Heap* heap = Runtime::Current()->GetHeap();
Ian Rogers6fac4472014-02-25 17:01:10 -0800137 Array* result;
138 if (!fill_usable) {
139 SetLengthVisitor visitor(component_count);
140 result = down_cast<Array*>(
141 heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, array_class, size,
142 allocator_type, visitor));
143 } else {
Hiroshi Yamauchiaa866f52014-03-21 16:18:30 -0700144 SetLengthToUsableSizeVisitor visitor(component_count, DataOffset(component_size).SizeValue(),
Ian Rogersa55cf412014-02-27 00:31:26 -0800145 component_size);
Ian Rogers6fac4472014-02-25 17:01:10 -0800146 result = down_cast<Array*>(
147 heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, array_class, size,
148 allocator_type, visitor));
149 }
150 if (kIsDebugBuild && result != nullptr && Runtime::Current()->IsStarted()) {
Mathieu Chartier85801542014-02-27 18:06:26 -0800151 array_class = result->GetClass(); // In case the array class moved.
Ian Rogersa55cf412014-02-27 00:31:26 -0800152 CHECK_EQ(array_class->GetComponentSize(), component_size);
Ian Rogers6fac4472014-02-25 17:01:10 -0800153 if (!fill_usable) {
154 CHECK_EQ(result->SizeOf(), size);
155 } else {
156 CHECK_GE(result->SizeOf(), size);
157 }
158 }
159 return result;
Hiroshi Yamauchi967a0ad2013-09-10 16:24:21 -0700160}
161
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800162template<class T>
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800163inline void PrimitiveArray<T>::VisitRoots(RootCallback* callback, void* arg) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800164 if (array_class_ != nullptr) {
Mathieu Chartier815873e2014-02-13 18:02:13 -0800165 callback(reinterpret_cast<mirror::Object**>(&array_class_), arg, 0, kRootStickyClass);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800166 }
167}
168
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700169template<typename T>
170inline PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) {
Hiroshi Yamauchi4f1ebc22014-06-25 14:30:41 -0700171 Array* raw_array = Array::Alloc<true>(self, GetArrayClass(), length, sizeof(T),
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700172 Runtime::Current()->GetHeap()->GetCurrentAllocator());
173 return down_cast<PrimitiveArray<T>*>(raw_array);
174}
175
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700176template<typename T>
177inline T PrimitiveArray<T>::Get(int32_t i) {
178 if (!CheckIsValidIndex(i)) {
179 DCHECK(Thread::Current()->IsExceptionPending());
180 return T(0);
181 }
182 return GetWithoutChecks(i);
183}
184
185template<typename T>
186inline void PrimitiveArray<T>::Set(int32_t i, T value) {
187 if (Runtime::Current()->IsActiveTransaction()) {
188 Set<true>(i, value);
189 } else {
190 Set<false>(i, value);
191 }
192}
193
194template<typename T>
195template<bool kTransactionActive, bool kCheckTransaction>
196inline void PrimitiveArray<T>::Set(int32_t i, T value) {
197 if (CheckIsValidIndex(i)) {
198 SetWithoutChecks<kTransactionActive, kCheckTransaction>(i, value);
199 } else {
200 DCHECK(Thread::Current()->IsExceptionPending());
201 }
202}
203
204template<typename T>
205template<bool kTransactionActive, bool kCheckTransaction>
206inline void PrimitiveArray<T>::SetWithoutChecks(int32_t i, T value) {
207 if (kCheckTransaction) {
208 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction());
209 }
210 if (kTransactionActive) {
211 Runtime::Current()->RecordWriteArray(this, i, GetWithoutChecks(i));
212 }
213 DCHECK(CheckIsValidIndex(i));
214 GetData()[i] = value;
215}
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700216// Backward copy where elements are of aligned appropriately for T. Count is in T sized units.
217// Copies are guaranteed not to tear when the sizeof T is less-than 64bit.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800218template<typename T>
219static inline void ArrayBackwardCopy(T* d, const T* s, int32_t count) {
220 d += count;
221 s += count;
222 for (int32_t i = 0; i < count; ++i) {
223 d--;
224 s--;
225 *d = *s;
226 }
227}
228
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700229// Forward copy where elements are of aligned appropriately for T. Count is in T sized units.
230// Copies are guaranteed not to tear when the sizeof T is less-than 64bit.
Ian Rogers6fac4472014-02-25 17:01:10 -0800231template<typename T>
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700232static inline void ArrayForwardCopy(T* d, const T* s, int32_t count) {
233 for (int32_t i = 0; i < count; ++i) {
234 *d = *s;
235 d++;
236 s++;
237 }
Ian Rogers6fac4472014-02-25 17:01:10 -0800238}
239
Ian Rogersef7d42f2014-01-06 12:55:46 -0800240template<class T>
Ian Rogers6fac4472014-02-25 17:01:10 -0800241inline void PrimitiveArray<T>::Memmove(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos,
242 int32_t count) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800243 if (UNLIKELY(count == 0)) {
244 return;
245 }
246 DCHECK_GE(dst_pos, 0);
247 DCHECK_GE(src_pos, 0);
248 DCHECK_GT(count, 0);
249 DCHECK(src != nullptr);
250 DCHECK_LT(dst_pos, GetLength());
251 DCHECK_LE(dst_pos, GetLength() - count);
252 DCHECK_LT(src_pos, src->GetLength());
253 DCHECK_LE(src_pos, src->GetLength() - count);
254
255 // Note for non-byte copies we can't rely on standard libc functions like memcpy(3) and memmove(3)
256 // in our implementation, because they may copy byte-by-byte.
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700257 if (LIKELY(src != this)) {
258 // Memcpy ok for guaranteed non-overlapping distinct arrays.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800259 Memcpy(dst_pos, src, src_pos, count);
260 } else {
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700261 // Handle copies within the same array using the appropriate direction copy.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800262 void* dst_raw = GetRawData(sizeof(T), dst_pos);
263 const void* src_raw = src->GetRawData(sizeof(T), src_pos);
264 if (sizeof(T) == sizeof(uint8_t)) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800265 uint8_t* d = reinterpret_cast<uint8_t*>(dst_raw);
266 const uint8_t* s = reinterpret_cast<const uint8_t*>(src_raw);
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700267 memmove(d, s, count);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800268 } else {
Ian Rogers99cb4ea2014-03-26 22:53:56 -0700269 const bool copy_forward = (dst_pos < src_pos) || (dst_pos - src_pos >= count);
270 if (sizeof(T) == sizeof(uint16_t)) {
271 uint16_t* d = reinterpret_cast<uint16_t*>(dst_raw);
272 const uint16_t* s = reinterpret_cast<const uint16_t*>(src_raw);
273 if (copy_forward) {
274 ArrayForwardCopy<uint16_t>(d, s, count);
275 } else {
276 ArrayBackwardCopy<uint16_t>(d, s, count);
277 }
278 } else if (sizeof(T) == sizeof(uint32_t)) {
279 uint32_t* d = reinterpret_cast<uint32_t*>(dst_raw);
280 const uint32_t* s = reinterpret_cast<const uint32_t*>(src_raw);
281 if (copy_forward) {
282 ArrayForwardCopy<uint32_t>(d, s, count);
283 } else {
284 ArrayBackwardCopy<uint32_t>(d, s, count);
285 }
286 } else {
287 DCHECK_EQ(sizeof(T), sizeof(uint64_t));
288 uint64_t* d = reinterpret_cast<uint64_t*>(dst_raw);
289 const uint64_t* s = reinterpret_cast<const uint64_t*>(src_raw);
290 if (copy_forward) {
291 ArrayForwardCopy<uint64_t>(d, s, count);
292 } else {
293 ArrayBackwardCopy<uint64_t>(d, s, count);
294 }
295 }
Ian Rogersef7d42f2014-01-06 12:55:46 -0800296 }
297 }
298}
299
Ian Rogersef7d42f2014-01-06 12:55:46 -0800300template<class T>
Ian Rogers6fac4472014-02-25 17:01:10 -0800301inline void PrimitiveArray<T>::Memcpy(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos,
302 int32_t count) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800303 if (UNLIKELY(count == 0)) {
304 return;
305 }
306 DCHECK_GE(dst_pos, 0);
307 DCHECK_GE(src_pos, 0);
308 DCHECK_GT(count, 0);
309 DCHECK(src != nullptr);
310 DCHECK_LT(dst_pos, GetLength());
311 DCHECK_LE(dst_pos, GetLength() - count);
312 DCHECK_LT(src_pos, src->GetLength());
313 DCHECK_LE(src_pos, src->GetLength() - count);
314
315 // Note for non-byte copies we can't rely on standard libc functions like memcpy(3) and memmove(3)
316 // in our implementation, because they may copy byte-by-byte.
317 void* dst_raw = GetRawData(sizeof(T), dst_pos);
318 const void* src_raw = src->GetRawData(sizeof(T), src_pos);
319 if (sizeof(T) == sizeof(uint8_t)) {
320 memcpy(dst_raw, src_raw, count);
321 } else if (sizeof(T) == sizeof(uint16_t)) {
322 uint16_t* d = reinterpret_cast<uint16_t*>(dst_raw);
323 const uint16_t* s = reinterpret_cast<const uint16_t*>(src_raw);
324 ArrayForwardCopy<uint16_t>(d, s, count);
325 } else if (sizeof(T) == sizeof(uint32_t)) {
326 uint32_t* d = reinterpret_cast<uint32_t*>(dst_raw);
327 const uint32_t* s = reinterpret_cast<const uint32_t*>(src_raw);
328 ArrayForwardCopy<uint32_t>(d, s, count);
329 } else {
330 DCHECK_EQ(sizeof(T), sizeof(uint64_t));
331 uint64_t* d = reinterpret_cast<uint64_t*>(dst_raw);
332 const uint64_t* s = reinterpret_cast<const uint64_t*>(src_raw);
333 ArrayForwardCopy<uint64_t>(d, s, count);
334 }
335}
336
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800337} // namespace mirror
338} // namespace art
339
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700340#endif // ART_RUNTIME_MIRROR_ARRAY_INL_H_