• 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_CLASS_H_
18 #define ART_RUNTIME_MIRROR_CLASS_H_
19 
20 #include <string_view>
21 
22 #include "base/bit_utils.h"
23 #include "base/casts.h"
24 #include "base/stride_iterator.h"
25 #include "class_flags.h"
26 #include "class_status.h"
27 #include "dex/dex_file_types.h"
28 #include "dex/modifiers.h"
29 #include "dex/primitive.h"
30 #include "gc/allocator_type.h"
31 #include "object.h"
32 #include "object_array.h"
33 #include "read_barrier_option.h"
34 
35 namespace art {
36 
37 namespace dex {
38 struct ClassDef;
39 class TypeList;
40 }  // namespace dex
41 
42 namespace hiddenapi {
43 class AccessContext;
44 }  // namespace hiddenapi
45 
46 template<typename T> class ArraySlice;
47 class ArtField;
48 class ArtMethod;
49 struct ClassOffsets;
50 class DexFile;
51 template<class T> class Handle;
52 class ImTable;
53 enum InvokeType : uint32_t;
54 template <typename Iter> class IterationRange;
55 template<typename T> class LengthPrefixedArray;
56 enum class PointerSize : size_t;
57 class Signature;
58 template<size_t kNumReferences> class PACKED(4) StackHandleScope;
59 class Thread;
60 
61 namespace mirror {
62 
63 class ClassExt;
64 class ClassLoader;
65 class Constructor;
66 class DexCache;
67 class IfTable;
68 class Method;
69 template <typename T> struct PACKED(8) DexCachePair;
70 
71 using StringDexCachePair = DexCachePair<String>;
72 using StringDexCacheType = std::atomic<StringDexCachePair>;
73 
74 // C++ mirror of java.lang.Class
75 class MANAGED Class final : public Object {
76  public:
77   // A magic value for reference_instance_offsets_. Ignore the bits and walk the super chain when
78   // this is the value.
79   // [This is an unlikely "natural" value, since it would be 30 non-ref instance fields followed by
80   // 2 ref instance fields.]
81   static constexpr uint32_t kClassWalkSuper = 0xC0000000;
82 
83   // Shift primitive type by kPrimitiveTypeSizeShiftShift to get the component type size shift
84   // Used for computing array size as follows:
85   // array_bytes = header_size + (elements << (primitive_type >> kPrimitiveTypeSizeShiftShift))
86   static constexpr uint32_t kPrimitiveTypeSizeShiftShift = 16;
87   static constexpr uint32_t kPrimitiveTypeMask = (1u << kPrimitiveTypeSizeShiftShift) - 1;
88 
89   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetStatus()90   ClassStatus GetStatus() REQUIRES_SHARED(Locks::mutator_lock_) {
91     // Avoid including "subtype_check_bits_and_status.h" to get the field.
92     // The ClassStatus is always in the 4 most-significant bits of status_.
93     return enum_cast<ClassStatus>(
94         static_cast<uint32_t>(GetField32Volatile<kVerifyFlags>(StatusOffset())) >> (32 - 4));
95   }
96 
97   // This is static because 'this' may be moved by GC.
98   static void SetStatus(Handle<Class> h_this, ClassStatus new_status, Thread* self)
99       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
100 
StatusOffset()101   static constexpr MemberOffset StatusOffset() {
102     return MemberOffset(OFFSET_OF_OBJECT_MEMBER(Class, status_));
103   }
104 
105   // Returns true if the class has been retired.
106   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsRetired()107   bool IsRetired() REQUIRES_SHARED(Locks::mutator_lock_) {
108     return GetStatus<kVerifyFlags>() == ClassStatus::kRetired;
109   }
110 
111   // Returns true if the class has failed to link.
112   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsErroneousUnresolved()113   bool IsErroneousUnresolved() REQUIRES_SHARED(Locks::mutator_lock_) {
114     return GetStatus<kVerifyFlags>() == ClassStatus::kErrorUnresolved;
115   }
116 
117   // Returns true if the class has failed to initialize.
118   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsErroneousResolved()119   bool IsErroneousResolved() REQUIRES_SHARED(Locks::mutator_lock_) {
120     return GetStatus<kVerifyFlags>() == ClassStatus::kErrorResolved;
121   }
122 
123   // Returns true if the class status indicets that the class has failed to link or initialize.
IsErroneous(ClassStatus status)124   static bool IsErroneous(ClassStatus status) {
125     return status == ClassStatus::kErrorUnresolved || status == ClassStatus::kErrorResolved;
126   }
127 
128   // Returns true if the class has failed to link or initialize.
129   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsErroneous()130   bool IsErroneous() REQUIRES_SHARED(Locks::mutator_lock_) {
131     return IsErroneous(GetStatus<kVerifyFlags>());
132   }
133 
134   // Returns true if the class has been loaded.
135   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsIdxLoaded()136   bool IsIdxLoaded() REQUIRES_SHARED(Locks::mutator_lock_) {
137     return GetStatus<kVerifyFlags>() >= ClassStatus::kIdx;
138   }
139 
140   // Returns true if the class has been loaded.
141   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsLoaded()142   bool IsLoaded() REQUIRES_SHARED(Locks::mutator_lock_) {
143     return GetStatus<kVerifyFlags>() >= ClassStatus::kLoaded;
144   }
145 
146   // Returns true if the class has been linked.
147   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsResolved()148   bool IsResolved() REQUIRES_SHARED(Locks::mutator_lock_) {
149     ClassStatus status = GetStatus<kVerifyFlags>();
150     return status >= ClassStatus::kResolved || status == ClassStatus::kErrorResolved;
151   }
152 
153   // Returns true if the class should be verified at runtime.
154   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
ShouldVerifyAtRuntime()155   bool ShouldVerifyAtRuntime() REQUIRES_SHARED(Locks::mutator_lock_) {
156     return GetStatus<kVerifyFlags>() == ClassStatus::kRetryVerificationAtRuntime;
157   }
158 
159   // Returns true if the class has been verified.
160   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsVerified()161   bool IsVerified() REQUIRES_SHARED(Locks::mutator_lock_) {
162     return GetStatus<kVerifyFlags>() >= ClassStatus::kVerified;
163   }
164 
165   // Returns true if the class is initializing.
166   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsInitializing()167   bool IsInitializing() REQUIRES_SHARED(Locks::mutator_lock_) {
168     return GetStatus<kVerifyFlags>() >= ClassStatus::kInitializing;
169   }
170 
171   // Returns true if the class is initialized.
172   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsInitialized()173   bool IsInitialized() REQUIRES_SHARED(Locks::mutator_lock_) {
174     return GetStatus<kVerifyFlags>() == ClassStatus::kInitialized;
175   }
176 
177   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetAccessFlags()178   ALWAYS_INLINE uint32_t GetAccessFlags() REQUIRES_SHARED(Locks::mutator_lock_) {
179     if (kIsDebugBuild) {
180       GetAccessFlagsDCheck<kVerifyFlags>();
181     }
182     return GetField32<kVerifyFlags>(AccessFlagsOffset());
183   }
184 
AccessFlagsOffset()185   static constexpr MemberOffset AccessFlagsOffset() {
186     return OFFSET_OF_OBJECT_MEMBER(Class, access_flags_);
187   }
188 
189   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetClassFlags()190   ALWAYS_INLINE uint32_t GetClassFlags() REQUIRES_SHARED(Locks::mutator_lock_) {
191     return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, class_flags_));
192   }
193   void SetClassFlags(uint32_t new_flags) REQUIRES_SHARED(Locks::mutator_lock_);
194 
195   void SetAccessFlags(uint32_t new_access_flags) REQUIRES_SHARED(Locks::mutator_lock_);
196 
197   // Returns true if the class is an enum.
IsEnum()198   ALWAYS_INLINE bool IsEnum() REQUIRES_SHARED(Locks::mutator_lock_) {
199     return (GetAccessFlags() & kAccEnum) != 0;
200   }
201 
202   // Returns true if the class is an interface.
203   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsInterface()204   ALWAYS_INLINE bool IsInterface() REQUIRES_SHARED(Locks::mutator_lock_) {
205     return (GetAccessFlags<kVerifyFlags>() & kAccInterface) != 0;
206   }
207 
208   // Returns true if the class is declared public.
IsPublic()209   ALWAYS_INLINE bool IsPublic() REQUIRES_SHARED(Locks::mutator_lock_) {
210     return (GetAccessFlags() & kAccPublic) != 0;
211   }
212 
213   // Returns true if the class is declared final.
IsFinal()214   ALWAYS_INLINE bool IsFinal() REQUIRES_SHARED(Locks::mutator_lock_) {
215     return (GetAccessFlags() & kAccFinal) != 0;
216   }
217 
IsFinalizable()218   ALWAYS_INLINE bool IsFinalizable() REQUIRES_SHARED(Locks::mutator_lock_) {
219     return (GetAccessFlags() & kAccClassIsFinalizable) != 0;
220   }
221 
ShouldSkipHiddenApiChecks()222   ALWAYS_INLINE bool ShouldSkipHiddenApiChecks() REQUIRES_SHARED(Locks::mutator_lock_) {
223     return (GetAccessFlags() & kAccSkipHiddenapiChecks) != 0;
224   }
225 
SetSkipHiddenApiChecks()226   ALWAYS_INLINE void SetSkipHiddenApiChecks() REQUIRES_SHARED(Locks::mutator_lock_) {
227     uint32_t flags = GetAccessFlags();
228     SetAccessFlags(flags | kAccSkipHiddenapiChecks);
229   }
230 
231   ALWAYS_INLINE void SetRecursivelyInitialized() REQUIRES_SHARED(Locks::mutator_lock_);
232 
233   ALWAYS_INLINE void SetHasDefaultMethods() REQUIRES_SHARED(Locks::mutator_lock_);
234 
SetFinalizable()235   ALWAYS_INLINE void SetFinalizable() REQUIRES_SHARED(Locks::mutator_lock_) {
236     uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_));
237     SetAccessFlags(flags | kAccClassIsFinalizable);
238   }
239 
240   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsStringClass()241   ALWAYS_INLINE bool IsStringClass() REQUIRES_SHARED(Locks::mutator_lock_) {
242     return (GetClassFlags<kVerifyFlags>() & kClassFlagString) != 0;
243   }
244 
SetStringClass()245   ALWAYS_INLINE void SetStringClass() REQUIRES_SHARED(Locks::mutator_lock_) {
246     SetClassFlags(kClassFlagString | kClassFlagNoReferenceFields);
247   }
248 
249   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsClassLoaderClass()250   ALWAYS_INLINE bool IsClassLoaderClass() REQUIRES_SHARED(Locks::mutator_lock_) {
251     return GetClassFlags<kVerifyFlags>() == kClassFlagClassLoader;
252   }
253 
SetClassLoaderClass()254   ALWAYS_INLINE void SetClassLoaderClass() REQUIRES_SHARED(Locks::mutator_lock_) {
255     SetClassFlags(kClassFlagClassLoader);
256   }
257 
258   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsDexCacheClass()259   ALWAYS_INLINE bool IsDexCacheClass() REQUIRES_SHARED(Locks::mutator_lock_) {
260     return (GetClassFlags<kVerifyFlags>() & kClassFlagDexCache) != 0;
261   }
262 
SetDexCacheClass()263   ALWAYS_INLINE void SetDexCacheClass() REQUIRES_SHARED(Locks::mutator_lock_) {
264     SetClassFlags(GetClassFlags() | kClassFlagDexCache);
265   }
266 
267   // Returns true if the class is abstract.
268   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsAbstract()269   ALWAYS_INLINE bool IsAbstract() REQUIRES_SHARED(Locks::mutator_lock_) {
270     return (GetAccessFlags<kVerifyFlags>() & kAccAbstract) != 0;
271   }
272 
273   // Returns true if the class is an annotation.
IsAnnotation()274   ALWAYS_INLINE bool IsAnnotation() REQUIRES_SHARED(Locks::mutator_lock_) {
275     return (GetAccessFlags() & kAccAnnotation) != 0;
276   }
277 
278   // Returns true if the class is synthetic.
IsSynthetic()279   ALWAYS_INLINE bool IsSynthetic() REQUIRES_SHARED(Locks::mutator_lock_) {
280     return (GetAccessFlags() & kAccSynthetic) != 0;
281   }
282 
283   // Return whether the class had run the verifier at least once.
284   // This does not necessarily mean that access checks are avoidable,
285   // since the class methods might still need to be run with access checks.
WasVerificationAttempted()286   bool WasVerificationAttempted() REQUIRES_SHARED(Locks::mutator_lock_) {
287     return (GetAccessFlags() & kAccVerificationAttempted) != 0;
288   }
289 
290   // Mark the class as having gone through a verification attempt.
291   // Mutually exclusive from whether or not each method is allowed to skip access checks.
SetVerificationAttempted()292   void SetVerificationAttempted() REQUIRES_SHARED(Locks::mutator_lock_) {
293     uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_));
294     if ((flags & kAccVerificationAttempted) == 0) {
295       SetAccessFlags(flags | kAccVerificationAttempted);
296     }
297   }
298 
299   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsTypeOfReferenceClass()300   bool IsTypeOfReferenceClass() REQUIRES_SHARED(Locks::mutator_lock_) {
301     return (GetClassFlags<kVerifyFlags>() & kClassFlagReference) != 0;
302   }
303 
304   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsWeakReferenceClass()305   bool IsWeakReferenceClass() REQUIRES_SHARED(Locks::mutator_lock_) {
306     return GetClassFlags<kVerifyFlags>() == kClassFlagWeakReference;
307   }
308 
309   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsSoftReferenceClass()310   bool IsSoftReferenceClass() REQUIRES_SHARED(Locks::mutator_lock_) {
311     return GetClassFlags<kVerifyFlags>() == kClassFlagSoftReference;
312   }
313 
314   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsFinalizerReferenceClass()315   bool IsFinalizerReferenceClass() REQUIRES_SHARED(Locks::mutator_lock_) {
316     return GetClassFlags<kVerifyFlags>() == kClassFlagFinalizerReference;
317   }
318 
319   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPhantomReferenceClass()320   bool IsPhantomReferenceClass() REQUIRES_SHARED(Locks::mutator_lock_) {
321     return GetClassFlags<kVerifyFlags>() == kClassFlagPhantomReference;
322   }
323 
324   // Can references of this type be assigned to by things of another type? For non-array types
325   // this is a matter of whether sub-classes may exist - which they can't if the type is final.
326   // For array classes, where all the classes are final due to there being no sub-classes, an
327   // Object[] may be assigned to by a String[] but a String[] may not be assigned to by other
328   // types as the component is final.
329   bool CannotBeAssignedFromOtherTypes() REQUIRES_SHARED(Locks::mutator_lock_);
330 
331   // Returns true if this class is the placeholder and should retire and
332   // be replaced with a class with the right size for embedded imt/vtable.
333   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsTemp()334   bool IsTemp() REQUIRES_SHARED(Locks::mutator_lock_) {
335     ClassStatus s = GetStatus<kVerifyFlags>();
336     return s < ClassStatus::kResolving &&
337            s != ClassStatus::kErrorResolved &&
338            ShouldHaveEmbeddedVTable<kVerifyFlags>();
339   }
340 
341   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
342            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
343   ObjPtr<String> GetName() REQUIRES_SHARED(Locks::mutator_lock_);  // Returns the cached name.
344   void SetName(ObjPtr<String> name) REQUIRES_SHARED(Locks::mutator_lock_);  // Sets the cached name.
345   // Computes the name, then sets the cached value.
346   static ObjPtr<String> ComputeName(Handle<Class> h_this) REQUIRES_SHARED(Locks::mutator_lock_)
347       REQUIRES(!Roles::uninterruptible_);
348 
349   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsProxyClass()350   bool IsProxyClass() REQUIRES_SHARED(Locks::mutator_lock_) {
351     // Read access flags without using getter as whether something is a proxy can be check in
352     // any loaded state
353     // TODO: switch to a check if the super class is java.lang.reflect.Proxy?
354     uint32_t access_flags = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_));
355     return (access_flags & kAccClassIsProxy) != 0;
356   }
357 
PrimitiveTypeOffset()358   static constexpr MemberOffset PrimitiveTypeOffset() {
359     return OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_);
360   }
361 
362   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
363   Primitive::Type GetPrimitiveType() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_);
364 
SetPrimitiveType(Primitive::Type new_type)365   void SetPrimitiveType(Primitive::Type new_type) REQUIRES_SHARED(Locks::mutator_lock_) {
366     DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t));
367     uint32_t v32 = static_cast<uint32_t>(new_type);
368     DCHECK_EQ(v32 & kPrimitiveTypeMask, v32) << "upper 16 bits aren't zero";
369     // Store the component size shift in the upper 16 bits.
370     v32 |= Primitive::ComponentSizeShift(new_type) << kPrimitiveTypeSizeShiftShift;
371     SetField32Transaction(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), v32);
372   }
373 
374   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
375   size_t GetPrimitiveTypeSizeShift() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_);
376 
377   // Returns true if the class is a primitive type.
378   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitive()379   bool IsPrimitive() REQUIRES_SHARED(Locks::mutator_lock_) {
380     return GetPrimitiveType<kVerifyFlags>() != Primitive::kPrimNot;
381   }
382 
383   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveBoolean()384   bool IsPrimitiveBoolean() REQUIRES_SHARED(Locks::mutator_lock_) {
385     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimBoolean;
386   }
387 
388   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveByte()389   bool IsPrimitiveByte() REQUIRES_SHARED(Locks::mutator_lock_) {
390     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimByte;
391   }
392 
393   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveChar()394   bool IsPrimitiveChar() REQUIRES_SHARED(Locks::mutator_lock_) {
395     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimChar;
396   }
397 
398   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveShort()399   bool IsPrimitiveShort() REQUIRES_SHARED(Locks::mutator_lock_) {
400     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimShort;
401   }
402 
403   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveInt()404   bool IsPrimitiveInt() REQUIRES_SHARED(Locks::mutator_lock_) {
405     return GetPrimitiveType() == Primitive::kPrimInt;
406   }
407 
408   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveLong()409   bool IsPrimitiveLong() REQUIRES_SHARED(Locks::mutator_lock_) {
410     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimLong;
411   }
412 
413   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveFloat()414   bool IsPrimitiveFloat() REQUIRES_SHARED(Locks::mutator_lock_) {
415     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimFloat;
416   }
417 
418   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveDouble()419   bool IsPrimitiveDouble() REQUIRES_SHARED(Locks::mutator_lock_) {
420     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimDouble;
421   }
422 
423   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsPrimitiveVoid()424   bool IsPrimitiveVoid() REQUIRES_SHARED(Locks::mutator_lock_) {
425     return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimVoid;
426   }
427 
428   // Depth of class from java.lang.Object
429   uint32_t Depth() REQUIRES_SHARED(Locks::mutator_lock_);
430 
431   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
432   bool IsArrayClass() REQUIRES_SHARED(Locks::mutator_lock_);
433 
434   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
435   bool IsClassClass() REQUIRES_SHARED(Locks::mutator_lock_);
436 
437   bool IsThrowableClass() REQUIRES_SHARED(Locks::mutator_lock_);
438 
ComponentTypeOffset()439   static constexpr MemberOffset ComponentTypeOffset() {
440     return OFFSET_OF_OBJECT_MEMBER(Class, component_type_);
441   }
442 
443   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
444            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
445   ObjPtr<Class> GetComponentType() REQUIRES_SHARED(Locks::mutator_lock_);
446 
447   void SetComponentType(ObjPtr<Class> new_component_type) REQUIRES_SHARED(Locks::mutator_lock_);
448 
449   size_t GetComponentSize() REQUIRES_SHARED(Locks::mutator_lock_);
450 
451   size_t GetComponentSizeShift() REQUIRES_SHARED(Locks::mutator_lock_);
452 
453   bool IsObjectClass() REQUIRES_SHARED(Locks::mutator_lock_);
454 
455   bool IsInstantiableNonArray() REQUIRES_SHARED(Locks::mutator_lock_);
456 
457   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
458   bool IsInstantiable() REQUIRES_SHARED(Locks::mutator_lock_);
459 
460   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
461   ALWAYS_INLINE bool IsObjectArrayClass() REQUIRES_SHARED(Locks::mutator_lock_);
462 
463   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
464   bool IsPrimitiveArray() REQUIRES_SHARED(Locks::mutator_lock_);
465 
466   // Creates a raw object instance but does not invoke the default constructor.
467   template<bool kIsInstrumented, bool kCheckAddFinalizer = true>
468   ALWAYS_INLINE ObjPtr<Object> Alloc(Thread* self, gc::AllocatorType allocator_type)
469       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
470 
471   ObjPtr<Object> AllocObject(Thread* self)
472       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
473   ObjPtr<Object> AllocNonMovableObject(Thread* self)
474       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
475 
476   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
477   ALWAYS_INLINE bool IsVariableSize() REQUIRES_SHARED(Locks::mutator_lock_);
478 
479   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
SizeOf()480   uint32_t SizeOf() REQUIRES_SHARED(Locks::mutator_lock_) {
481     return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, class_size_));
482   }
483 
484   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetClassSize()485   uint32_t GetClassSize() REQUIRES_SHARED(Locks::mutator_lock_) {
486     return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, class_size_));
487   }
488 
489   void SetClassSize(uint32_t new_class_size)
490       REQUIRES_SHARED(Locks::mutator_lock_);
491 
492   // Compute how many bytes would be used a class with the given elements.
493   static uint32_t ComputeClassSize(bool has_embedded_vtable,
494                                    uint32_t num_vtable_entries,
495                                    uint32_t num_8bit_static_fields,
496                                    uint32_t num_16bit_static_fields,
497                                    uint32_t num_32bit_static_fields,
498                                    uint32_t num_64bit_static_fields,
499                                    uint32_t num_ref_static_fields,
500                                    PointerSize pointer_size);
501 
502   // The size of java.lang.Class.class.
ClassClassSize(PointerSize pointer_size)503   static uint32_t ClassClassSize(PointerSize pointer_size) {
504     // The number of vtable entries in java.lang.Class.
505     uint32_t vtable_entries = Object::kVTableLength + 67;
506     return ComputeClassSize(true, vtable_entries, 0, 0, 4, 1, 0, pointer_size);
507   }
508 
509   // The size of a java.lang.Class representing a primitive such as int.class.
PrimitiveClassSize(PointerSize pointer_size)510   static uint32_t PrimitiveClassSize(PointerSize pointer_size) {
511     return ComputeClassSize(false, 0, 0, 0, 0, 0, 0, pointer_size);
512   }
513 
514   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
515   uint32_t GetObjectSize() REQUIRES_SHARED(Locks::mutator_lock_);
ObjectSizeOffset()516   static constexpr MemberOffset ObjectSizeOffset() {
517     return OFFSET_OF_OBJECT_MEMBER(Class, object_size_);
518   }
ObjectSizeAllocFastPathOffset()519   static constexpr MemberOffset ObjectSizeAllocFastPathOffset() {
520     return OFFSET_OF_OBJECT_MEMBER(Class, object_size_alloc_fast_path_);
521   }
522 
523   ALWAYS_INLINE void SetObjectSize(uint32_t new_object_size) REQUIRES_SHARED(Locks::mutator_lock_);
524 
525   void SetObjectSizeAllocFastPath(uint32_t new_object_size) REQUIRES_SHARED(Locks::mutator_lock_);
526 
527   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
528   uint32_t GetObjectSizeAllocFastPath() REQUIRES_SHARED(Locks::mutator_lock_);
529 
SetObjectSizeWithoutChecks(uint32_t new_object_size)530   void SetObjectSizeWithoutChecks(uint32_t new_object_size)
531       REQUIRES_SHARED(Locks::mutator_lock_) {
532     // Not called within a transaction.
533     return SetField32<false, false, kVerifyNone>(
534         OFFSET_OF_OBJECT_MEMBER(Class, object_size_), new_object_size);
535   }
536 
537   // Returns true if this class is in the same packages as that class.
538   bool IsInSamePackage(ObjPtr<Class> that) REQUIRES_SHARED(Locks::mutator_lock_);
539 
540   static bool IsInSamePackage(std::string_view descriptor1, std::string_view descriptor2);
541 
542   // Returns true if this class can access that class.
543   bool CanAccess(ObjPtr<Class> that) REQUIRES_SHARED(Locks::mutator_lock_);
544 
545   // Can this class access a member in the provided class with the provided member access flags?
546   // Note that access to the class isn't checked in case the declaring class is protected and the
547   // method has been exposed by a public sub-class
548   bool CanAccessMember(ObjPtr<Class> access_to, uint32_t member_flags)
549       REQUIRES_SHARED(Locks::mutator_lock_);
550 
551   // Can this class access a resolved field?
552   // Note that access to field's class is checked and this may require looking up the class
553   // referenced by the FieldId in the DexFile in case the declaring class is inaccessible.
554   bool CanAccessResolvedField(ObjPtr<Class> access_to,
555                               ArtField* field,
556                               ObjPtr<DexCache> dex_cache,
557                               uint32_t field_idx)
558       REQUIRES_SHARED(Locks::mutator_lock_);
559   bool CheckResolvedFieldAccess(ObjPtr<Class> access_to,
560                                 ArtField* field,
561                                 ObjPtr<DexCache> dex_cache,
562                                 uint32_t field_idx)
563       REQUIRES_SHARED(Locks::mutator_lock_);
564 
565   // Can this class access a resolved method?
566   // Note that access to methods's class is checked and this may require looking up the class
567   // referenced by the MethodId in the DexFile in case the declaring class is inaccessible.
568   bool CanAccessResolvedMethod(ObjPtr<Class> access_to,
569                                ArtMethod* resolved_method,
570                                ObjPtr<DexCache> dex_cache,
571                                uint32_t method_idx)
572       REQUIRES_SHARED(Locks::mutator_lock_);
573   bool CheckResolvedMethodAccess(ObjPtr<Class> access_to,
574                                  ArtMethod* resolved_method,
575                                  ObjPtr<DexCache> dex_cache,
576                                  uint32_t method_idx,
577                                  InvokeType throw_invoke_type)
578       REQUIRES_SHARED(Locks::mutator_lock_);
579 
580   bool IsSubClass(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
581 
582   // Can src be assigned to this class? For example, String can be assigned to Object (by an
583   // upcast), however, an Object cannot be assigned to a String as a potentially exception throwing
584   // downcast would be necessary. Similarly for interfaces, a class that implements (or an interface
585   // that extends) another can be assigned to its parent, but not vice-versa. All Classes may assign
586   // to themselves. Classes for primitive types may not assign to each other.
587   ALWAYS_INLINE bool IsAssignableFrom(ObjPtr<Class> src) REQUIRES_SHARED(Locks::mutator_lock_);
588 
589   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
590            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
591   ALWAYS_INLINE ObjPtr<Class> GetSuperClass() REQUIRES_SHARED(Locks::mutator_lock_);
592 
593   // Get first common super class. It will never return null.
594   // `This` and `klass` must be classes.
595   ObjPtr<Class> GetCommonSuperClass(Handle<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
596 
597   void SetSuperClass(ObjPtr<Class> new_super_class) REQUIRES_SHARED(Locks::mutator_lock_);
598 
599   bool HasSuperClass() REQUIRES_SHARED(Locks::mutator_lock_);
600 
SuperClassOffset()601   static constexpr MemberOffset SuperClassOffset() {
602     return MemberOffset(OFFSETOF_MEMBER(Class, super_class_));
603   }
604 
605   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
606            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
607   ObjPtr<ClassLoader> GetClassLoader() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_);
608 
609   template <bool kCheckTransaction = true>
610   void SetClassLoader(ObjPtr<ClassLoader> new_cl) REQUIRES_SHARED(Locks::mutator_lock_);
611 
DexCacheOffset()612   static constexpr MemberOffset DexCacheOffset() {
613     return MemberOffset(OFFSETOF_MEMBER(Class, dex_cache_));
614   }
615 
IfTableOffset()616   static constexpr MemberOffset IfTableOffset() {
617     return MemberOffset(OFFSETOF_MEMBER(Class, iftable_));
618   }
619 
620   enum {
621     kDumpClassFullDetail = 1,
622     kDumpClassClassLoader = (1 << 1),
623     kDumpClassInitialized = (1 << 2),
624   };
625 
626   void DumpClass(std::ostream& os, int flags) REQUIRES_SHARED(Locks::mutator_lock_);
627 
628   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
629            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
630   ObjPtr<DexCache> GetDexCache() REQUIRES_SHARED(Locks::mutator_lock_);
631 
632   // Also updates the dex_cache_strings_ variable from new_dex_cache.
633   void SetDexCache(ObjPtr<DexCache> new_dex_cache) REQUIRES_SHARED(Locks::mutator_lock_);
634 
635   ALWAYS_INLINE ArraySlice<ArtMethod> GetDirectMethods(PointerSize pointer_size)
636       REQUIRES_SHARED(Locks::mutator_lock_);
637 
638   ALWAYS_INLINE LengthPrefixedArray<ArtMethod>* GetMethodsPtr()
639       REQUIRES_SHARED(Locks::mutator_lock_);
640 
MethodsOffset()641   static constexpr MemberOffset MethodsOffset() {
642     return MemberOffset(OFFSETOF_MEMBER(Class, methods_));
643   }
644 
645   ALWAYS_INLINE ArraySlice<ArtMethod> GetMethods(PointerSize pointer_size)
646       REQUIRES_SHARED(Locks::mutator_lock_);
647 
648   void SetMethodsPtr(LengthPrefixedArray<ArtMethod>* new_methods,
649                      uint32_t num_direct,
650                      uint32_t num_virtual)
651       REQUIRES_SHARED(Locks::mutator_lock_);
652   // Used by image writer.
653   void SetMethodsPtrUnchecked(LengthPrefixedArray<ArtMethod>* new_methods,
654                               uint32_t num_direct,
655                               uint32_t num_virtual)
656       REQUIRES_SHARED(Locks::mutator_lock_);
657 
658   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
659   ALWAYS_INLINE ArraySlice<ArtMethod> GetDirectMethodsSlice(PointerSize pointer_size)
660       REQUIRES_SHARED(Locks::mutator_lock_);
661 
662   ALWAYS_INLINE ArtMethod* GetDirectMethod(size_t i, PointerSize pointer_size)
663       REQUIRES_SHARED(Locks::mutator_lock_);
664 
665   // Use only when we are allocating populating the method arrays.
666   ALWAYS_INLINE ArtMethod* GetDirectMethodUnchecked(size_t i, PointerSize pointer_size)
667         REQUIRES_SHARED(Locks::mutator_lock_);
668   ALWAYS_INLINE ArtMethod* GetVirtualMethodUnchecked(size_t i, PointerSize pointer_size)
669         REQUIRES_SHARED(Locks::mutator_lock_);
670 
671   // Returns the number of static, private, and constructor methods.
672   ALWAYS_INLINE uint32_t NumDirectMethods() REQUIRES_SHARED(Locks::mutator_lock_);
673 
674   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
675   ALWAYS_INLINE ArraySlice<ArtMethod> GetMethodsSlice(PointerSize pointer_size)
676       REQUIRES_SHARED(Locks::mutator_lock_);
677 
678   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
679   ALWAYS_INLINE ArraySlice<ArtMethod> GetDeclaredMethodsSlice(PointerSize pointer_size)
680       REQUIRES_SHARED(Locks::mutator_lock_);
681 
682   ALWAYS_INLINE ArraySlice<ArtMethod> GetDeclaredMethods(
683         PointerSize pointer_size)
684       REQUIRES_SHARED(Locks::mutator_lock_);
685 
686   template <PointerSize kPointerSize, bool kTransactionActive>
687   static ObjPtr<Method> GetDeclaredMethodInternal(
688       Thread* self,
689       ObjPtr<Class> klass,
690       ObjPtr<String> name,
691       ObjPtr<ObjectArray<Class>> args,
692       const std::function<hiddenapi::AccessContext()>& fn_get_access_context)
693       REQUIRES_SHARED(Locks::mutator_lock_);
694 
695   template <PointerSize kPointerSize, bool kTransactionActive>
696   static ObjPtr<Constructor> GetDeclaredConstructorInternal(Thread* self,
697                                                             ObjPtr<Class> klass,
698                                                             ObjPtr<ObjectArray<Class>> args)
699       REQUIRES_SHARED(Locks::mutator_lock_);
700 
701   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
702   ALWAYS_INLINE ArraySlice<ArtMethod> GetDeclaredVirtualMethodsSlice(PointerSize pointer_size)
703       REQUIRES_SHARED(Locks::mutator_lock_);
704 
705   ALWAYS_INLINE ArraySlice<ArtMethod> GetDeclaredVirtualMethods(
706         PointerSize pointer_size)
707       REQUIRES_SHARED(Locks::mutator_lock_);
708 
709   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
710   ALWAYS_INLINE ArraySlice<ArtMethod> GetCopiedMethodsSlice(PointerSize pointer_size)
711       REQUIRES_SHARED(Locks::mutator_lock_);
712 
713   ALWAYS_INLINE ArraySlice<ArtMethod> GetCopiedMethods(PointerSize pointer_size)
714       REQUIRES_SHARED(Locks::mutator_lock_);
715 
716   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
717   ALWAYS_INLINE ArraySlice<ArtMethod> GetVirtualMethodsSlice(PointerSize pointer_size)
718       REQUIRES_SHARED(Locks::mutator_lock_);
719 
720   ALWAYS_INLINE ArraySlice<ArtMethod> GetVirtualMethods(
721       PointerSize pointer_size)
722       REQUIRES_SHARED(Locks::mutator_lock_);
723 
724   // Returns the number of non-inherited virtual methods (sum of declared and copied methods).
725   ALWAYS_INLINE uint32_t NumVirtualMethods() REQUIRES_SHARED(Locks::mutator_lock_);
726 
727   // Returns the number of copied virtual methods.
728   ALWAYS_INLINE uint32_t NumCopiedVirtualMethods() REQUIRES_SHARED(Locks::mutator_lock_);
729 
730   // Returns the number of declared virtual methods.
731   ALWAYS_INLINE uint32_t NumDeclaredVirtualMethods() REQUIRES_SHARED(Locks::mutator_lock_);
732 
733   ALWAYS_INLINE uint32_t NumMethods() REQUIRES_SHARED(Locks::mutator_lock_);
734   static ALWAYS_INLINE uint32_t NumMethods(LengthPrefixedArray<ArtMethod>* methods)
735       REQUIRES_SHARED(Locks::mutator_lock_);
736 
737   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
738   ArtMethod* GetVirtualMethod(size_t i, PointerSize pointer_size)
739       REQUIRES_SHARED(Locks::mutator_lock_);
740 
741   ArtMethod* GetVirtualMethodDuringLinking(size_t i, PointerSize pointer_size)
742       REQUIRES_SHARED(Locks::mutator_lock_);
743 
744   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
745            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
746   ALWAYS_INLINE ObjPtr<PointerArray> GetVTable() REQUIRES_SHARED(Locks::mutator_lock_);
747 
748   ALWAYS_INLINE ObjPtr<PointerArray> GetVTableDuringLinking() REQUIRES_SHARED(Locks::mutator_lock_);
749 
750   void SetVTable(ObjPtr<PointerArray> new_vtable) REQUIRES_SHARED(Locks::mutator_lock_);
751 
VTableOffset()752   static constexpr MemberOffset VTableOffset() {
753     return OFFSET_OF_OBJECT_MEMBER(Class, vtable_);
754   }
755 
EmbeddedVTableLengthOffset()756   static constexpr MemberOffset EmbeddedVTableLengthOffset() {
757     return MemberOffset(sizeof(Class));
758   }
759 
ImtPtrOffset(PointerSize pointer_size)760   static constexpr MemberOffset ImtPtrOffset(PointerSize pointer_size) {
761     return MemberOffset(
762         RoundUp(EmbeddedVTableLengthOffset().Uint32Value() + sizeof(uint32_t),
763                 static_cast<size_t>(pointer_size)));
764   }
765 
766   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
767   bool ShouldHaveImt() REQUIRES_SHARED(Locks::mutator_lock_);
768 
769   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
770   bool ShouldHaveEmbeddedVTable() REQUIRES_SHARED(Locks::mutator_lock_);
771 
772   bool HasVTable() REQUIRES_SHARED(Locks::mutator_lock_);
773 
774   static MemberOffset EmbeddedVTableEntryOffset(uint32_t i, PointerSize pointer_size);
775 
776   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
777   int32_t GetVTableLength() REQUIRES_SHARED(Locks::mutator_lock_);
778 
779   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
780            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
781   ArtMethod* GetVTableEntry(uint32_t i, PointerSize pointer_size)
782       REQUIRES_SHARED(Locks::mutator_lock_);
783 
784   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
785   int32_t GetEmbeddedVTableLength() REQUIRES_SHARED(Locks::mutator_lock_);
786 
787   void SetEmbeddedVTableLength(int32_t len) REQUIRES_SHARED(Locks::mutator_lock_);
788 
789   ImTable* GetImt(PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_);
790 
791   void SetImt(ImTable* imt, PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_);
792 
793   ArtMethod* GetEmbeddedVTableEntry(uint32_t i, PointerSize pointer_size)
794       REQUIRES_SHARED(Locks::mutator_lock_);
795 
796   void SetEmbeddedVTableEntry(uint32_t i, ArtMethod* method, PointerSize pointer_size)
797       REQUIRES_SHARED(Locks::mutator_lock_);
798 
799   inline void SetEmbeddedVTableEntryUnchecked(uint32_t i,
800                                               ArtMethod* method,
801                                               PointerSize pointer_size)
802       REQUIRES_SHARED(Locks::mutator_lock_);
803 
804   void PopulateEmbeddedVTable(PointerSize pointer_size)
805       REQUIRES_SHARED(Locks::mutator_lock_);
806 
807   // Given a method implemented by this class but potentially from a super class, return the
808   // specific implementation method for this class.
809   ArtMethod* FindVirtualMethodForVirtual(ArtMethod* method, PointerSize pointer_size)
810       REQUIRES_SHARED(Locks::mutator_lock_);
811 
812   // Given a method implemented by this class' super class, return the specific implementation
813   // method for this class.
814   ArtMethod* FindVirtualMethodForSuper(ArtMethod* method, PointerSize pointer_size)
815       REQUIRES_SHARED(Locks::mutator_lock_);
816 
817   // Given a method from some implementor of this interface, return the specific implementation
818   // method for this class.
819   ArtMethod* FindVirtualMethodForInterfaceSuper(ArtMethod* method, PointerSize pointer_size)
820       REQUIRES_SHARED(Locks::mutator_lock_);
821 
822   // Given a method implemented by this class, but potentially from a
823   // super class or interface, return the specific implementation
824   // method for this class.
825   ArtMethod* FindVirtualMethodForInterface(ArtMethod* method, PointerSize pointer_size)
826       REQUIRES_SHARED(Locks::mutator_lock_) ALWAYS_INLINE;
827 
828   ArtMethod* FindVirtualMethodForVirtualOrInterface(ArtMethod* method, PointerSize pointer_size)
829       REQUIRES_SHARED(Locks::mutator_lock_);
830 
831   // Find a method with the given name and signature in an interface class.
832   //
833   // Search for the method declared in the class, then search for a method declared in any
834   // superinterface, then search the superclass java.lang.Object (implicitly declared methods
835   // in an interface without superinterfaces, see JLS 9.2, can be inherited, see JLS 9.4.1).
836   // TODO: Implement search for a unique maximally-specific non-abstract superinterface method.
837 
838   ArtMethod* FindInterfaceMethod(std::string_view name,
839                                  std::string_view signature,
840                                  PointerSize pointer_size)
841       REQUIRES_SHARED(Locks::mutator_lock_);
842 
843   ArtMethod* FindInterfaceMethod(std::string_view name,
844                                  const Signature& signature,
845                                  PointerSize pointer_size)
846       REQUIRES_SHARED(Locks::mutator_lock_);
847 
848   ArtMethod* FindInterfaceMethod(ObjPtr<DexCache> dex_cache,
849                                  uint32_t dex_method_idx,
850                                  PointerSize pointer_size)
851       REQUIRES_SHARED(Locks::mutator_lock_);
852 
853   // Find a method with the given name and signature in a non-interface class.
854   //
855   // Search for the method in the class, following the JLS rules which conflict with the RI
856   // in some cases. The JLS says that inherited methods are searched (JLS 15.12.2.1) and
857   // these can come from a superclass or a superinterface (JLS 8.4.8). We perform the
858   // following search:
859   //   1. Search the methods declared directly in the class. If we find a method with the
860   //      given name and signature, return that method.
861   //   2. Search the methods declared in superclasses until we find a method with the given
862   //      signature or complete the search in java.lang.Object. If we find a method with the
863   //      given name and signature, check if it's been inherited by the class where we're
864   //      performing the lookup (qualifying type). If it's inherited, return it. Otherwise,
865   //      just remember the method and its declaring class and proceed to step 3.
866   //   3. Search "copied" methods (containing methods inherited from interfaces) in the class
867   //      and its superclass chain. If we found a method in step 2 (which was not inherited,
868   //      otherwise we would not be performing step 3), end the search when we reach its
869   //      declaring class, otherwise search the entire superclass chain. If we find a method
870   //      with the given name and signature, return that method.
871   //   4. Return the method found in step 2 if any (not inherited), or null.
872   //
873   // It's the responsibility of the caller to throw exceptions if the returned method (or null)
874   // does not satisfy the request. Special consideration should be given to the case where this
875   // function returns a method that's not inherited (found in step 2, returned in step 4).
876 
877   ArtMethod* FindClassMethod(std::string_view name,
878                              std::string_view signature,
879                              PointerSize pointer_size)
880       REQUIRES_SHARED(Locks::mutator_lock_);
881 
882   ArtMethod* FindClassMethod(std::string_view name,
883                              const Signature& signature,
884                              PointerSize pointer_size)
885       REQUIRES_SHARED(Locks::mutator_lock_);
886 
887   ArtMethod* FindClassMethod(ObjPtr<DexCache> dex_cache,
888                              uint32_t dex_method_idx,
889                              PointerSize pointer_size)
890       REQUIRES_SHARED(Locks::mutator_lock_);
891 
892   ArtMethod* FindConstructor(std::string_view signature, PointerSize pointer_size)
893       REQUIRES_SHARED(Locks::mutator_lock_);
894 
895   ArtMethod* FindDeclaredVirtualMethodByName(std::string_view name, PointerSize pointer_size)
896       REQUIRES_SHARED(Locks::mutator_lock_);
897 
898   ArtMethod* FindDeclaredDirectMethodByName(std::string_view name, PointerSize pointer_size)
899       REQUIRES_SHARED(Locks::mutator_lock_);
900 
901   ArtMethod* FindClassInitializer(PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_);
902 
HasDefaultMethods()903   bool HasDefaultMethods() REQUIRES_SHARED(Locks::mutator_lock_) {
904     return (GetAccessFlags() & kAccHasDefaultMethod) != 0;
905   }
906 
HasBeenRecursivelyInitialized()907   bool HasBeenRecursivelyInitialized() REQUIRES_SHARED(Locks::mutator_lock_) {
908     return (GetAccessFlags() & kAccRecursivelyInitialized) != 0;
909   }
910 
911   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
912   ALWAYS_INLINE int32_t GetIfTableCount() REQUIRES_SHARED(Locks::mutator_lock_);
913 
914   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
915            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
916   ALWAYS_INLINE ObjPtr<IfTable> GetIfTable() REQUIRES_SHARED(Locks::mutator_lock_);
917 
918   ALWAYS_INLINE void SetIfTable(ObjPtr<IfTable> new_iftable)
919       REQUIRES_SHARED(Locks::mutator_lock_);
920 
921   // Get instance fields of the class (See also GetSFields).
922   LengthPrefixedArray<ArtField>* GetIFieldsPtr() REQUIRES_SHARED(Locks::mutator_lock_);
923 
924   ALWAYS_INLINE IterationRange<StrideIterator<ArtField>> GetIFields()
925       REQUIRES_SHARED(Locks::mutator_lock_);
926 
927   void SetIFieldsPtr(LengthPrefixedArray<ArtField>* new_ifields)
928       REQUIRES_SHARED(Locks::mutator_lock_);
929 
930   // Unchecked edition has no verification flags.
931   void SetIFieldsPtrUnchecked(LengthPrefixedArray<ArtField>* new_sfields)
932       REQUIRES_SHARED(Locks::mutator_lock_);
933 
934   uint32_t NumInstanceFields() REQUIRES_SHARED(Locks::mutator_lock_);
935   ArtField* GetInstanceField(uint32_t i) REQUIRES_SHARED(Locks::mutator_lock_);
936 
937   // Returns the number of instance fields containing reference types. Does not count fields in any
938   // super classes.
939   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
NumReferenceInstanceFields()940   uint32_t NumReferenceInstanceFields() REQUIRES_SHARED(Locks::mutator_lock_) {
941     DCHECK(IsResolved<kVerifyFlags>());
942     return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_));
943   }
944 
NumReferenceInstanceFieldsDuringLinking()945   uint32_t NumReferenceInstanceFieldsDuringLinking() REQUIRES_SHARED(Locks::mutator_lock_) {
946     DCHECK(IsLoaded() || IsErroneous());
947     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_));
948   }
949 
SetNumReferenceInstanceFields(uint32_t new_num)950   void SetNumReferenceInstanceFields(uint32_t new_num) REQUIRES_SHARED(Locks::mutator_lock_) {
951     // Not called within a transaction.
952     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), new_num);
953   }
954 
955   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
956   uint32_t GetReferenceInstanceOffsets() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_);
957 
958   void SetReferenceInstanceOffsets(uint32_t new_reference_offsets)
959       REQUIRES_SHARED(Locks::mutator_lock_);
960 
961   // Get the offset of the first reference instance field. Other reference instance fields follow.
962   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
963            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
964   MemberOffset GetFirstReferenceInstanceFieldOffset()
965       REQUIRES_SHARED(Locks::mutator_lock_);
966 
967   // Returns the number of static fields containing reference types.
968   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
NumReferenceStaticFields()969   uint32_t NumReferenceStaticFields() REQUIRES_SHARED(Locks::mutator_lock_) {
970     DCHECK(IsResolved<kVerifyFlags>());
971     return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_));
972   }
973 
NumReferenceStaticFieldsDuringLinking()974   uint32_t NumReferenceStaticFieldsDuringLinking() REQUIRES_SHARED(Locks::mutator_lock_) {
975     DCHECK(IsLoaded() || IsErroneous() || IsRetired());
976     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_));
977   }
978 
SetNumReferenceStaticFields(uint32_t new_num)979   void SetNumReferenceStaticFields(uint32_t new_num) REQUIRES_SHARED(Locks::mutator_lock_) {
980     // Not called within a transaction.
981     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), new_num);
982   }
983 
984   // Get the offset of the first reference static field. Other reference static fields follow.
985   template <VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
986   MemberOffset GetFirstReferenceStaticFieldOffset(PointerSize pointer_size)
987       REQUIRES_SHARED(Locks::mutator_lock_);
988 
989   // Get the offset of the first reference static field. Other reference static fields follow.
990   MemberOffset GetFirstReferenceStaticFieldOffsetDuringLinking(PointerSize pointer_size)
991       REQUIRES_SHARED(Locks::mutator_lock_);
992 
993   // Gets the static fields of the class.
994   LengthPrefixedArray<ArtField>* GetSFieldsPtr() REQUIRES_SHARED(Locks::mutator_lock_);
995   ALWAYS_INLINE IterationRange<StrideIterator<ArtField>> GetSFields()
996       REQUIRES_SHARED(Locks::mutator_lock_);
997 
998   void SetSFieldsPtr(LengthPrefixedArray<ArtField>* new_sfields)
999       REQUIRES_SHARED(Locks::mutator_lock_);
1000 
1001   // Unchecked edition has no verification flags.
1002   void SetSFieldsPtrUnchecked(LengthPrefixedArray<ArtField>* new_sfields)
1003       REQUIRES_SHARED(Locks::mutator_lock_);
1004 
1005   uint32_t NumStaticFields() REQUIRES_SHARED(Locks::mutator_lock_);
1006 
1007   // TODO: uint16_t
1008   ArtField* GetStaticField(uint32_t i) REQUIRES_SHARED(Locks::mutator_lock_);
1009 
1010   // Find a static or instance field using the JLS resolution order
1011   static ArtField* FindField(Thread* self,
1012                              ObjPtr<Class> klass,
1013                              std::string_view name,
1014                              std::string_view type)
1015       REQUIRES_SHARED(Locks::mutator_lock_);
1016 
1017   // Finds the given instance field in this class or a superclass.
1018   ArtField* FindInstanceField(std::string_view name, std::string_view type)
1019       REQUIRES_SHARED(Locks::mutator_lock_);
1020 
1021   // Finds the given instance field in this class or a superclass, only searches classes that
1022   // have the same dex cache.
1023   ArtField* FindInstanceField(ObjPtr<DexCache> dex_cache, uint32_t dex_field_idx)
1024       REQUIRES_SHARED(Locks::mutator_lock_);
1025 
1026   ArtField* FindDeclaredInstanceField(std::string_view name, std::string_view type)
1027       REQUIRES_SHARED(Locks::mutator_lock_);
1028 
1029   ArtField* FindDeclaredInstanceField(ObjPtr<DexCache> dex_cache, uint32_t dex_field_idx)
1030       REQUIRES_SHARED(Locks::mutator_lock_);
1031 
1032   // Finds the given static field in this class or a superclass.
1033   static ArtField* FindStaticField(Thread* self,
1034                                    ObjPtr<Class> klass,
1035                                    std::string_view name,
1036                                    std::string_view type)
1037       REQUIRES_SHARED(Locks::mutator_lock_);
1038 
1039   // Finds the given static field in this class or superclass, only searches classes that
1040   // have the same dex cache.
1041   static ArtField* FindStaticField(Thread* self,
1042                                    ObjPtr<Class> klass,
1043                                    ObjPtr<DexCache> dex_cache,
1044                                    uint32_t dex_field_idx)
1045       REQUIRES_SHARED(Locks::mutator_lock_);
1046 
1047   ArtField* FindDeclaredStaticField(std::string_view name, std::string_view type)
1048       REQUIRES_SHARED(Locks::mutator_lock_);
1049 
1050   ArtField* FindDeclaredStaticField(ObjPtr<DexCache> dex_cache, uint32_t dex_field_idx)
1051       REQUIRES_SHARED(Locks::mutator_lock_);
1052 
GetClinitThreadId()1053   pid_t GetClinitThreadId() REQUIRES_SHARED(Locks::mutator_lock_) {
1054     DCHECK(IsIdxLoaded() || IsErroneous()) << PrettyClass();
1055     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_));
1056   }
1057 
1058   void SetClinitThreadId(pid_t new_clinit_thread_id) REQUIRES_SHARED(Locks::mutator_lock_);
1059 
1060   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
1061            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
1062   ObjPtr<ClassExt> GetExtData() REQUIRES_SHARED(Locks::mutator_lock_);
1063 
1064   // Returns the ExtData for this class, allocating one if necessary. This should be the only way
1065   // to force ext_data_ to be set. No functions are available for changing an already set ext_data_
1066   // since doing so is not allowed.
1067   ObjPtr<ClassExt> EnsureExtDataPresent(Thread* self)
1068       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
1069 
GetDexClassDefIndex()1070   uint16_t GetDexClassDefIndex() REQUIRES_SHARED(Locks::mutator_lock_) {
1071     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_class_def_idx_));
1072   }
1073 
SetDexClassDefIndex(uint16_t class_def_idx)1074   void SetDexClassDefIndex(uint16_t class_def_idx) REQUIRES_SHARED(Locks::mutator_lock_) {
1075     SetField32Transaction(OFFSET_OF_OBJECT_MEMBER(Class, dex_class_def_idx_), class_def_idx);
1076   }
1077 
GetDexTypeIndex()1078   dex::TypeIndex GetDexTypeIndex() REQUIRES_SHARED(Locks::mutator_lock_) {
1079     return dex::TypeIndex(
1080         static_cast<uint16_t>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_))));
1081   }
1082 
SetDexTypeIndex(dex::TypeIndex type_idx)1083   void SetDexTypeIndex(dex::TypeIndex type_idx) REQUIRES_SHARED(Locks::mutator_lock_) {
1084     SetField32Transaction(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), type_idx.index_);
1085   }
1086 
1087   dex::TypeIndex FindTypeIndexInOtherDexFile(const DexFile& dex_file)
1088       REQUIRES_SHARED(Locks::mutator_lock_);
1089 
1090   // Visit native roots visits roots which are keyed off the native pointers such as ArtFields and
1091   // ArtMethods.
1092   template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier, class Visitor>
1093   void VisitNativeRoots(Visitor& visitor, PointerSize pointer_size)
1094       REQUIRES_SHARED(Locks::mutator_lock_);
1095 
1096   // Get one of the primitive classes.
1097   static ObjPtr<mirror::Class> GetPrimitiveClass(ObjPtr<mirror::String> name)
1098       REQUIRES_SHARED(Locks::mutator_lock_);
1099 
1100   // When class is verified, set the kAccSkipAccessChecks flag on each method.
1101   void SetSkipAccessChecksFlagOnAllMethods(PointerSize pointer_size)
1102       REQUIRES_SHARED(Locks::mutator_lock_);
1103 
1104   // Get the descriptor of the class. In a few cases a std::string is required, rather than
1105   // always create one the storage argument is populated and its internal c_str() returned. We do
1106   // this to avoid memory allocation in the common case.
1107   const char* GetDescriptor(std::string* storage) REQUIRES_SHARED(Locks::mutator_lock_);
1108 
1109   bool DescriptorEquals(const char* match) REQUIRES_SHARED(Locks::mutator_lock_);
1110 
1111   const dex::ClassDef* GetClassDef() REQUIRES_SHARED(Locks::mutator_lock_);
1112 
1113   ALWAYS_INLINE uint32_t NumDirectInterfaces() REQUIRES_SHARED(Locks::mutator_lock_);
1114 
1115   dex::TypeIndex GetDirectInterfaceTypeIdx(uint32_t idx) REQUIRES_SHARED(Locks::mutator_lock_);
1116 
1117   // Get the direct interface of the `klass` at index `idx` if resolved, otherwise return null.
1118   // If the caller expects the interface to be resolved, for example for a resolved `klass`,
1119   // that assumption should be checked by `DCHECK(result != nullptr)`.
1120   static ObjPtr<Class> GetDirectInterface(Thread* self, ObjPtr<Class> klass, uint32_t idx)
1121       REQUIRES_SHARED(Locks::mutator_lock_);
1122 
1123   // Resolve and get the direct interface of the `klass` at index `idx`.
1124   // Returns null with a pending exception if the resolution fails.
1125   static ObjPtr<Class> ResolveDirectInterface(Thread* self, Handle<Class> klass, uint32_t idx)
1126       REQUIRES_SHARED(Locks::mutator_lock_);
1127 
1128   const char* GetSourceFile() REQUIRES_SHARED(Locks::mutator_lock_);
1129 
1130   std::string GetLocation() REQUIRES_SHARED(Locks::mutator_lock_);
1131 
1132   const DexFile& GetDexFile() REQUIRES_SHARED(Locks::mutator_lock_);
1133 
1134   const dex::TypeList* GetInterfaceTypeList() REQUIRES_SHARED(Locks::mutator_lock_);
1135 
1136   // Asserts we are initialized or initializing in the given thread.
1137   void AssertInitializedOrInitializingInThread(Thread* self)
1138       REQUIRES_SHARED(Locks::mutator_lock_);
1139 
1140   ObjPtr<Class> CopyOf(Thread* self, int32_t new_length, ImTable* imt, PointerSize pointer_size)
1141       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
1142 
1143   // For proxy class only.
1144   ObjPtr<ObjectArray<Class>> GetProxyInterfaces() REQUIRES_SHARED(Locks::mutator_lock_);
1145 
1146   // For proxy class only.
1147   ObjPtr<ObjectArray<ObjectArray<Class>>> GetProxyThrows() REQUIRES_SHARED(Locks::mutator_lock_);
1148 
1149   // May cause thread suspension due to EqualParameters.
1150   ArtMethod* GetDeclaredConstructor(Thread* self,
1151                                     Handle<ObjectArray<Class>> args,
1152                                     PointerSize pointer_size)
1153       REQUIRES_SHARED(Locks::mutator_lock_);
1154 
1155   static int32_t GetInnerClassFlags(Handle<Class> h_this, int32_t default_value)
1156       REQUIRES_SHARED(Locks::mutator_lock_);
1157 
1158   // Used to initialize a class in the allocation code path to ensure it is guarded by a StoreStore
1159   // fence.
1160   class InitializeClassVisitor {
1161    public:
InitializeClassVisitor(uint32_t class_size)1162     explicit InitializeClassVisitor(uint32_t class_size) : class_size_(class_size) {
1163     }
1164 
1165     void operator()(ObjPtr<Object> obj, size_t usable_size) const
1166         REQUIRES_SHARED(Locks::mutator_lock_);
1167 
1168    private:
1169     const uint32_t class_size_;
1170 
1171     DISALLOW_COPY_AND_ASSIGN(InitializeClassVisitor);
1172   };
1173 
1174   // Returns true if the class loader is null, ie the class loader is the boot strap class loader.
1175   bool IsBootStrapClassLoaded() REQUIRES_SHARED(Locks::mutator_lock_);
1176 
ImTableEntrySize(PointerSize pointer_size)1177   static size_t ImTableEntrySize(PointerSize pointer_size) {
1178     return static_cast<size_t>(pointer_size);
1179   }
1180 
VTableEntrySize(PointerSize pointer_size)1181   static size_t VTableEntrySize(PointerSize pointer_size) {
1182     return static_cast<size_t>(pointer_size);
1183   }
1184 
1185   ALWAYS_INLINE ArraySlice<ArtMethod> GetDirectMethodsSliceUnchecked(PointerSize pointer_size)
1186       REQUIRES_SHARED(Locks::mutator_lock_);
1187 
1188   ALWAYS_INLINE ArraySlice<ArtMethod> GetVirtualMethodsSliceUnchecked(PointerSize pointer_size)
1189       REQUIRES_SHARED(Locks::mutator_lock_);
1190 
1191   ALWAYS_INLINE ArraySlice<ArtMethod> GetDeclaredMethodsSliceUnchecked(PointerSize pointer_size)
1192       REQUIRES_SHARED(Locks::mutator_lock_);
1193 
1194   ALWAYS_INLINE ArraySlice<ArtMethod> GetDeclaredVirtualMethodsSliceUnchecked(
1195       PointerSize pointer_size)
1196       REQUIRES_SHARED(Locks::mutator_lock_);
1197 
1198   ALWAYS_INLINE ArraySlice<ArtMethod> GetCopiedMethodsSliceUnchecked(PointerSize pointer_size)
1199       REQUIRES_SHARED(Locks::mutator_lock_);
1200 
1201   static std::string PrettyDescriptor(ObjPtr<mirror::Class> klass)
1202       REQUIRES_SHARED(Locks::mutator_lock_);
1203   std::string PrettyDescriptor()
1204       REQUIRES_SHARED(Locks::mutator_lock_);
1205   // Returns a human-readable form of the name of the given class.
1206   // Given String.class, the output would be "java.lang.Class<java.lang.String>".
1207   static std::string PrettyClass(ObjPtr<mirror::Class> c)
1208       REQUIRES_SHARED(Locks::mutator_lock_);
1209   std::string PrettyClass()
1210       REQUIRES_SHARED(Locks::mutator_lock_);
1211   // Returns a human-readable form of the name of the given class with its class loader.
1212   static std::string PrettyClassAndClassLoader(ObjPtr<mirror::Class> c)
1213       REQUIRES_SHARED(Locks::mutator_lock_);
1214   std::string PrettyClassAndClassLoader()
1215       REQUIRES_SHARED(Locks::mutator_lock_);
1216 
1217   // Fix up all of the native pointers in the class by running them through the visitor. Only sets
1218   // the corresponding entry in dest if visitor(obj) != obj to prevent dirty memory. Dest should be
1219   // initialized to a copy of *this to prevent issues. Does not visit the ArtMethod and ArtField
1220   // roots.
1221   template <VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, typename Visitor>
1222   void FixupNativePointers(Class* dest, PointerSize pointer_size, const Visitor& visitor)
1223       REQUIRES_SHARED(Locks::mutator_lock_);
1224 
1225  private:
1226   template <typename T, VerifyObjectFlags kVerifyFlags, typename Visitor>
1227   void FixupNativePointer(
1228       Class* dest, PointerSize pointer_size, const Visitor& visitor, MemberOffset member_offset)
1229       REQUIRES_SHARED(Locks::mutator_lock_);
1230 
1231   ALWAYS_INLINE static ArraySlice<ArtMethod> GetMethodsSliceRangeUnchecked(
1232       LengthPrefixedArray<ArtMethod>* methods,
1233       PointerSize pointer_size,
1234       uint32_t start_offset,
1235       uint32_t end_offset)
1236       REQUIRES_SHARED(Locks::mutator_lock_);
1237 
1238   template <bool throw_on_failure>
1239   bool ResolvedFieldAccessTest(ObjPtr<Class> access_to,
1240                                ArtField* field,
1241                                ObjPtr<DexCache> dex_cache,
1242                                uint32_t field_idx)
1243       REQUIRES_SHARED(Locks::mutator_lock_);
1244 
1245   template <bool throw_on_failure>
1246   bool ResolvedMethodAccessTest(ObjPtr<Class> access_to,
1247                                 ArtMethod* resolved_method,
1248                                 ObjPtr<DexCache> dex_cache,
1249                                 uint32_t method_idx,
1250                                 InvokeType throw_invoke_type)
1251       REQUIRES_SHARED(Locks::mutator_lock_);
1252 
1253   bool Implements(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
1254   bool IsArrayAssignableFromArray(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
1255   bool IsAssignableFromArray(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
1256 
1257   void CheckObjectAlloc() REQUIRES_SHARED(Locks::mutator_lock_);
1258 
1259   // Unchecked editions is for root visiting.
1260   LengthPrefixedArray<ArtField>* GetSFieldsPtrUnchecked() REQUIRES_SHARED(Locks::mutator_lock_);
1261   IterationRange<StrideIterator<ArtField>> GetSFieldsUnchecked()
1262       REQUIRES_SHARED(Locks::mutator_lock_);
1263   LengthPrefixedArray<ArtField>* GetIFieldsPtrUnchecked() REQUIRES_SHARED(Locks::mutator_lock_);
1264   IterationRange<StrideIterator<ArtField>> GetIFieldsUnchecked()
1265       REQUIRES_SHARED(Locks::mutator_lock_);
1266 
1267   // The index in the methods_ array where the first declared virtual method is.
1268   ALWAYS_INLINE uint32_t GetVirtualMethodsStartOffset() REQUIRES_SHARED(Locks::mutator_lock_);
1269 
1270   // The index in the methods_ array where the first direct method is.
1271   ALWAYS_INLINE uint32_t GetDirectMethodsStartOffset() REQUIRES_SHARED(Locks::mutator_lock_);
1272 
1273   // The index in the methods_ array where the first copied method is.
1274   ALWAYS_INLINE uint32_t GetCopiedMethodsStartOffset() REQUIRES_SHARED(Locks::mutator_lock_);
1275 
1276   bool ProxyDescriptorEquals(const char* match) REQUIRES_SHARED(Locks::mutator_lock_);
1277 
1278   template<VerifyObjectFlags kVerifyFlags>
1279   void GetAccessFlagsDCheck() REQUIRES_SHARED(Locks::mutator_lock_);
1280 
1281   void SetAccessFlagsDCheck(uint32_t new_access_flags) REQUIRES_SHARED(Locks::mutator_lock_);
1282 
1283   // Check that the pointer size matches the one in the class linker.
1284   ALWAYS_INLINE static void CheckPointerSize(PointerSize pointer_size);
1285 
1286   static MemberOffset EmbeddedVTableOffset(PointerSize pointer_size);
1287   template <bool kVisitNativeRoots,
1288             VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
1289             ReadBarrierOption kReadBarrierOption = kWithReadBarrier,
1290             typename Visitor>
1291   void VisitReferences(ObjPtr<Class> klass, const Visitor& visitor)
1292       REQUIRES_SHARED(Locks::mutator_lock_);
1293 
1294   // 'Class' Object Fields
1295   // Order governed by java field ordering. See art::ClassLinker::LinkFields.
1296 
1297   // Defining class loader, or null for the "bootstrap" system loader.
1298   HeapReference<ClassLoader> class_loader_;
1299 
1300   // For array classes, the component class object for instanceof/checkcast
1301   // (for String[][][], this will be String[][]). null for non-array classes.
1302   HeapReference<Class> component_type_;
1303 
1304   // DexCache of resolved constant pool entries (will be null for classes generated by the
1305   // runtime such as arrays and primitive classes).
1306   HeapReference<DexCache> dex_cache_;
1307 
1308   // Extraneous class data that is not always needed. This field is allocated lazily and may
1309   // only be set with 'this' locked. This is synchronized on 'this'.
1310   // TODO(allight) We should probably synchronize it on something external or handle allocation in
1311   // some other (safe) way to prevent possible deadlocks.
1312   HeapReference<ClassExt> ext_data_;
1313 
1314   // The interface table (iftable_) contains pairs of a interface class and an array of the
1315   // interface methods. There is one pair per interface supported by this class.  That means one
1316   // pair for each interface we support directly, indirectly via superclass, or indirectly via a
1317   // superinterface.  This will be null if neither we nor our superclass implement any interfaces.
1318   //
1319   // Why we need this: given "class Foo implements Face", declare "Face faceObj = new Foo()".
1320   // Invoke faceObj.blah(), where "blah" is part of the Face interface.  We can't easily use a
1321   // single vtable.
1322   //
1323   // For every interface a concrete class implements, we create an array of the concrete vtable_
1324   // methods for the methods in the interface.
1325   HeapReference<IfTable> iftable_;
1326 
1327   // Descriptor for the class such as "java.lang.Class" or "[C". Lazily initialized by ComputeName
1328   HeapReference<String> name_;
1329 
1330   // The superclass, or null if this is java.lang.Object or a primitive type.
1331   //
1332   // Note that interfaces have java.lang.Object as their
1333   // superclass. This doesn't match the expectations in JNI
1334   // GetSuperClass or java.lang.Class.getSuperClass() which need to
1335   // check for interfaces and return null.
1336   HeapReference<Class> super_class_;
1337 
1338   // Virtual method table (vtable), for use by "invoke-virtual".  The vtable from the superclass is
1339   // copied in, and virtual methods from our class either replace those from the super or are
1340   // appended. For abstract classes, methods may be created in the vtable that aren't in
1341   // virtual_ methods_ for miranda methods.
1342   HeapReference<PointerArray> vtable_;
1343 
1344   // instance fields
1345   //
1346   // These describe the layout of the contents of an Object.
1347   // Note that only the fields directly declared by this class are
1348   // listed in ifields; fields declared by a superclass are listed in
1349   // the superclass's Class.ifields.
1350   //
1351   // ArtFields are allocated as a length prefixed ArtField array, and not an array of pointers to
1352   // ArtFields.
1353   uint64_t ifields_;
1354 
1355   // Pointer to an ArtMethod length-prefixed array. All the methods where this class is the place
1356   // where they are logically defined. This includes all private, static, final and virtual methods
1357   // as well as inherited default methods and miranda methods.
1358   //
1359   // The slice methods_ [0, virtual_methods_offset_) are the direct (static, private, init) methods
1360   // declared by this class.
1361   //
1362   // The slice methods_ [virtual_methods_offset_, copied_methods_offset_) are the virtual methods
1363   // declared by this class.
1364   //
1365   // The slice methods_ [copied_methods_offset_, |methods_|) are the methods that are copied from
1366   // interfaces such as miranda or default methods. These are copied for resolution purposes as this
1367   // class is where they are (logically) declared as far as the virtual dispatch is concerned.
1368   //
1369   // Note that this field is used by the native debugger as the unique identifier for the type.
1370   uint64_t methods_;
1371 
1372   // Static fields length-prefixed array.
1373   uint64_t sfields_;
1374 
1375   // Access flags; low 16 bits are defined by VM spec.
1376   uint32_t access_flags_;
1377 
1378   // Class flags to help speed up visiting object references.
1379   uint32_t class_flags_;
1380 
1381   // Total size of the Class instance; used when allocating storage on gc heap.
1382   // See also object_size_.
1383   uint32_t class_size_;
1384 
1385   // Tid used to check for recursive <clinit> invocation.
1386   pid_t clinit_thread_id_;
1387   static_assert(sizeof(pid_t) == sizeof(int32_t), "java.lang.Class.clinitThreadId size check");
1388 
1389   // ClassDef index in dex file, -1 if no class definition such as an array.
1390   // TODO: really 16bits
1391   int32_t dex_class_def_idx_;
1392 
1393   // Type index in dex file.
1394   // TODO: really 16bits
1395   int32_t dex_type_idx_;
1396 
1397   // Number of instance fields that are object refs.
1398   uint32_t num_reference_instance_fields_;
1399 
1400   // Number of static fields that are object refs,
1401   uint32_t num_reference_static_fields_;
1402 
1403   // Total object size; used when allocating storage on gc heap.
1404   // (For interfaces and abstract classes this will be zero.)
1405   // See also class_size_.
1406   uint32_t object_size_;
1407 
1408   // Aligned object size for allocation fast path. The value is max uint32_t if the object is
1409   // uninitialized or finalizable. Not currently used for variable sized objects.
1410   uint32_t object_size_alloc_fast_path_;
1411 
1412   // The lower 16 bits contains a Primitive::Type value. The upper 16
1413   // bits contains the size shift of the primitive type.
1414   uint32_t primitive_type_;
1415 
1416   // Bitmap of offsets of ifields.
1417   uint32_t reference_instance_offsets_;
1418 
1419   // See the real definition in subtype_check_bits_and_status.h
1420   // typeof(status_) is actually SubtypeCheckBitsAndStatus.
1421   uint32_t status_;
1422 
1423   // The offset of the first virtual method that is copied from an interface. This includes miranda,
1424   // default, and default-conflict methods. Having a hard limit of ((2 << 16) - 1) for methods
1425   // defined on a single class is well established in Java so we will use only uint16_t's here.
1426   uint16_t copied_methods_offset_;
1427 
1428   // The offset of the first declared virtual methods in the methods_ array.
1429   uint16_t virtual_methods_offset_;
1430 
1431   // TODO: ?
1432   // initiating class loader list
1433   // NOTE: for classes with low serialNumber, these are unused, and the
1434   // values are kept in a table in gDvm.
1435   // InitiatingLoaderList initiating_loader_list_;
1436 
1437   // The following data exist in real class objects.
1438   // Embedded Imtable, for class object that's not an interface, fixed size.
1439   // ImTableEntry embedded_imtable_[0];
1440   // Embedded Vtable, for class object that's not an interface, variable size.
1441   // VTableEntry embedded_vtable_[0];
1442   // Static fields, variable size.
1443   // uint32_t fields_[0];
1444 
1445   ART_FRIEND_TEST(DexCacheTest, TestResolvedFieldAccess);  // For ResolvedFieldAccessTest
1446   friend struct art::ClassOffsets;  // for verifying offset information
1447   friend class Object;  // For VisitReferences
1448   DISALLOW_IMPLICIT_CONSTRUCTORS(Class);
1449 };
1450 
1451 }  // namespace mirror
1452 }  // namespace art
1453 
1454 #endif  // ART_RUNTIME_MIRROR_CLASS_H_
1455