• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_H_
18 #define ART_RUNTIME_MIRROR_OBJECT_ARRAY_H_
19 
20 #include "array.h"
21 #include "obj_ptr.h"
22 
23 namespace art {
24 namespace mirror {
25 
26 template<class T>
27 class MANAGED ObjectArray: public Array {
28  public:
29   // The size of Object[].class.
ClassSize(PointerSize pointer_size)30   static uint32_t ClassSize(PointerSize pointer_size) {
31     return Array::ClassSize(pointer_size);
32   }
33 
34   static ObjPtr<ObjectArray<T>> Alloc(Thread* self,
35                                       ObjPtr<Class> object_array_class,
36                                       int32_t length,
37                                       gc::AllocatorType allocator_type)
38       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
39 
40   static ObjPtr<ObjectArray<T>> Alloc(Thread* self,
41                                       ObjPtr<Class> object_array_class,
42                                       int32_t length)
43       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
44 
45   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
46            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
47   ALWAYS_INLINE ObjPtr<T> Get(int32_t i) REQUIRES_SHARED(Locks::mutator_lock_);
48 
49   // Returns true if the object can be stored into the array. If not, throws
50   // an ArrayStoreException and returns false.
51   // TODO fix thread safety analysis: should be REQUIRES_SHARED(Locks::mutator_lock_).
52   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
53   bool CheckAssignable(ObjPtr<T> object) NO_THREAD_SAFETY_ANALYSIS;
54 
55   ALWAYS_INLINE void Set(int32_t i, ObjPtr<T> object) REQUIRES_SHARED(Locks::mutator_lock_);
56   // TODO fix thread safety analysis: should be REQUIRES_SHARED(Locks::mutator_lock_).
57   template<bool kTransactionActive, bool kCheckTransaction = true,
58       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
59   ALWAYS_INLINE void Set(int32_t i, ObjPtr<T> object) NO_THREAD_SAFETY_ANALYSIS;
60 
61   // Set element without bound and element type checks, to be used in limited
62   // circumstances, such as during boot image writing.
63   // TODO fix thread safety analysis broken by the use of template. This should be
64   // REQUIRES_SHARED(Locks::mutator_lock_).
65   template<bool kTransactionActive, bool kCheckTransaction = true,
66       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
67   ALWAYS_INLINE void SetWithoutChecks(int32_t i, ObjPtr<T> object) NO_THREAD_SAFETY_ANALYSIS;
68   // TODO fix thread safety analysis broken by the use of template. This should be
69   // REQUIRES_SHARED(Locks::mutator_lock_).
70   template<bool kTransactionActive, bool kCheckTransaction = true,
71       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
72   ALWAYS_INLINE void SetWithoutChecksAndWriteBarrier(int32_t i, ObjPtr<T> object)
73       NO_THREAD_SAFETY_ANALYSIS;
74 
75   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
76            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
77   ALWAYS_INLINE ObjPtr<T> GetWithoutChecks(int32_t i) REQUIRES_SHARED(Locks::mutator_lock_);
78 
79   // Copy src into this array (dealing with overlaps as memmove does) without assignability checks.
80   void AssignableMemmove(int32_t dst_pos,
81                          ObjPtr<ObjectArray<T>> src,
82                          int32_t src_pos,
83                          int32_t count)
84       REQUIRES_SHARED(Locks::mutator_lock_);
85 
86   // Copy src into this array assuming no overlap and without assignability checks.
87   void AssignableMemcpy(int32_t dst_pos,
88                         ObjPtr<ObjectArray<T>> src,
89                         int32_t src_pos,
90                         int32_t count)
91       REQUIRES_SHARED(Locks::mutator_lock_);
92 
93   // Copy src into this array with assignability checks.
94   template<bool kTransactionActive>
95   void AssignableCheckingMemcpy(int32_t dst_pos,
96                                 ObjPtr<ObjectArray<T>> src,
97                                 int32_t src_pos,
98                                 int32_t count,
99                                 bool throw_exception)
100       REQUIRES_SHARED(Locks::mutator_lock_);
101 
102   ObjPtr<ObjectArray<T>> CopyOf(Thread* self, int32_t new_length)
103       REQUIRES_SHARED(Locks::mutator_lock_)
104       REQUIRES(!Roles::uninterruptible_);
105 
106   static MemberOffset OffsetOfElement(int32_t i);
107 
108  private:
109   // TODO fix thread safety analysis broken by the use of template. This should be
110   // REQUIRES_SHARED(Locks::mutator_lock_).
111   template<typename Visitor>
112   void VisitReferences(const Visitor& visitor) NO_THREAD_SAFETY_ANALYSIS;
113 
114   friend class Object;  // For VisitReferences
115   DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectArray);
116 };
117 
118 }  // namespace mirror
119 }  // namespace art
120 
121 #endif  // ART_RUNTIME_MIRROR_OBJECT_ARRAY_H_
122