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 "base/array_slice.h"
25 #include "base/iteration_range.h"
26 #include "base/length_prefixed_array.h"
27 #include "base/utils.h"
28 #include "class_linker.h"
29 #include "class_loader.h"
30 #include "common_throws.h"
31 #include "dex/dex_file-inl.h"
32 #include "dex/invoke_type.h"
33 #include "dex_cache.h"
34 #include "iftable-inl.h"
35 #include "imtable.h"
36 #include "object-inl.h"
37 #include "object_array.h"
38 #include "read_barrier-inl.h"
39 #include "runtime.h"
40 #include "string.h"
41 #include "subtype_check.h"
42 #include "thread-current-inl.h"
43 
44 namespace art {
45 namespace mirror {
46 
47 template<VerifyObjectFlags kVerifyFlags>
GetObjectSize()48 inline uint32_t Class::GetObjectSize() {
49   // Note: Extra parentheses to avoid the comma being interpreted as macro parameter separator.
50   DCHECK((!IsVariableSize<kVerifyFlags>())) << "class=" << PrettyTypeOf();
51   return GetField32(ObjectSizeOffset());
52 }
53 
54 template<VerifyObjectFlags kVerifyFlags>
GetObjectSizeAllocFastPath()55 inline uint32_t Class::GetObjectSizeAllocFastPath() {
56   // Note: Extra parentheses to avoid the comma being interpreted as macro parameter separator.
57   DCHECK((!IsVariableSize<kVerifyFlags>())) << "class=" << PrettyTypeOf();
58   return GetField32(ObjectSizeAllocFastPathOffset());
59 }
60 
61 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetSuperClass()62 inline ObjPtr<Class> Class::GetSuperClass() {
63   // Can only get super class for loaded classes (hack for when runtime is
64   // initializing)
65   DCHECK(IsLoaded<kVerifyFlags>() ||
66          IsErroneous<kVerifyFlags>() ||
67          !Runtime::Current()->IsStarted()) << IsLoaded();
68   return GetFieldObject<Class, kVerifyFlags, kReadBarrierOption>(
69       OFFSET_OF_OBJECT_MEMBER(Class, super_class_));
70 }
71 
SetSuperClass(ObjPtr<Class> new_super_class)72 inline void Class::SetSuperClass(ObjPtr<Class> new_super_class) {
73   // Super class is assigned once, except during class linker initialization.
74   if (kIsDebugBuild) {
75     ObjPtr<Class> old_super_class =
76         GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_));
77     DCHECK(old_super_class == nullptr || old_super_class == new_super_class);
78   }
79   DCHECK(new_super_class != nullptr);
80   SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), new_super_class);
81 }
82 
HasSuperClass()83 inline bool Class::HasSuperClass() {
84   // No read barrier is needed for comparing with null. See ReadBarrierOption.
85   return GetSuperClass<kDefaultVerifyFlags, kWithoutReadBarrier>() != nullptr;
86 }
87 
88 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetClassLoader()89 inline ObjPtr<ClassLoader> Class::GetClassLoader() {
90   return GetFieldObject<ClassLoader, kVerifyFlags, kReadBarrierOption>(
91       OFFSET_OF_OBJECT_MEMBER(Class, class_loader_));
92 }
93 
94 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetExtData()95 inline ObjPtr<ClassExt> Class::GetExtData() {
96   return GetFieldObject<ClassExt, kVerifyFlags, kReadBarrierOption>(
97       OFFSET_OF_OBJECT_MEMBER(Class, ext_data_));
98 }
99 
100 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetDexCache()101 inline ObjPtr<DexCache> Class::GetDexCache() {
102   return GetFieldObject<DexCache, kVerifyFlags, kReadBarrierOption>(
103       OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_));
104 }
105 
GetCopiedMethodsStartOffset()106 inline uint32_t Class::GetCopiedMethodsStartOffset() {
107   // Object::GetFieldShort returns an int16_t value, but
108   // Class::copied_methods_offset_ is an uint16_t value; cast the
109   // latter to uint16_t before returning it as an uint32_t value, so
110   // that uint16_t values between 2^15 and 2^16-1 are correctly
111   // handled.
112   return static_cast<uint16_t>(
113       GetFieldShort(OFFSET_OF_OBJECT_MEMBER(Class, copied_methods_offset_)));
114 }
115 
GetDirectMethodsStartOffset()116 inline uint32_t Class::GetDirectMethodsStartOffset() {
117   return 0;
118 }
119 
GetVirtualMethodsStartOffset()120 inline uint32_t Class::GetVirtualMethodsStartOffset() {
121   // Object::GetFieldShort returns an int16_t value, but
122   // Class::virtual_method_offset_ is an uint16_t value; cast the
123   // latter to uint16_t before returning it as an uint32_t value, so
124   // that uint16_t values between 2^15 and 2^16-1 are correctly
125   // handled.
126   return static_cast<uint16_t>(
127       GetFieldShort(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_offset_)));
128 }
129 
130 template<VerifyObjectFlags kVerifyFlags>
GetDirectMethodsSlice(PointerSize pointer_size)131 inline ArraySlice<ArtMethod> Class::GetDirectMethodsSlice(PointerSize pointer_size) {
132   DCHECK(IsLoaded() || IsErroneous());
133   return GetDirectMethodsSliceUnchecked(pointer_size);
134 }
135 
GetDirectMethodsSliceUnchecked(PointerSize pointer_size)136 inline ArraySlice<ArtMethod> Class::GetDirectMethodsSliceUnchecked(PointerSize pointer_size) {
137   return GetMethodsSliceRangeUnchecked(GetMethodsPtr(),
138                                        pointer_size,
139                                        GetDirectMethodsStartOffset(),
140                                        GetVirtualMethodsStartOffset());
141 }
142 
143 template<VerifyObjectFlags kVerifyFlags>
GetDeclaredMethodsSlice(PointerSize pointer_size)144 inline ArraySlice<ArtMethod> Class::GetDeclaredMethodsSlice(PointerSize pointer_size) {
145   DCHECK(IsLoaded() || IsErroneous());
146   return GetDeclaredMethodsSliceUnchecked(pointer_size);
147 }
148 
GetDeclaredMethodsSliceUnchecked(PointerSize pointer_size)149 inline ArraySlice<ArtMethod> Class::GetDeclaredMethodsSliceUnchecked(PointerSize pointer_size) {
150   return GetMethodsSliceRangeUnchecked(GetMethodsPtr(),
151                                        pointer_size,
152                                        GetDirectMethodsStartOffset(),
153                                        GetCopiedMethodsStartOffset());
154 }
155 
156 template<VerifyObjectFlags kVerifyFlags>
GetDeclaredVirtualMethodsSlice(PointerSize pointer_size)157 inline ArraySlice<ArtMethod> Class::GetDeclaredVirtualMethodsSlice(PointerSize pointer_size) {
158   DCHECK(IsLoaded() || IsErroneous());
159   return GetDeclaredVirtualMethodsSliceUnchecked(pointer_size);
160 }
161 
GetDeclaredVirtualMethodsSliceUnchecked(PointerSize pointer_size)162 inline ArraySlice<ArtMethod> Class::GetDeclaredVirtualMethodsSliceUnchecked(
163     PointerSize pointer_size) {
164   return GetMethodsSliceRangeUnchecked(GetMethodsPtr(),
165                                        pointer_size,
166                                        GetVirtualMethodsStartOffset(),
167                                        GetCopiedMethodsStartOffset());
168 }
169 
170 template<VerifyObjectFlags kVerifyFlags>
GetVirtualMethodsSlice(PointerSize pointer_size)171 inline ArraySlice<ArtMethod> Class::GetVirtualMethodsSlice(PointerSize pointer_size) {
172   DCHECK(IsLoaded() || IsErroneous());
173   return GetVirtualMethodsSliceUnchecked(pointer_size);
174 }
175 
GetVirtualMethodsSliceUnchecked(PointerSize pointer_size)176 inline ArraySlice<ArtMethod> Class::GetVirtualMethodsSliceUnchecked(PointerSize pointer_size) {
177   LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
178   return GetMethodsSliceRangeUnchecked(methods,
179                                        pointer_size,
180                                        GetVirtualMethodsStartOffset(),
181                                        NumMethods(methods));
182 }
183 
184 template<VerifyObjectFlags kVerifyFlags>
GetCopiedMethodsSlice(PointerSize pointer_size)185 inline ArraySlice<ArtMethod> Class::GetCopiedMethodsSlice(PointerSize pointer_size) {
186   DCHECK(IsLoaded() || IsErroneous());
187   return GetCopiedMethodsSliceUnchecked(pointer_size);
188 }
189 
GetCopiedMethodsSliceUnchecked(PointerSize pointer_size)190 inline ArraySlice<ArtMethod> Class::GetCopiedMethodsSliceUnchecked(PointerSize pointer_size) {
191   LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
192   return GetMethodsSliceRangeUnchecked(methods,
193                                        pointer_size,
194                                        GetCopiedMethodsStartOffset(),
195                                        NumMethods(methods));
196 }
197 
GetMethodsPtr()198 inline LengthPrefixedArray<ArtMethod>* Class::GetMethodsPtr() {
199   return reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
200       static_cast<uintptr_t>(GetField64(OFFSET_OF_OBJECT_MEMBER(Class, methods_))));
201 }
202 
203 template<VerifyObjectFlags kVerifyFlags>
GetMethodsSlice(PointerSize pointer_size)204 inline ArraySlice<ArtMethod> Class::GetMethodsSlice(PointerSize pointer_size) {
205   DCHECK(IsLoaded() || IsErroneous());
206   LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
207   return GetMethodsSliceRangeUnchecked(methods, pointer_size, 0, NumMethods(methods));
208 }
209 
GetMethodsSliceRangeUnchecked(LengthPrefixedArray<ArtMethod> * methods,PointerSize pointer_size,uint32_t start_offset,uint32_t end_offset)210 inline ArraySlice<ArtMethod> Class::GetMethodsSliceRangeUnchecked(
211     LengthPrefixedArray<ArtMethod>* methods,
212     PointerSize pointer_size,
213     uint32_t start_offset,
214     uint32_t end_offset) {
215   DCHECK_LE(start_offset, end_offset);
216   DCHECK_LE(end_offset, NumMethods(methods));
217   uint32_t size = end_offset - start_offset;
218   if (size == 0u) {
219     return ArraySlice<ArtMethod>();
220   }
221   DCHECK(methods != nullptr);
222   DCHECK_LE(end_offset, methods->size());
223   size_t method_size = ArtMethod::Size(pointer_size);
224   size_t method_alignment = ArtMethod::Alignment(pointer_size);
225   ArraySlice<ArtMethod> slice(&methods->At(0u, method_size, method_alignment),
226                               methods->size(),
227                               method_size);
228   return slice.SubArray(start_offset, size);
229 }
230 
NumMethods()231 inline uint32_t Class::NumMethods() {
232   return NumMethods(GetMethodsPtr());
233 }
234 
NumMethods(LengthPrefixedArray<ArtMethod> * methods)235 inline uint32_t Class::NumMethods(LengthPrefixedArray<ArtMethod>* methods) {
236   return (methods == nullptr) ? 0 : methods->size();
237 }
238 
GetDirectMethodUnchecked(size_t i,PointerSize pointer_size)239 inline ArtMethod* Class::GetDirectMethodUnchecked(size_t i, PointerSize pointer_size) {
240   CheckPointerSize(pointer_size);
241   return &GetDirectMethodsSliceUnchecked(pointer_size)[i];
242 }
243 
GetDirectMethod(size_t i,PointerSize pointer_size)244 inline ArtMethod* Class::GetDirectMethod(size_t i, PointerSize pointer_size) {
245   CheckPointerSize(pointer_size);
246   return &GetDirectMethodsSlice(pointer_size)[i];
247 }
248 
SetMethodsPtr(LengthPrefixedArray<ArtMethod> * new_methods,uint32_t num_direct,uint32_t num_virtual)249 inline void Class::SetMethodsPtr(LengthPrefixedArray<ArtMethod>* new_methods,
250                                  uint32_t num_direct,
251                                  uint32_t num_virtual) {
252   DCHECK(GetMethodsPtr() == nullptr);
253   SetMethodsPtrUnchecked(new_methods, num_direct, num_virtual);
254 }
255 
256 
SetMethodsPtrUnchecked(LengthPrefixedArray<ArtMethod> * new_methods,uint32_t num_direct,uint32_t num_virtual)257 inline void Class::SetMethodsPtrUnchecked(LengthPrefixedArray<ArtMethod>* new_methods,
258                                           uint32_t num_direct,
259                                           uint32_t num_virtual) {
260   DCHECK_LE(num_direct + num_virtual, (new_methods == nullptr) ? 0 : new_methods->size());
261   SetField64<false>(OFFSET_OF_OBJECT_MEMBER(Class, methods_),
262                     static_cast<uint64_t>(reinterpret_cast<uintptr_t>(new_methods)));
263   SetFieldShort<false>(OFFSET_OF_OBJECT_MEMBER(Class, copied_methods_offset_),
264                     dchecked_integral_cast<uint16_t>(num_direct + num_virtual));
265   SetFieldShort<false>(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_offset_),
266                        dchecked_integral_cast<uint16_t>(num_direct));
267 }
268 
269 template<VerifyObjectFlags kVerifyFlags>
GetVirtualMethod(size_t i,PointerSize pointer_size)270 inline ArtMethod* Class::GetVirtualMethod(size_t i, PointerSize pointer_size) {
271   CheckPointerSize(pointer_size);
272   DCHECK(IsResolved<kVerifyFlags>() || IsErroneous<kVerifyFlags>())
273       << Class::PrettyClass() << " status=" << GetStatus();
274   return GetVirtualMethodUnchecked(i, pointer_size);
275 }
276 
GetVirtualMethodDuringLinking(size_t i,PointerSize pointer_size)277 inline ArtMethod* Class::GetVirtualMethodDuringLinking(size_t i, PointerSize pointer_size) {
278   CheckPointerSize(pointer_size);
279   DCHECK(IsLoaded() || IsErroneous());
280   return GetVirtualMethodUnchecked(i, pointer_size);
281 }
282 
GetVirtualMethodUnchecked(size_t i,PointerSize pointer_size)283 inline ArtMethod* Class::GetVirtualMethodUnchecked(size_t i, PointerSize pointer_size) {
284   CheckPointerSize(pointer_size);
285   return &GetVirtualMethodsSliceUnchecked(pointer_size)[i];
286 }
287 
288 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetVTable()289 inline ObjPtr<PointerArray> Class::GetVTable() {
290   DCHECK(IsLoaded<kVerifyFlags>() || IsErroneous<kVerifyFlags>());
291   return GetFieldObject<PointerArray, kVerifyFlags, kReadBarrierOption>(
292       OFFSET_OF_OBJECT_MEMBER(Class, vtable_));
293 }
294 
GetVTableDuringLinking()295 inline ObjPtr<PointerArray> Class::GetVTableDuringLinking() {
296   DCHECK(IsLoaded() || IsErroneous());
297   return GetFieldObject<PointerArray>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_));
298 }
299 
SetVTable(ObjPtr<PointerArray> new_vtable)300 inline void Class::SetVTable(ObjPtr<PointerArray> new_vtable) {
301   SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable);
302 }
303 
304 template<VerifyObjectFlags kVerifyFlags>
ShouldHaveImt()305 inline bool Class::ShouldHaveImt() {
306   return ShouldHaveEmbeddedVTable<kVerifyFlags>();
307 }
308 
309 template<VerifyObjectFlags kVerifyFlags>
ShouldHaveEmbeddedVTable()310 inline bool Class::ShouldHaveEmbeddedVTable() {
311   return IsInstantiable<kVerifyFlags>();
312 }
313 
HasVTable()314 inline bool Class::HasVTable() {
315   // No read barrier is needed for comparing with null. See ReadBarrierOption.
316   return GetVTable<kDefaultVerifyFlags, kWithoutReadBarrier>() != nullptr ||
317          ShouldHaveEmbeddedVTable();
318 }
319 
320 template<VerifyObjectFlags kVerifyFlags>
GetVTableLength()321 inline int32_t Class::GetVTableLength() {
322   if (ShouldHaveEmbeddedVTable<kVerifyFlags>()) {
323     return GetEmbeddedVTableLength();
324   }
325   // We do not need a read barrier here as the length is constant,
326   // both from-space and to-space vtables shall yield the same result.
327   ObjPtr<PointerArray> vtable = GetVTable<kVerifyFlags, kWithoutReadBarrier>();
328   return vtable != nullptr ? vtable->GetLength() : 0;
329 }
330 
331 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetVTableEntry(uint32_t i,PointerSize pointer_size)332 inline ArtMethod* Class::GetVTableEntry(uint32_t i, PointerSize pointer_size) {
333   if (ShouldHaveEmbeddedVTable<kVerifyFlags>()) {
334     return GetEmbeddedVTableEntry(i, pointer_size);
335   }
336   ObjPtr<PointerArray> vtable = GetVTable<kVerifyFlags, kReadBarrierOption>();
337   DCHECK(vtable != nullptr);
338   return vtable->GetElementPtrSize<ArtMethod*, kVerifyFlags>(i, pointer_size);
339 }
340 
341 template<VerifyObjectFlags kVerifyFlags>
GetEmbeddedVTableLength()342 inline int32_t Class::GetEmbeddedVTableLength() {
343   return GetField32<kVerifyFlags>(MemberOffset(EmbeddedVTableLengthOffset()));
344 }
345 
SetEmbeddedVTableLength(int32_t len)346 inline void Class::SetEmbeddedVTableLength(int32_t len) {
347   SetField32<false>(MemberOffset(EmbeddedVTableLengthOffset()), len);
348 }
349 
GetImt(PointerSize pointer_size)350 inline ImTable* Class::GetImt(PointerSize pointer_size) {
351   return GetFieldPtrWithSize<ImTable*>(ImtPtrOffset(pointer_size), pointer_size);
352 }
353 
SetImt(ImTable * imt,PointerSize pointer_size)354 inline void Class::SetImt(ImTable* imt, PointerSize pointer_size) {
355   return SetFieldPtrWithSize<false>(ImtPtrOffset(pointer_size), imt, pointer_size);
356 }
357 
EmbeddedVTableEntryOffset(uint32_t i,PointerSize pointer_size)358 inline MemberOffset Class::EmbeddedVTableEntryOffset(uint32_t i, PointerSize pointer_size) {
359   return MemberOffset(
360       EmbeddedVTableOffset(pointer_size).Uint32Value() + i * VTableEntrySize(pointer_size));
361 }
362 
GetEmbeddedVTableEntry(uint32_t i,PointerSize pointer_size)363 inline ArtMethod* Class::GetEmbeddedVTableEntry(uint32_t i, PointerSize pointer_size) {
364   return GetFieldPtrWithSize<ArtMethod*>(EmbeddedVTableEntryOffset(i, pointer_size), pointer_size);
365 }
366 
SetEmbeddedVTableEntryUnchecked(uint32_t i,ArtMethod * method,PointerSize pointer_size)367 inline void Class::SetEmbeddedVTableEntryUnchecked(
368     uint32_t i, ArtMethod* method, PointerSize pointer_size) {
369   SetFieldPtrWithSize<false>(EmbeddedVTableEntryOffset(i, pointer_size), method, pointer_size);
370 }
371 
SetEmbeddedVTableEntry(uint32_t i,ArtMethod * method,PointerSize pointer_size)372 inline void Class::SetEmbeddedVTableEntry(uint32_t i, ArtMethod* method, PointerSize pointer_size) {
373   ObjPtr<PointerArray> vtable = GetVTableDuringLinking();
374   CHECK_EQ(method, vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size));
375   SetEmbeddedVTableEntryUnchecked(i, method, pointer_size);
376 }
377 
Implements(ObjPtr<Class> klass)378 inline bool Class::Implements(ObjPtr<Class> klass) {
379   DCHECK(klass != nullptr);
380   DCHECK(klass->IsInterface()) << PrettyClass();
381   // All interfaces implemented directly and by our superclass, and
382   // recursively all super-interfaces of those interfaces, are listed
383   // in iftable_, so we can just do a linear scan through that.
384   int32_t iftable_count = GetIfTableCount();
385   ObjPtr<IfTable> iftable = GetIfTable();
386   for (int32_t i = 0; i < iftable_count; i++) {
387     if (iftable->GetInterface(i) == klass) {
388       return true;
389     }
390   }
391   return false;
392 }
393 
394 template<VerifyObjectFlags kVerifyFlags>
IsVariableSize()395 inline bool Class::IsVariableSize() {
396   // Classes, arrays, and strings vary in size, and so the object_size_ field cannot
397   // be used to Get their instance size
398   return IsClassClass<kVerifyFlags>() ||
399          IsArrayClass<kVerifyFlags>() ||
400          IsStringClass<kVerifyFlags>();
401 }
402 
SetObjectSize(uint32_t new_object_size)403 inline void Class::SetObjectSize(uint32_t new_object_size) {
404   DCHECK(!IsVariableSize());
405   // Not called within a transaction.
406   return SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), new_object_size);
407 }
408 
409 // Determine whether "this" is assignable from "src", where both of these
410 // are array classes.
411 //
412 // Consider an array class, e.g. Y[][], where Y is a subclass of X.
413 //   Y[][]            = Y[][] --> true (identity)
414 //   X[][]            = Y[][] --> true (element superclass)
415 //   Y                = Y[][] --> false
416 //   Y[]              = Y[][] --> false
417 //   Object           = Y[][] --> true (everything is an object)
418 //   Object[]         = Y[][] --> true
419 //   Object[][]       = Y[][] --> true
420 //   Object[][][]     = Y[][] --> false (too many []s)
421 //   Serializable     = Y[][] --> true (all arrays are Serializable)
422 //   Serializable[]   = Y[][] --> true
423 //   Serializable[][] = Y[][] --> false (unless Y is Serializable)
424 //
425 // Don't forget about primitive types.
426 //   Object[]         = int[] --> false
427 //
IsArrayAssignableFromArray(ObjPtr<Class> src)428 inline bool Class::IsArrayAssignableFromArray(ObjPtr<Class> src) {
429   DCHECK(IsArrayClass()) << PrettyClass();
430   DCHECK(src->IsArrayClass()) << src->PrettyClass();
431   return GetComponentType()->IsAssignableFrom(src->GetComponentType());
432 }
433 
IsAssignableFromArray(ObjPtr<Class> src)434 inline bool Class::IsAssignableFromArray(ObjPtr<Class> src) {
435   DCHECK(!IsInterface()) << PrettyClass();  // handled first in IsAssignableFrom
436   DCHECK(src->IsArrayClass()) << src->PrettyClass();
437   if (!IsArrayClass()) {
438     // If "this" is not also an array, it must be Object.
439     // src's super should be java_lang_Object, since it is an array.
440     ObjPtr<Class> java_lang_Object = src->GetSuperClass();
441     DCHECK(java_lang_Object != nullptr) << src->PrettyClass();
442     DCHECK(java_lang_Object->GetSuperClass() == nullptr) << src->PrettyClass();
443     return this == java_lang_Object;
444   }
445   return IsArrayAssignableFromArray(src);
446 }
447 
448 template <bool throw_on_failure>
ResolvedFieldAccessTest(ObjPtr<Class> access_to,ArtField * field,ObjPtr<DexCache> dex_cache,uint32_t field_idx)449 inline bool Class::ResolvedFieldAccessTest(ObjPtr<Class> access_to,
450                                            ArtField* field,
451                                            ObjPtr<DexCache> dex_cache,
452                                            uint32_t field_idx) {
453   DCHECK(dex_cache != nullptr);
454   if (UNLIKELY(!this->CanAccess(access_to))) {
455     // The referrer class can't access the field's declaring class but may still be able
456     // to access the field if the FieldId specifies an accessible subclass of the declaring
457     // class rather than the declaring class itself.
458     dex::TypeIndex class_idx = dex_cache->GetDexFile()->GetFieldId(field_idx).class_idx_;
459     // The referenced class has already been resolved with the field, but may not be in the dex
460     // cache. Use LookupResolveType here to search the class table if it is not in the dex cache.
461     // should be no thread suspension due to the class being resolved.
462     ObjPtr<Class> dex_access_to = Runtime::Current()->GetClassLinker()->LookupResolvedType(
463         class_idx,
464         dex_cache,
465         access_to->GetClassLoader());
466     DCHECK(dex_access_to != nullptr);
467     if (UNLIKELY(!this->CanAccess(dex_access_to))) {
468       if (throw_on_failure) {
469         ThrowIllegalAccessErrorClass(this, dex_access_to);
470       }
471       return false;
472     }
473   }
474   if (LIKELY(this->CanAccessMember(access_to, field->GetAccessFlags()))) {
475     return true;
476   }
477   if (throw_on_failure) {
478     ThrowIllegalAccessErrorField(this, field);
479   }
480   return false;
481 }
482 
483 template <bool throw_on_failure>
ResolvedMethodAccessTest(ObjPtr<Class> access_to,ArtMethod * method,ObjPtr<DexCache> dex_cache,uint32_t method_idx,InvokeType throw_invoke_type)484 inline bool Class::ResolvedMethodAccessTest(ObjPtr<Class> access_to,
485                                             ArtMethod* method,
486                                             ObjPtr<DexCache> dex_cache,
487                                             uint32_t method_idx,
488                                             InvokeType throw_invoke_type) {
489   DCHECK(throw_on_failure || throw_invoke_type == kStatic);
490   DCHECK(dex_cache != nullptr);
491   if (UNLIKELY(!this->CanAccess(access_to))) {
492     // The referrer class can't access the method's declaring class but may still be able
493     // to access the method if the MethodId specifies an accessible subclass of the declaring
494     // class rather than the declaring class itself.
495     dex::TypeIndex class_idx = dex_cache->GetDexFile()->GetMethodId(method_idx).class_idx_;
496     // The referenced class has already been resolved with the method, but may not be in the dex
497     // cache.
498     ObjPtr<Class> dex_access_to = Runtime::Current()->GetClassLinker()->LookupResolvedType(
499         class_idx,
500         dex_cache,
501         access_to->GetClassLoader());
502     DCHECK(dex_access_to != nullptr);
503     if (UNLIKELY(!this->CanAccess(dex_access_to))) {
504       if (throw_on_failure) {
505         ThrowIllegalAccessErrorClassForMethodDispatch(this,
506                                                       dex_access_to,
507                                                       method,
508                                                       throw_invoke_type);
509       }
510       return false;
511     }
512   }
513   if (LIKELY(this->CanAccessMember(access_to, method->GetAccessFlags()))) {
514     return true;
515   }
516   if (throw_on_failure) {
517     ThrowIllegalAccessErrorMethod(this, method);
518   }
519   return false;
520 }
521 
CanAccessResolvedField(ObjPtr<Class> access_to,ArtField * field,ObjPtr<DexCache> dex_cache,uint32_t field_idx)522 inline bool Class::CanAccessResolvedField(ObjPtr<Class> access_to,
523                                           ArtField* field,
524                                           ObjPtr<DexCache> dex_cache,
525                                           uint32_t field_idx) {
526   return ResolvedFieldAccessTest<false>(access_to, field, dex_cache, field_idx);
527 }
528 
CheckResolvedFieldAccess(ObjPtr<Class> access_to,ArtField * field,ObjPtr<DexCache> dex_cache,uint32_t field_idx)529 inline bool Class::CheckResolvedFieldAccess(ObjPtr<Class> access_to,
530                                             ArtField* field,
531                                             ObjPtr<DexCache> dex_cache,
532                                             uint32_t field_idx) {
533   return ResolvedFieldAccessTest<true>(access_to, field, dex_cache, field_idx);
534 }
535 
CanAccessResolvedMethod(ObjPtr<Class> access_to,ArtMethod * method,ObjPtr<DexCache> dex_cache,uint32_t method_idx)536 inline bool Class::CanAccessResolvedMethod(ObjPtr<Class> access_to,
537                                            ArtMethod* method,
538                                            ObjPtr<DexCache> dex_cache,
539                                            uint32_t method_idx) {
540   return ResolvedMethodAccessTest<false>(access_to, method, dex_cache, method_idx, kStatic);
541 }
542 
CheckResolvedMethodAccess(ObjPtr<Class> access_to,ArtMethod * method,ObjPtr<DexCache> dex_cache,uint32_t method_idx,InvokeType throw_invoke_type)543 inline bool Class::CheckResolvedMethodAccess(ObjPtr<Class> access_to,
544                                              ArtMethod* method,
545                                              ObjPtr<DexCache> dex_cache,
546                                              uint32_t method_idx,
547                                              InvokeType throw_invoke_type) {
548   return ResolvedMethodAccessTest<true>(
549       access_to, method, dex_cache, method_idx, throw_invoke_type);
550 }
551 
IsSubClass(ObjPtr<Class> klass)552 inline bool Class::IsSubClass(ObjPtr<Class> klass) {
553   // Since the SubtypeCheck::IsSubtypeOf needs to lookup the Depth,
554   // it is always O(Depth) in terms of speed to do the check.
555   //
556   // So always do the "slow" linear scan in normal release builds.
557   //
558   // Future note: If we could have the depth in O(1) we could use the 'fast'
559   // method instead as it avoids a loop and a read barrier.
560   bool result = false;
561   DCHECK(!IsInterface()) << PrettyClass();
562   DCHECK(!IsArrayClass()) << PrettyClass();
563   ObjPtr<Class> current = this;
564   do {
565     if (current == klass) {
566       result = true;
567       break;
568     }
569     current = current->GetSuperClass();
570   } while (current != nullptr);
571 
572   if (kIsDebugBuild && kBitstringSubtypeCheckEnabled) {
573     ObjPtr<mirror::Class> dis(this);
574 
575     SubtypeCheckInfo::Result sc_result = SubtypeCheck<ObjPtr<Class>>::IsSubtypeOf(dis, klass);
576     if (sc_result != SubtypeCheckInfo::kUnknownSubtypeOf) {
577       // Note: The "kUnknownSubTypeOf" can be avoided if and only if:
578       //   SubtypeCheck::EnsureInitialized(source)
579       //       happens-before source.IsSubClass(target)
580       //   SubtypeCheck::EnsureAssigned(target).GetState() == Assigned
581       //       happens-before source.IsSubClass(target)
582       //
583       // When code generated by optimizing compiler executes this operation, both
584       // happens-before are guaranteed, so there is no fallback code there.
585       SubtypeCheckInfo::Result expected_result =
586           result ? SubtypeCheckInfo::kSubtypeOf : SubtypeCheckInfo::kNotSubtypeOf;
587       DCHECK_EQ(expected_result, sc_result)
588           << "source: " << PrettyClass() << "target: " << klass->PrettyClass();
589     }
590   }
591 
592   return result;
593 }
594 
FindVirtualMethodForInterface(ArtMethod * method,PointerSize pointer_size)595 inline ArtMethod* Class::FindVirtualMethodForInterface(ArtMethod* method,
596                                                        PointerSize pointer_size) {
597   ObjPtr<Class> declaring_class = method->GetDeclaringClass();
598   DCHECK(declaring_class != nullptr) << PrettyClass();
599   if (UNLIKELY(!declaring_class->IsInterface())) {
600     DCHECK(declaring_class->IsObjectClass()) << method->PrettyMethod();
601     DCHECK(method->IsPublic() && !method->IsStatic());
602     return FindVirtualMethodForVirtual(method, pointer_size);
603   }
604   DCHECK(!method->IsCopied());
605   // TODO cache to improve lookup speed
606   const int32_t iftable_count = GetIfTableCount();
607   ObjPtr<IfTable> iftable = GetIfTable();
608   for (int32_t i = 0; i < iftable_count; i++) {
609     if (iftable->GetInterface(i) == declaring_class) {
610       return iftable->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>(
611           method->GetMethodIndex(), pointer_size);
612     }
613   }
614   return nullptr;
615 }
616 
FindVirtualMethodForVirtual(ArtMethod * method,PointerSize pointer_size)617 inline ArtMethod* Class::FindVirtualMethodForVirtual(ArtMethod* method, PointerSize pointer_size) {
618   // Only miranda or default methods may come from interfaces and be used as a virtual.
619   DCHECK(!method->GetDeclaringClass()->IsInterface() || method->IsDefault() || method->IsMiranda());
620   // The argument method may from a super class.
621   // Use the index to a potentially overridden one for this instance's class.
622   return GetVTableEntry(method->GetMethodIndex(), pointer_size);
623 }
624 
FindVirtualMethodForSuper(ArtMethod * method,PointerSize pointer_size)625 inline ArtMethod* Class::FindVirtualMethodForSuper(ArtMethod* method, PointerSize pointer_size) {
626   DCHECK(!method->GetDeclaringClass()->IsInterface());
627   return GetSuperClass()->GetVTableEntry(method->GetMethodIndex(), pointer_size);
628 }
629 
FindVirtualMethodForVirtualOrInterface(ArtMethod * method,PointerSize pointer_size)630 inline ArtMethod* Class::FindVirtualMethodForVirtualOrInterface(ArtMethod* method,
631                                                                 PointerSize pointer_size) {
632   if (method->IsDirect()) {
633     return method;
634   }
635   if (method->GetDeclaringClass()->IsInterface() && !method->IsCopied()) {
636     return FindVirtualMethodForInterface(method, pointer_size);
637   }
638   return FindVirtualMethodForVirtual(method, pointer_size);
639 }
640 
641 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetIfTable()642 inline ObjPtr<IfTable> Class::GetIfTable() {
643   ObjPtr<IfTable> ret = GetFieldObject<IfTable, kVerifyFlags, kReadBarrierOption>(IfTableOffset());
644   DCHECK(ret != nullptr) << PrettyClass(this);
645   return ret;
646 }
647 
648 template<VerifyObjectFlags kVerifyFlags>
GetIfTableCount()649 inline int32_t Class::GetIfTableCount() {
650   // We do not need a read barrier here as the length is constant,
651   // both from-space and to-space iftables shall yield the same result.
652   return GetIfTable<kVerifyFlags, kWithoutReadBarrier>()->Count();
653 }
654 
SetIfTable(ObjPtr<IfTable> new_iftable)655 inline void Class::SetIfTable(ObjPtr<IfTable> new_iftable) {
656   DCHECK(new_iftable != nullptr) << PrettyClass(this);
657   SetFieldObject<false>(IfTableOffset(), new_iftable);
658 }
659 
GetIFieldsPtr()660 inline LengthPrefixedArray<ArtField>* Class::GetIFieldsPtr() {
661   DCHECK(IsLoaded() || IsErroneous()) << GetStatus();
662   return GetFieldPtr<LengthPrefixedArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_));
663 }
664 
665 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetFirstReferenceInstanceFieldOffset()666 inline MemberOffset Class::GetFirstReferenceInstanceFieldOffset() {
667   ObjPtr<Class> super_class = GetSuperClass<kVerifyFlags, kReadBarrierOption>();
668   return (super_class != nullptr)
669       ? MemberOffset(RoundUp(super_class->GetObjectSize<kVerifyFlags>(), kHeapReferenceSize))
670       : ClassOffset();
671 }
672 
673 template <VerifyObjectFlags kVerifyFlags>
GetFirstReferenceStaticFieldOffset(PointerSize pointer_size)674 inline MemberOffset Class::GetFirstReferenceStaticFieldOffset(PointerSize pointer_size) {
675   DCHECK(IsResolved<kVerifyFlags>());
676   uint32_t base = sizeof(Class);  // Static fields come after the class.
677   if (ShouldHaveEmbeddedVTable<kVerifyFlags>()) {
678     // Static fields come after the embedded tables.
679     base = Class::ComputeClassSize(
680         true, GetEmbeddedVTableLength<kVerifyFlags>(), 0, 0, 0, 0, 0, pointer_size);
681   }
682   return MemberOffset(base);
683 }
684 
GetFirstReferenceStaticFieldOffsetDuringLinking(PointerSize pointer_size)685 inline MemberOffset Class::GetFirstReferenceStaticFieldOffsetDuringLinking(
686     PointerSize pointer_size) {
687   DCHECK(IsLoaded());
688   uint32_t base = sizeof(Class);  // Static fields come after the class.
689   if (ShouldHaveEmbeddedVTable()) {
690     // Static fields come after the embedded tables.
691     base = Class::ComputeClassSize(true, GetVTableDuringLinking()->GetLength(),
692                                            0, 0, 0, 0, 0, pointer_size);
693   }
694   return MemberOffset(base);
695 }
696 
SetIFieldsPtr(LengthPrefixedArray<ArtField> * new_ifields)697 inline void Class::SetIFieldsPtr(LengthPrefixedArray<ArtField>* new_ifields) {
698   DCHECK(GetIFieldsPtrUnchecked() == nullptr);
699   return SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields);
700 }
701 
SetIFieldsPtrUnchecked(LengthPrefixedArray<ArtField> * new_ifields)702 inline void Class::SetIFieldsPtrUnchecked(LengthPrefixedArray<ArtField>* new_ifields) {
703   SetFieldPtr<false, true, kVerifyNone>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields);
704 }
705 
GetSFieldsPtrUnchecked()706 inline LengthPrefixedArray<ArtField>* Class::GetSFieldsPtrUnchecked() {
707   return GetFieldPtr<LengthPrefixedArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_));
708 }
709 
GetIFieldsPtrUnchecked()710 inline LengthPrefixedArray<ArtField>* Class::GetIFieldsPtrUnchecked() {
711   return GetFieldPtr<LengthPrefixedArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_));
712 }
713 
GetSFieldsPtr()714 inline LengthPrefixedArray<ArtField>* Class::GetSFieldsPtr() {
715   DCHECK(IsLoaded() || IsErroneous()) << GetStatus();
716   return GetSFieldsPtrUnchecked();
717 }
718 
SetSFieldsPtr(LengthPrefixedArray<ArtField> * new_sfields)719 inline void Class::SetSFieldsPtr(LengthPrefixedArray<ArtField>* new_sfields) {
720   DCHECK((IsRetired() && new_sfields == nullptr) ||
721          GetFieldPtr<ArtField*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_)) == nullptr);
722   SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields);
723 }
724 
SetSFieldsPtrUnchecked(LengthPrefixedArray<ArtField> * new_sfields)725 inline void Class::SetSFieldsPtrUnchecked(LengthPrefixedArray<ArtField>* new_sfields) {
726   SetFieldPtr<false, true, kVerifyNone>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields);
727 }
728 
GetStaticField(uint32_t i)729 inline ArtField* Class::GetStaticField(uint32_t i) {
730   return &GetSFieldsPtr()->At(i);
731 }
732 
GetInstanceField(uint32_t i)733 inline ArtField* Class::GetInstanceField(uint32_t i) {
734   return &GetIFieldsPtr()->At(i);
735 }
736 
737 template<VerifyObjectFlags kVerifyFlags>
GetReferenceInstanceOffsets()738 inline uint32_t Class::GetReferenceInstanceOffsets() {
739   DCHECK(IsResolved<kVerifyFlags>() || IsErroneous<kVerifyFlags>());
740   return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_));
741 }
742 
SetClinitThreadId(pid_t new_clinit_thread_id)743 inline void Class::SetClinitThreadId(pid_t new_clinit_thread_id) {
744   SetField32Transaction(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), new_clinit_thread_id);
745 }
746 
747 template<VerifyObjectFlags kVerifyFlags,
748          ReadBarrierOption kReadBarrierOption>
GetName()749 inline ObjPtr<String> Class::GetName() {
750   return GetFieldObject<String, kVerifyFlags, kReadBarrierOption>(
751       OFFSET_OF_OBJECT_MEMBER(Class, name_));
752 }
753 
SetName(ObjPtr<String> name)754 inline void Class::SetName(ObjPtr<String> name) {
755   SetFieldObjectTransaction(OFFSET_OF_OBJECT_MEMBER(Class, name_), name);
756 }
757 
758 template<VerifyObjectFlags kVerifyFlags>
GetPrimitiveType()759 inline Primitive::Type Class::GetPrimitiveType() {
760   static_assert(sizeof(Primitive::Type) == sizeof(int32_t),
761                 "art::Primitive::Type and int32_t have different sizes.");
762   int32_t v32 = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_));
763   Primitive::Type type = static_cast<Primitive::Type>(v32 & kPrimitiveTypeMask);
764   DCHECK_EQ(static_cast<size_t>(v32 >> kPrimitiveTypeSizeShiftShift),
765             Primitive::ComponentSizeShift(type));
766   return type;
767 }
768 
769 template<VerifyObjectFlags kVerifyFlags>
GetPrimitiveTypeSizeShift()770 inline size_t Class::GetPrimitiveTypeSizeShift() {
771   static_assert(sizeof(Primitive::Type) == sizeof(int32_t),
772                 "art::Primitive::Type and int32_t have different sizes.");
773   int32_t v32 = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_));
774   size_t size_shift = static_cast<Primitive::Type>(v32 >> kPrimitiveTypeSizeShiftShift);
775   DCHECK_EQ(size_shift,
776             Primitive::ComponentSizeShift(static_cast<Primitive::Type>(v32 & kPrimitiveTypeMask)));
777   return size_shift;
778 }
779 
ComputeClassSize(bool has_embedded_vtable,uint32_t num_vtable_entries,uint32_t num_8bit_static_fields,uint32_t num_16bit_static_fields,uint32_t num_32bit_static_fields,uint32_t num_64bit_static_fields,uint32_t num_ref_static_fields,PointerSize pointer_size)780 inline uint32_t Class::ComputeClassSize(bool has_embedded_vtable,
781                                         uint32_t num_vtable_entries,
782                                         uint32_t num_8bit_static_fields,
783                                         uint32_t num_16bit_static_fields,
784                                         uint32_t num_32bit_static_fields,
785                                         uint32_t num_64bit_static_fields,
786                                         uint32_t num_ref_static_fields,
787                                         PointerSize pointer_size) {
788   // Space used by java.lang.Class and its instance fields.
789   uint32_t size = sizeof(Class);
790   // Space used by embedded tables.
791   if (has_embedded_vtable) {
792     size = RoundUp(size + sizeof(uint32_t), static_cast<size_t>(pointer_size));
793     size += static_cast<size_t>(pointer_size);  // size of pointer to IMT
794     size += num_vtable_entries * VTableEntrySize(pointer_size);
795   }
796 
797   // Space used by reference statics.
798   size += num_ref_static_fields * kHeapReferenceSize;
799   if (!IsAligned<8>(size) && num_64bit_static_fields > 0) {
800     uint32_t gap = 8 - (size & 0x7);
801     size += gap;  // will be padded
802     // Shuffle 4-byte fields forward.
803     while (gap >= sizeof(uint32_t) && num_32bit_static_fields != 0) {
804       --num_32bit_static_fields;
805       gap -= sizeof(uint32_t);
806     }
807     // Shuffle 2-byte fields forward.
808     while (gap >= sizeof(uint16_t) && num_16bit_static_fields != 0) {
809       --num_16bit_static_fields;
810       gap -= sizeof(uint16_t);
811     }
812     // Shuffle byte fields forward.
813     while (gap >= sizeof(uint8_t) && num_8bit_static_fields != 0) {
814       --num_8bit_static_fields;
815       gap -= sizeof(uint8_t);
816     }
817   }
818   // Guaranteed to be at least 4 byte aligned. No need for further alignments.
819   // Space used for primitive static fields.
820   size += num_8bit_static_fields * sizeof(uint8_t) + num_16bit_static_fields * sizeof(uint16_t) +
821       num_32bit_static_fields * sizeof(uint32_t) + num_64bit_static_fields * sizeof(uint64_t);
822   return size;
823 }
824 
825 template<VerifyObjectFlags kVerifyFlags>
IsClassClass()826 inline bool Class::IsClassClass() {
827   // OK to look at from-space copies since java.lang.Class.class is non-moveable
828   // (even when running without boot image, see ClassLinker::InitWithoutImage())
829   // and we're reading it for comparison only. See ReadBarrierOption.
830   ObjPtr<Class> java_lang_Class = GetClass<kVerifyFlags, kWithoutReadBarrier>();
831   return this == java_lang_Class;
832 }
833 
GetDexFile()834 inline const DexFile& Class::GetDexFile() {
835   // From-space version is the same as the to-space version since the dex file never changes.
836   // Avoiding the read barrier here is important to prevent recursive AssertToSpaceInvariant issues
837   // from PrettyTypeOf.
838   return *GetDexCache<kDefaultVerifyFlags, kWithoutReadBarrier>()->GetDexFile();
839 }
840 
DescriptorEquals(const char * match)841 inline bool Class::DescriptorEquals(const char* match) {
842   ObjPtr<mirror::Class> klass = this;
843   while (klass->IsArrayClass()) {
844     if (match[0] != '[') {
845       return false;
846     }
847     ++match;
848     klass = klass->GetComponentType();
849   }
850   if (klass->IsPrimitive()) {
851     return strcmp(Primitive::Descriptor(klass->GetPrimitiveType()), match) == 0;
852   } else if (klass->IsProxyClass()) {
853     return klass->ProxyDescriptorEquals(match);
854   } else {
855     const DexFile& dex_file = klass->GetDexFile();
856     const dex::TypeId& type_id = dex_file.GetTypeId(klass->GetDexTypeIndex());
857     return strcmp(dex_file.GetTypeDescriptor(type_id), match) == 0;
858   }
859 }
860 
AssertInitializedOrInitializingInThread(Thread * self)861 inline void Class::AssertInitializedOrInitializingInThread(Thread* self) {
862   if (kIsDebugBuild && !IsInitialized()) {
863     CHECK(IsInitializing()) << PrettyClass() << " is not initializing: " << GetStatus();
864     CHECK_EQ(GetClinitThreadId(), self->GetTid())
865         << PrettyClass() << " is initializing in a different thread";
866   }
867 }
868 
GetProxyInterfaces()869 inline ObjPtr<ObjectArray<Class>> Class::GetProxyInterfaces() {
870   CHECK(IsProxyClass());
871   // First static field.
872   ArtField* field = GetStaticField(0);
873   DCHECK_STREQ(field->GetName(), "interfaces");
874   MemberOffset field_offset = field->GetOffset();
875   return GetFieldObject<ObjectArray<Class>>(field_offset);
876 }
877 
GetProxyThrows()878 inline ObjPtr<ObjectArray<ObjectArray<Class>>> Class::GetProxyThrows() {
879   CHECK(IsProxyClass());
880   // Second static field.
881   ArtField* field = GetStaticField(1);
882   DCHECK_STREQ(field->GetName(), "throws");
883   MemberOffset field_offset = field->GetOffset();
884   return GetFieldObject<ObjectArray<ObjectArray<Class>>>(field_offset);
885 }
886 
IsBootStrapClassLoaded()887 inline bool Class::IsBootStrapClassLoaded() {
888   // No read barrier is needed for comparing with null. See ReadBarrierOption.
889   return GetClassLoader<kDefaultVerifyFlags, kWithoutReadBarrier>() == nullptr;
890 }
891 
operator()892 inline void Class::InitializeClassVisitor::operator()(ObjPtr<Object> obj,
893                                                       size_t usable_size) const {
894   DCHECK_LE(class_size_, usable_size);
895   // Avoid AsClass as object is not yet in live bitmap or allocation stack.
896   ObjPtr<Class> klass = ObjPtr<Class>::DownCast(obj);
897   klass->SetClassSize(class_size_);
898   klass->SetPrimitiveType(Primitive::kPrimNot);  // Default to not being primitive.
899   klass->SetDexClassDefIndex(DexFile::kDexNoIndex16);  // Default to no valid class def index.
900   klass->SetDexTypeIndex(dex::TypeIndex(DexFile::kDexNoIndex16));  // Default to no valid type
901                                                                    // index.
902   // Default to force slow path until initialized.
903   klass->SetObjectSizeAllocFastPath(std::numeric_limits<uint32_t>::max());
904 }
905 
SetAccessFlags(uint32_t new_access_flags)906 inline void Class::SetAccessFlags(uint32_t new_access_flags) {
907   if (kIsDebugBuild) {
908     SetAccessFlagsDCheck(new_access_flags);
909   }
910   // Called inside a transaction when setting pre-verified flag during boot image compilation.
911   if (Runtime::Current()->IsActiveTransaction()) {
912     SetField32<true>(AccessFlagsOffset(), new_access_flags);
913   } else {
914     SetField32<false>(AccessFlagsOffset(), new_access_flags);
915   }
916 }
917 
SetClassFlags(uint32_t new_flags)918 inline void Class::SetClassFlags(uint32_t new_flags) {
919   if (Runtime::Current()->IsActiveTransaction()) {
920     SetField32<true>(OFFSET_OF_OBJECT_MEMBER(Class, class_flags_), new_flags);
921   } else {
922     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_flags_), new_flags);
923   }
924 }
925 
NumDirectInterfaces()926 inline uint32_t Class::NumDirectInterfaces() {
927   if (IsPrimitive()) {
928     return 0;
929   } else if (IsArrayClass()) {
930     return 2;
931   } else if (IsProxyClass()) {
932     ObjPtr<ObjectArray<Class>> interfaces = GetProxyInterfaces();
933     return interfaces != nullptr ? interfaces->GetLength() : 0;
934   } else {
935     const dex::TypeList* interfaces = GetInterfaceTypeList();
936     if (interfaces == nullptr) {
937       return 0;
938     } else {
939       return interfaces->Size();
940     }
941   }
942 }
943 
GetDirectMethods(PointerSize pointer_size)944 inline ArraySlice<ArtMethod> Class::GetDirectMethods(PointerSize pointer_size) {
945   CheckPointerSize(pointer_size);
946   return GetDirectMethodsSliceUnchecked(pointer_size);
947 }
948 
GetDeclaredMethods(PointerSize pointer_size)949 inline ArraySlice<ArtMethod> Class::GetDeclaredMethods(PointerSize pointer_size) {
950   return GetDeclaredMethodsSliceUnchecked(pointer_size);
951 }
952 
GetDeclaredVirtualMethods(PointerSize pointer_size)953 inline ArraySlice<ArtMethod> Class::GetDeclaredVirtualMethods(PointerSize pointer_size) {
954   return GetDeclaredVirtualMethodsSliceUnchecked(pointer_size);
955 }
956 
GetVirtualMethods(PointerSize pointer_size)957 inline ArraySlice<ArtMethod> Class::GetVirtualMethods(PointerSize pointer_size) {
958   CheckPointerSize(pointer_size);
959   return GetVirtualMethodsSliceUnchecked(pointer_size);
960 }
961 
GetCopiedMethods(PointerSize pointer_size)962 inline ArraySlice<ArtMethod> Class::GetCopiedMethods(PointerSize pointer_size) {
963   CheckPointerSize(pointer_size);
964   return GetCopiedMethodsSliceUnchecked(pointer_size);
965 }
966 
967 
GetMethods(PointerSize pointer_size)968 inline ArraySlice<ArtMethod> Class::GetMethods(PointerSize pointer_size) {
969   CheckPointerSize(pointer_size);
970   LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
971   return GetMethodsSliceRangeUnchecked(methods, pointer_size, 0u, NumMethods(methods));
972 }
973 
GetIFields()974 inline IterationRange<StrideIterator<ArtField>> Class::GetIFields() {
975   return MakeIterationRangeFromLengthPrefixedArray(GetIFieldsPtr());
976 }
977 
GetSFields()978 inline IterationRange<StrideIterator<ArtField>> Class::GetSFields() {
979   return MakeIterationRangeFromLengthPrefixedArray(GetSFieldsPtr());
980 }
981 
GetIFieldsUnchecked()982 inline IterationRange<StrideIterator<ArtField>> Class::GetIFieldsUnchecked() {
983   return MakeIterationRangeFromLengthPrefixedArray(GetIFieldsPtrUnchecked());
984 }
985 
GetSFieldsUnchecked()986 inline IterationRange<StrideIterator<ArtField>> Class::GetSFieldsUnchecked() {
987   return MakeIterationRangeFromLengthPrefixedArray(GetSFieldsPtrUnchecked());
988 }
989 
EmbeddedVTableOffset(PointerSize pointer_size)990 inline MemberOffset Class::EmbeddedVTableOffset(PointerSize pointer_size) {
991   return MemberOffset(ImtPtrOffset(pointer_size).Uint32Value() + static_cast<size_t>(pointer_size));
992 }
993 
CheckPointerSize(PointerSize pointer_size)994 inline void Class::CheckPointerSize(PointerSize pointer_size) {
995   DCHECK_EQ(pointer_size, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
996 }
997 
998 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
GetComponentType()999 inline ObjPtr<Class> Class::GetComponentType() {
1000   return GetFieldObject<Class, kVerifyFlags, kReadBarrierOption>(ComponentTypeOffset());
1001 }
1002 
SetComponentType(ObjPtr<Class> new_component_type)1003 inline void Class::SetComponentType(ObjPtr<Class> new_component_type) {
1004   DCHECK(GetComponentType() == nullptr);
1005   DCHECK(new_component_type != nullptr);
1006   // Component type is invariant: use non-transactional mode without check.
1007   SetFieldObject<false, false>(ComponentTypeOffset(), new_component_type);
1008 }
1009 
GetComponentSize()1010 inline size_t Class::GetComponentSize() {
1011   return 1U << GetComponentSizeShift();
1012 }
1013 
GetComponentSizeShift()1014 inline size_t Class::GetComponentSizeShift() {
1015   // No read barrier is needed for reading a constant primitive field through
1016   // constant reference field. See ReadBarrierOption.
1017   return GetComponentType<kDefaultVerifyFlags, kWithoutReadBarrier>()->GetPrimitiveTypeSizeShift();
1018 }
1019 
IsObjectClass()1020 inline bool Class::IsObjectClass() {
1021   // No read barrier is needed for comparing with null. See ReadBarrierOption.
1022   return !IsPrimitive() && GetSuperClass<kDefaultVerifyFlags, kWithoutReadBarrier>() == nullptr;
1023 }
1024 
IsInstantiableNonArray()1025 inline bool Class::IsInstantiableNonArray() {
1026   return !IsPrimitive() && !IsInterface() && !IsAbstract() && !IsArrayClass();
1027 }
1028 
1029 template<VerifyObjectFlags kVerifyFlags>
IsInstantiable()1030 bool Class::IsInstantiable() {
1031   return (!IsPrimitive<kVerifyFlags>() &&
1032           !IsInterface<kVerifyFlags>() &&
1033           !IsAbstract<kVerifyFlags>()) ||
1034       (IsAbstract<kVerifyFlags>() && IsArrayClass<kVerifyFlags>());
1035 }
1036 
1037 template<VerifyObjectFlags kVerifyFlags>
IsArrayClass()1038 inline bool Class::IsArrayClass() {
1039   // We do not need a read barrier for comparing with null.
1040   return GetComponentType<kVerifyFlags, kWithoutReadBarrier>() != nullptr;
1041 }
1042 
1043 template<VerifyObjectFlags kVerifyFlags>
IsObjectArrayClass()1044 inline bool Class::IsObjectArrayClass() {
1045   // We do not need a read barrier here as the primitive type is constant,
1046   // both from-space and to-space component type classes shall yield the same result.
1047   const ObjPtr<Class> component_type = GetComponentType<kVerifyFlags, kWithoutReadBarrier>();
1048   constexpr VerifyObjectFlags kNewFlags = RemoveThisFlags(kVerifyFlags);
1049   return component_type != nullptr && !component_type->IsPrimitive<kNewFlags>();
1050 }
1051 
1052 template<VerifyObjectFlags kVerifyFlags>
IsPrimitiveArray()1053 bool Class::IsPrimitiveArray() {
1054   // We do not need a read barrier here as the primitive type is constant,
1055   // both from-space and to-space component type classes shall yield the same result.
1056   const ObjPtr<Class> component_type = GetComponentType<kVerifyFlags, kWithoutReadBarrier>();
1057   constexpr VerifyObjectFlags kNewFlags = RemoveThisFlags(kVerifyFlags);
1058   return component_type != nullptr && component_type->IsPrimitive<kNewFlags>();
1059 }
1060 
IsAssignableFrom(ObjPtr<Class> src)1061 inline bool Class::IsAssignableFrom(ObjPtr<Class> src) {
1062   DCHECK(src != nullptr);
1063   if (this == src) {
1064     // Can always assign to things of the same type.
1065     return true;
1066   } else if (IsObjectClass()) {
1067     // Can assign any reference to java.lang.Object.
1068     return !src->IsPrimitive();
1069   } else if (IsInterface()) {
1070     return src->Implements(this);
1071   } else if (src->IsArrayClass()) {
1072     return IsAssignableFromArray(src);
1073   } else {
1074     return !src->IsInterface() && src->IsSubClass(this);
1075   }
1076 }
1077 
NumDirectMethods()1078 inline uint32_t Class::NumDirectMethods() {
1079   return GetVirtualMethodsStartOffset();
1080 }
1081 
NumDeclaredVirtualMethods()1082 inline uint32_t Class::NumDeclaredVirtualMethods() {
1083   return GetCopiedMethodsStartOffset() - GetVirtualMethodsStartOffset();
1084 }
1085 
NumVirtualMethods()1086 inline uint32_t Class::NumVirtualMethods() {
1087   return NumMethods() - GetVirtualMethodsStartOffset();
1088 }
1089 
NumInstanceFields()1090 inline uint32_t Class::NumInstanceFields() {
1091   LengthPrefixedArray<ArtField>* arr = GetIFieldsPtrUnchecked();
1092   return arr != nullptr ? arr->size() : 0u;
1093 }
1094 
NumStaticFields()1095 inline uint32_t Class::NumStaticFields() {
1096   LengthPrefixedArray<ArtField>* arr = GetSFieldsPtrUnchecked();
1097   return arr != nullptr ? arr->size() : 0u;
1098 }
1099 
1100 template <typename T, VerifyObjectFlags kVerifyFlags, typename Visitor>
FixupNativePointer(Class * dest,PointerSize pointer_size,const Visitor & visitor,MemberOffset member_offset)1101 inline void Class::FixupNativePointer(
1102     Class* dest, PointerSize pointer_size, const Visitor& visitor, MemberOffset member_offset) {
1103   void** address =
1104       reinterpret_cast<void**>(reinterpret_cast<uintptr_t>(dest) + member_offset.Uint32Value());
1105   T old_value = GetFieldPtrWithSize<T, kVerifyFlags>(member_offset, pointer_size);
1106   T new_value = visitor(old_value, address);
1107   if (old_value != new_value) {
1108     dest->SetFieldPtrWithSize</* kTransactionActive= */ false,
1109                               /* kCheckTransaction= */ true,
1110                               kVerifyNone>(member_offset, new_value, pointer_size);
1111   }
1112 }
1113 
1114 template <VerifyObjectFlags kVerifyFlags, typename Visitor>
FixupNativePointers(Class * dest,PointerSize pointer_size,const Visitor & visitor)1115 inline void Class::FixupNativePointers(Class* dest,
1116                                        PointerSize pointer_size,
1117                                        const Visitor& visitor) {
1118   // Update the field arrays.
1119   FixupNativePointer<LengthPrefixedArray<ArtField>*, kVerifyFlags>(
1120       dest, pointer_size, visitor, OFFSET_OF_OBJECT_MEMBER(Class, sfields_));
1121   FixupNativePointer<LengthPrefixedArray<ArtField>*, kVerifyFlags>(
1122       dest, pointer_size, visitor, OFFSET_OF_OBJECT_MEMBER(Class, ifields_));
1123   // Update method array.
1124   FixupNativePointer<LengthPrefixedArray<ArtMethod>*, kVerifyFlags>(
1125       dest, pointer_size, visitor, OFFSET_OF_OBJECT_MEMBER(Class, methods_));
1126   // Fix up embedded tables.
1127   if (!IsTemp<kVerifyNone>() && ShouldHaveEmbeddedVTable<kVerifyNone>()) {
1128     for (int32_t i = 0, count = GetEmbeddedVTableLength<kVerifyFlags>(); i < count; ++i) {
1129       FixupNativePointer<ArtMethod*, kVerifyFlags>(
1130           dest, pointer_size, visitor, EmbeddedVTableEntryOffset(i, pointer_size));
1131     }
1132   }
1133   if (!IsTemp<kVerifyNone>() && ShouldHaveImt<kVerifyNone>()) {
1134     FixupNativePointer<ImTable*, kVerifyFlags>(
1135         dest, pointer_size, visitor, ImtPtrOffset(pointer_size));
1136   }
1137 }
1138 
CanAccess(ObjPtr<Class> that)1139 inline bool Class::CanAccess(ObjPtr<Class> that) {
1140   return that->IsPublic() || this->IsInSamePackage(that);
1141 }
1142 
1143 
CanAccessMember(ObjPtr<Class> access_to,uint32_t member_flags)1144 inline bool Class::CanAccessMember(ObjPtr<Class> access_to, uint32_t member_flags) {
1145   // Classes can access all of their own members
1146   if (this == access_to) {
1147     return true;
1148   }
1149   // Public members are trivially accessible
1150   if (member_flags & kAccPublic) {
1151     return true;
1152   }
1153   // Private members are trivially not accessible
1154   if (member_flags & kAccPrivate) {
1155     return false;
1156   }
1157   // Check for protected access from a sub-class, which may or may not be in the same package.
1158   if (member_flags & kAccProtected) {
1159     if (!this->IsInterface() && this->IsSubClass(access_to)) {
1160       return true;
1161     }
1162   }
1163   // Allow protected access from other classes in the same package.
1164   return this->IsInSamePackage(access_to);
1165 }
1166 
CannotBeAssignedFromOtherTypes()1167 inline bool Class::CannotBeAssignedFromOtherTypes() {
1168   if (!IsArrayClass()) {
1169     return IsFinal();
1170   }
1171   ObjPtr<Class> component = GetComponentType();
1172   return component->IsPrimitive() || component->CannotBeAssignedFromOtherTypes();
1173 }
1174 
1175 template <bool kCheckTransaction>
SetClassLoader(ObjPtr<ClassLoader> new_class_loader)1176 inline void Class::SetClassLoader(ObjPtr<ClassLoader> new_class_loader) {
1177   if (kCheckTransaction && Runtime::Current()->IsActiveTransaction()) {
1178     SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader);
1179   } else {
1180     DCHECK(!Runtime::Current()->IsActiveTransaction());
1181     SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader);
1182   }
1183 }
1184 
SetRecursivelyInitialized()1185 inline void Class::SetRecursivelyInitialized() {
1186   DCHECK_EQ(GetLockOwnerThreadId(), Thread::Current()->GetThreadId());
1187   uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_));
1188   SetAccessFlags(flags | kAccRecursivelyInitialized);
1189 }
1190 
SetHasDefaultMethods()1191 inline void Class::SetHasDefaultMethods() {
1192   DCHECK_EQ(GetLockOwnerThreadId(), Thread::Current()->GetThreadId());
1193   uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_));
1194   SetAccessFlags(flags | kAccHasDefaultMethod);
1195 }
1196 
1197 }  // namespace mirror
1198 }  // namespace art
1199 
1200 #endif  // ART_RUNTIME_MIRROR_CLASS_INL_H_
1201