array.h revision 94f7b49578b6aaa80de8ffed230648d601393905 
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_ARRAY_H_
18#define ART_RUNTIME_MIRROR_ARRAY_H_
19
20#include "gc_root.h"
21#include "gc/allocator_type.h"
22#include "object.h"
23#include "object_callbacks.h"
24
25namespace art {
26
27template<class T> class Handle;
28
29namespace mirror {
30
31class MANAGED Array : public Object {
32 public:
33  // The size of a java.lang.Class representing an array.
34  static uint32_t ClassSize();
35
36  // Allocates an array with the given properties, if fill_usable is true the array will be of at
37  // least component_count size, however, if there's usable space at the end of the allocation the
38  // array will fill it.
39  template <bool kIsInstrumented>
40  static Array* Alloc(Thread* self, Class* array_class, int32_t component_count,
41                      size_t component_size, gc::AllocatorType allocator_type,
42                      bool fill_usable = false)
43      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
44
45  static Array* CreateMultiArray(Thread* self, Handle<Class> element_class,
46                                 Handle<IntArray> dimensions)
47      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
48
49  template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
50           ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
51  size_t SizeOf() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
52  template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
53  int32_t GetLength() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
54    return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Array, length_));
55  }
56
57  void SetLength(int32_t length) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
58    CHECK_GE(length, 0);
59    // We use non transactional version since we can't undo this write. We also disable checking
60    // since it would fail during a transaction.
61    SetField32<false, false, kVerifyNone>(OFFSET_OF_OBJECT_MEMBER(Array, length_), length);
62  }
63
64  static MemberOffset LengthOffset() {
65    return OFFSET_OF_OBJECT_MEMBER(Array, length_);
66  }
67
68  static MemberOffset DataOffset(size_t component_size) {
69    if (component_size != sizeof(int64_t)) {
70      return OFFSET_OF_OBJECT_MEMBER(Array, first_element_);
71    } else {
72      // Align longs and doubles.
73      return MemberOffset(OFFSETOF_MEMBER(Array, first_element_) + 4);
74    }
75  }
76
77  void* GetRawData(size_t component_size, int32_t index)
78      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
79    intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(component_size).Int32Value() +
80        + (index * component_size);
81    return reinterpret_cast<void*>(data);
82  }
83
84  const void* GetRawData(size_t component_size, int32_t index) const {
85    intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(component_size).Int32Value() +
86        + (index * component_size);
87    return reinterpret_cast<void*>(data);
88  }
89
90  // Returns true if the index is valid. If not, throws an ArrayIndexOutOfBoundsException and
91  // returns false.
92  template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
93  bool CheckIsValidIndex(int32_t index) ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
94
95 protected:
96  void ThrowArrayStoreException(Object* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
97
98 private:
99  void ThrowArrayIndexOutOfBoundsException(int32_t index)
100      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
101
102  // The number of array elements.
103  int32_t length_;
104  // Marker for the data (used by generated code)
105  uint32_t first_element_[0];
106
107  DISALLOW_IMPLICIT_CONSTRUCTORS(Array);
108};
109
110template<typename T>
111class MANAGED PrimitiveArray : public Array {
112 public:
113  typedef T ElementType;
114
115  static PrimitiveArray<T>* Alloc(Thread* self, size_t length)
116      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
117
118  const T* GetData() const ALWAYS_INLINE  SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
119    return reinterpret_cast<const T*>(GetRawData(sizeof(T), 0));
120  }
121
122  T* GetData() ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
123    return reinterpret_cast<T*>(GetRawData(sizeof(T), 0));
124  }
125
126  T Get(int32_t i) ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
127
128  T GetWithoutChecks(int32_t i) ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
129    DCHECK(CheckIsValidIndex(i));
130    return GetData()[i];
131  }
132
133  void Set(int32_t i, T value) ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
134
135  // TODO fix thread safety analysis broken by the use of template. This should be
136  // SHARED_LOCKS_REQUIRED(Locks::mutator_lock_).
137  template<bool kTransactionActive, bool kCheckTransaction = true>
138  void Set(int32_t i, T value) ALWAYS_INLINE NO_THREAD_SAFETY_ANALYSIS;
139
140  // TODO fix thread safety analysis broken by the use of template. This should be
141  // SHARED_LOCKS_REQUIRED(Locks::mutator_lock_).
142  template<bool kTransactionActive, bool kCheckTransaction = true>
143  void SetWithoutChecks(int32_t i, T value) ALWAYS_INLINE NO_THREAD_SAFETY_ANALYSIS;
144
145  /*
146   * Works like memmove(), except we guarantee not to allow tearing of array values (ie using
147   * smaller than element size copies). Arguments are assumed to be within the bounds of the array
148   * and the arrays non-null.
149   */
150  void Memmove(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos, int32_t count)
151      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
152
153  /*
154   * Works like memcpy(), except we guarantee not to allow tearing of array values (ie using
155   * smaller than element size copies). Arguments are assumed to be within the bounds of the array
156   * and the arrays non-null.
157   */
158  void Memcpy(int32_t dst_pos, PrimitiveArray<T>* src, int32_t src_pos, int32_t count)
159      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
160
161  static void SetArrayClass(Class* array_class) {
162    CHECK(array_class_.IsNull());
163    CHECK(array_class != nullptr);
164    array_class_ = GcRoot<Class>(array_class);
165  }
166
167  static Class* GetArrayClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
168    DCHECK(!array_class_.IsNull());
169    return array_class_.Read();
170  }
171
172  static void ResetArrayClass() {
173    CHECK(!array_class_.IsNull());
174    array_class_ = GcRoot<Class>(nullptr);
175  }
176
177  static void VisitRoots(RootCallback* callback, void* arg)
178      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
179
180 private:
181  static GcRoot<Class> array_class_;
182
183  DISALLOW_IMPLICIT_CONSTRUCTORS(PrimitiveArray);
184};
185
186}  // namespace mirror
187}  // namespace art
188
189#endif  // ART_RUNTIME_MIRROR_ARRAY_H_
190