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_CLASS_INL_H_
18 #define ART_RUNTIME_MIRROR_CLASS_INL_H_
19
20 #include "class.h"
21
22 #include "art_field.h"
23 #include "art_method.h"
24 #include "class_loader.h"
25 #include "dex_cache.h"
26 #include "iftable.h"
27 #include "object_array-inl.h"
28 #include "runtime.h"
29 #include "string.h"
30
31 namespace art {
32 namespace mirror {
33
GetObjectSize()34 inline size_t Class::GetObjectSize() const {
35 DCHECK(!IsVariableSize()) << " class=" << PrettyTypeOf(this);
36 DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
37 size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), false);
38 DCHECK_GE(result, sizeof(Object)) << " class=" << PrettyTypeOf(this);
39 return result;
40 }
41
GetSuperClass()42 inline Class* Class::GetSuperClass() const {
43 // Can only get super class for loaded classes (hack for when runtime is
44 // initializing)
45 DCHECK(IsLoaded() || !Runtime::Current()->IsStarted()) << IsLoaded();
46 return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
47 }
48
GetClassLoader()49 inline ClassLoader* Class::GetClassLoader() const {
50 return GetFieldObject<ClassLoader*>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), false);
51 }
52
GetDexCache()53 inline DexCache* Class::GetDexCache() const {
54 return GetFieldObject<DexCache*>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), false);
55 }
56
GetDirectMethods()57 inline ObjectArray<ArtMethod>* Class::GetDirectMethods() const {
58 DCHECK(IsLoaded() || IsErroneous());
59 return GetFieldObject<ObjectArray<ArtMethod>*>(
60 OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
61 }
62
SetDirectMethods(ObjectArray<ArtMethod> * new_direct_methods)63 inline void Class::SetDirectMethods(ObjectArray<ArtMethod>* new_direct_methods)
64 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
65 DCHECK(NULL == GetFieldObject<ObjectArray<ArtMethod>*>(
66 OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false));
67 DCHECK_NE(0, new_direct_methods->GetLength());
68 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_),
69 new_direct_methods, false);
70 }
71
GetDirectMethod(int32_t i)72 inline ArtMethod* Class::GetDirectMethod(int32_t i) const
73 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
74 return GetDirectMethods()->Get(i);
75 }
76
SetDirectMethod(uint32_t i,ArtMethod * f)77 inline void Class::SetDirectMethod(uint32_t i, ArtMethod* f) // TODO: uint16_t
78 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
79 ObjectArray<ArtMethod>* direct_methods =
80 GetFieldObject<ObjectArray<ArtMethod>*>(
81 OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
82 direct_methods->Set(i, f);
83 }
84
85 // Returns the number of static, private, and constructor methods.
NumDirectMethods()86 inline size_t Class::NumDirectMethods() const {
87 return (GetDirectMethods() != NULL) ? GetDirectMethods()->GetLength() : 0;
88 }
89
GetVirtualMethods()90 inline ObjectArray<ArtMethod>* Class::GetVirtualMethods() const {
91 DCHECK(IsLoaded() || IsErroneous());
92 return GetFieldObject<ObjectArray<ArtMethod>*>(
93 OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
94 }
95
SetVirtualMethods(ObjectArray<ArtMethod> * new_virtual_methods)96 inline void Class::SetVirtualMethods(ObjectArray<ArtMethod>* new_virtual_methods) {
97 // TODO: we reassign virtual methods to grow the table for miranda
98 // methods.. they should really just be assigned once
99 DCHECK_NE(0, new_virtual_methods->GetLength());
100 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_),
101 new_virtual_methods, false);
102 }
103
NumVirtualMethods()104 inline size_t Class::NumVirtualMethods() const {
105 return (GetVirtualMethods() != NULL) ? GetVirtualMethods()->GetLength() : 0;
106 }
107
GetVirtualMethod(uint32_t i)108 inline ArtMethod* Class::GetVirtualMethod(uint32_t i) const
109 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
110 DCHECK(IsResolved() || IsErroneous());
111 return GetVirtualMethods()->Get(i);
112 }
113
GetVirtualMethodDuringLinking(uint32_t i)114 inline ArtMethod* Class::GetVirtualMethodDuringLinking(uint32_t i) const
115 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
116 DCHECK(IsLoaded() || IsErroneous());
117 return GetVirtualMethods()->Get(i);
118 }
119
SetVirtualMethod(uint32_t i,ArtMethod * f)120 inline void Class::SetVirtualMethod(uint32_t i, ArtMethod* f) // TODO: uint16_t
121 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
122 ObjectArray<ArtMethod>* virtual_methods =
123 GetFieldObject<ObjectArray<ArtMethod>*>(
124 OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
125 virtual_methods->Set(i, f);
126 }
127
GetVTable()128 inline ObjectArray<ArtMethod>* Class::GetVTable() const {
129 DCHECK(IsResolved() || IsErroneous());
130 return GetFieldObject<ObjectArray<ArtMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
131 }
132
GetVTableDuringLinking()133 inline ObjectArray<ArtMethod>* Class::GetVTableDuringLinking() const {
134 DCHECK(IsLoaded() || IsErroneous());
135 return GetFieldObject<ObjectArray<ArtMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
136 }
137
SetVTable(ObjectArray<ArtMethod> * new_vtable)138 inline void Class::SetVTable(ObjectArray<ArtMethod>* new_vtable)
139 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
140 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable, false);
141 }
142
Implements(const Class * klass)143 inline bool Class::Implements(const Class* klass) const {
144 DCHECK(klass != NULL);
145 DCHECK(klass->IsInterface()) << PrettyClass(this);
146 // All interfaces implemented directly and by our superclass, and
147 // recursively all super-interfaces of those interfaces, are listed
148 // in iftable_, so we can just do a linear scan through that.
149 int32_t iftable_count = GetIfTableCount();
150 IfTable* iftable = GetIfTable();
151 for (int32_t i = 0; i < iftable_count; i++) {
152 if (iftable->GetInterface(i) == klass) {
153 return true;
154 }
155 }
156 return false;
157 }
158
159 // Determine whether "this" is assignable from "src", where both of these
160 // are array classes.
161 //
162 // Consider an array class, e.g. Y[][], where Y is a subclass of X.
163 // Y[][] = Y[][] --> true (identity)
164 // X[][] = Y[][] --> true (element superclass)
165 // Y = Y[][] --> false
166 // Y[] = Y[][] --> false
167 // Object = Y[][] --> true (everything is an object)
168 // Object[] = Y[][] --> true
169 // Object[][] = Y[][] --> true
170 // Object[][][] = Y[][] --> false (too many []s)
171 // Serializable = Y[][] --> true (all arrays are Serializable)
172 // Serializable[] = Y[][] --> true
173 // Serializable[][] = Y[][] --> false (unless Y is Serializable)
174 //
175 // Don't forget about primitive types.
176 // Object[] = int[] --> false
177 //
IsArrayAssignableFromArray(const Class * src)178 inline bool Class::IsArrayAssignableFromArray(const Class* src) const {
179 DCHECK(IsArrayClass()) << PrettyClass(this);
180 DCHECK(src->IsArrayClass()) << PrettyClass(src);
181 return GetComponentType()->IsAssignableFrom(src->GetComponentType());
182 }
183
IsAssignableFromArray(const Class * src)184 inline bool Class::IsAssignableFromArray(const Class* src) const {
185 DCHECK(!IsInterface()) << PrettyClass(this); // handled first in IsAssignableFrom
186 DCHECK(src->IsArrayClass()) << PrettyClass(src);
187 if (!IsArrayClass()) {
188 // If "this" is not also an array, it must be Object.
189 // src's super should be java_lang_Object, since it is an array.
190 Class* java_lang_Object = src->GetSuperClass();
191 DCHECK(java_lang_Object != NULL) << PrettyClass(src);
192 DCHECK(java_lang_Object->GetSuperClass() == NULL) << PrettyClass(src);
193 return this == java_lang_Object;
194 }
195 return IsArrayAssignableFromArray(src);
196 }
197
IsSubClass(const Class * klass)198 inline bool Class::IsSubClass(const Class* klass) const {
199 DCHECK(!IsInterface()) << PrettyClass(this);
200 DCHECK(!IsArrayClass()) << PrettyClass(this);
201 const Class* current = this;
202 do {
203 if (current == klass) {
204 return true;
205 }
206 current = current->GetSuperClass();
207 } while (current != NULL);
208 return false;
209 }
210
FindVirtualMethodForInterface(ArtMethod * method)211 inline ArtMethod* Class::FindVirtualMethodForInterface(ArtMethod* method) const {
212 Class* declaring_class = method->GetDeclaringClass();
213 DCHECK(declaring_class != NULL) << PrettyClass(this);
214 DCHECK(declaring_class->IsInterface()) << PrettyMethod(method);
215 // TODO cache to improve lookup speed
216 int32_t iftable_count = GetIfTableCount();
217 IfTable* iftable = GetIfTable();
218 for (int32_t i = 0; i < iftable_count; i++) {
219 if (iftable->GetInterface(i) == declaring_class) {
220 return iftable->GetMethodArray(i)->Get(method->GetMethodIndex());
221 }
222 }
223 return NULL;
224 }
225
FindVirtualMethodForVirtual(ArtMethod * method)226 inline ArtMethod* Class::FindVirtualMethodForVirtual(ArtMethod* method) const
227 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
228 DCHECK(!method->GetDeclaringClass()->IsInterface() || method->IsMiranda());
229 // The argument method may from a super class.
230 // Use the index to a potentially overridden one for this instance's class.
231 return GetVTable()->Get(method->GetMethodIndex());
232 }
233
FindVirtualMethodForSuper(ArtMethod * method)234 inline ArtMethod* Class::FindVirtualMethodForSuper(ArtMethod* method) const
235 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
236 DCHECK(!method->GetDeclaringClass()->IsInterface());
237 return GetSuperClass()->GetVTable()->Get(method->GetMethodIndex());
238 }
239
FindVirtualMethodForVirtualOrInterface(ArtMethod * method)240 inline ArtMethod* Class::FindVirtualMethodForVirtualOrInterface(ArtMethod* method) const {
241 if (method->IsDirect()) {
242 return method;
243 }
244 if (method->GetDeclaringClass()->IsInterface() && !method->IsMiranda()) {
245 return FindVirtualMethodForInterface(method);
246 }
247 return FindVirtualMethodForVirtual(method);
248 }
249
GetIfTable()250 inline IfTable* Class::GetIfTable() const {
251 return GetFieldObject<IfTable*>(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), false);
252 }
253
GetIfTableCount()254 inline int32_t Class::GetIfTableCount() const {
255 IfTable* iftable = GetIfTable();
256 if (iftable == NULL) {
257 return 0;
258 }
259 return iftable->Count();
260 }
261
SetIfTable(IfTable * new_iftable)262 inline void Class::SetIfTable(IfTable* new_iftable) {
263 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), new_iftable, false);
264 }
265
GetIFields()266 inline ObjectArray<ArtField>* Class::GetIFields() const {
267 DCHECK(IsLoaded() || IsErroneous());
268 return GetFieldObject<ObjectArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
269 }
270
SetIFields(ObjectArray<ArtField> * new_ifields)271 inline void Class::SetIFields(ObjectArray<ArtField>* new_ifields)
272 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
273 DCHECK(NULL == GetFieldObject<ObjectArray<ArtField>*>(
274 OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false));
275 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields, false);
276 }
277
GetSFields()278 inline ObjectArray<ArtField>* Class::GetSFields() const {
279 DCHECK(IsLoaded() || IsErroneous());
280 return GetFieldObject<ObjectArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
281 }
282
SetSFields(ObjectArray<ArtField> * new_sfields)283 inline void Class::SetSFields(ObjectArray<ArtField>* new_sfields)
284 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
285 DCHECK(NULL == GetFieldObject<ObjectArray<ArtField>*>(
286 OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false));
287 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields, false);
288 }
289
NumStaticFields()290 inline size_t Class::NumStaticFields() const {
291 return (GetSFields() != NULL) ? GetSFields()->GetLength() : 0;
292 }
293
GetStaticField(uint32_t i)294 inline ArtField* Class::GetStaticField(uint32_t i) const // TODO: uint16_t
295 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
296 return GetSFields()->Get(i);
297 }
298
SetStaticField(uint32_t i,ArtField * f)299 inline void Class::SetStaticField(uint32_t i, ArtField* f) // TODO: uint16_t
300 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
301 ObjectArray<ArtField>* sfields= GetFieldObject<ObjectArray<ArtField>*>(
302 OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
303 sfields->Set(i, f);
304 }
305
NumInstanceFields()306 inline size_t Class::NumInstanceFields() const {
307 return (GetIFields() != NULL) ? GetIFields()->GetLength() : 0;
308 }
309
GetInstanceField(uint32_t i)310 inline ArtField* Class::GetInstanceField(uint32_t i) const // TODO: uint16_t
311 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
312 DCHECK_NE(NumInstanceFields(), 0U);
313 return GetIFields()->Get(i);
314 }
315
SetInstanceField(uint32_t i,ArtField * f)316 inline void Class::SetInstanceField(uint32_t i, ArtField* f) // TODO: uint16_t
317 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
318 ObjectArray<ArtField>* ifields= GetFieldObject<ObjectArray<ArtField>*>(
319 OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
320 ifields->Set(i, f);
321 }
322
SetVerifyErrorClass(Class * klass)323 inline void Class::SetVerifyErrorClass(Class* klass) {
324 CHECK(klass != NULL) << PrettyClass(this);
325 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), klass, false);
326 }
327
GetAccessFlags()328 inline uint32_t Class::GetAccessFlags() const {
329 // Check class is loaded or this is java.lang.String that has a
330 // circularity issue during loading the names of its members
331 DCHECK(IsLoaded() || IsErroneous() ||
332 this == String::GetJavaLangString() ||
333 this == ArtField::GetJavaLangReflectArtField() ||
334 this == ArtMethod::GetJavaLangReflectArtMethod());
335 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
336 }
337
GetName()338 inline String* Class::GetName() const {
339 return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, name_), false);
340 }
SetName(String * name)341 inline void Class::SetName(String* name) {
342 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, name_), name, false);
343 }
344
345 } // namespace mirror
346 } // namespace art
347
348 #endif // ART_RUNTIME_MIRROR_CLASS_INL_H_
349