class-inl.h revision 6286a97bea0f584342803a215550038852b24776 
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-inl.h"
23#include "art_method.h"
24#include "art_method-inl.h"
25#include "base/array_slice.h"
26#include "base/length_prefixed_array.h"
27#include "class_loader.h"
28#include "common_throws.h"
29#include "dex_cache.h"
30#include "dex_file.h"
31#include "gc/heap-inl.h"
32#include "iftable.h"
33#include "object_array-inl.h"
34#include "read_barrier-inl.h"
35#include "reference-inl.h"
36#include "runtime.h"
37#include "string.h"
38#include "utils.h"
39
40namespace art {
41namespace mirror {
42
43template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
44inline uint32_t Class::GetObjectSize() {
45  // Note: Extra parentheses to avoid the comma being interpreted as macro parameter separator.
46  DCHECK((!IsVariableSize<kVerifyFlags, kReadBarrierOption>())) << " class=" << PrettyTypeOf(this);
47  return GetField32(ObjectSizeOffset());
48}
49
50inline Class* Class::GetSuperClass() {
51  // Can only get super class for loaded classes (hack for when runtime is
52  // initializing)
53  DCHECK(IsLoaded() || IsErroneous() || !Runtime::Current()->IsStarted()) << IsLoaded();
54  return GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_));
55}
56
57inline ClassLoader* Class::GetClassLoader() {
58  return GetFieldObject<ClassLoader>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_));
59}
60
61template<VerifyObjectFlags kVerifyFlags>
62inline DexCache* Class::GetDexCache() {
63  return GetFieldObject<DexCache, kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_));
64}
65
66inline uint32_t Class::GetCopiedMethodsStartOffset() {
67  return GetFieldShort(OFFSET_OF_OBJECT_MEMBER(Class, copied_methods_offset_));
68}
69
70inline uint32_t Class::GetDirectMethodsStartOffset() {
71  return 0;
72}
73
74inline uint32_t Class::GetVirtualMethodsStartOffset() {
75  return GetFieldShort(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_offset_));
76}
77
78template<VerifyObjectFlags kVerifyFlags>
79inline ArraySlice<ArtMethod> Class::GetDirectMethodsSlice(size_t pointer_size) {
80  DCHECK(IsLoaded() || IsErroneous());
81  DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
82  return GetDirectMethodsSliceUnchecked(pointer_size);
83}
84
85inline ArraySlice<ArtMethod> Class::GetDirectMethodsSliceUnchecked(size_t pointer_size) {
86  return ArraySlice<ArtMethod>(GetMethodsPtr(),
87                               GetDirectMethodsStartOffset(),
88                               GetVirtualMethodsStartOffset(),
89                               ArtMethod::Size(pointer_size),
90                               ArtMethod::Alignment(pointer_size));
91}
92
93template<VerifyObjectFlags kVerifyFlags>
94inline ArraySlice<ArtMethod> Class::GetDeclaredMethodsSlice(size_t pointer_size) {
95  DCHECK(IsLoaded() || IsErroneous());
96  DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
97  return GetDeclaredMethodsSliceUnchecked(pointer_size);
98}
99
100inline ArraySlice<ArtMethod> Class::GetDeclaredMethodsSliceUnchecked(size_t pointer_size) {
101  return ArraySlice<ArtMethod>(GetMethodsPtr(),
102                               GetDirectMethodsStartOffset(),
103                               GetCopiedMethodsStartOffset(),
104                               ArtMethod::Size(pointer_size),
105                               ArtMethod::Alignment(pointer_size));
106}
107template<VerifyObjectFlags kVerifyFlags>
108inline ArraySlice<ArtMethod> Class::GetDeclaredVirtualMethodsSlice(size_t pointer_size) {
109  DCHECK(IsLoaded() || IsErroneous());
110  DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
111  return GetDeclaredVirtualMethodsSliceUnchecked(pointer_size);
112}
113
114inline ArraySlice<ArtMethod> Class::GetDeclaredVirtualMethodsSliceUnchecked(size_t pointer_size) {
115  return ArraySlice<ArtMethod>(GetMethodsPtr(),
116                               GetVirtualMethodsStartOffset(),
117                               GetCopiedMethodsStartOffset(),
118                               ArtMethod::Size(pointer_size),
119                               ArtMethod::Alignment(pointer_size));
120}
121
122template<VerifyObjectFlags kVerifyFlags>
123inline ArraySlice<ArtMethod> Class::GetVirtualMethodsSlice(size_t pointer_size) {
124  DCHECK(IsLoaded() || IsErroneous());
125  DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
126  return GetVirtualMethodsSliceUnchecked(pointer_size);
127}
128
129inline ArraySlice<ArtMethod> Class::GetVirtualMethodsSliceUnchecked(size_t pointer_size) {
130  LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
131  return ArraySlice<ArtMethod>(methods,
132                               GetVirtualMethodsStartOffset(),
133                               NumMethods(),
134                               ArtMethod::Size(pointer_size),
135                               ArtMethod::Alignment(pointer_size));
136}
137
138template<VerifyObjectFlags kVerifyFlags>
139inline ArraySlice<ArtMethod> Class::GetCopiedMethodsSlice(size_t pointer_size) {
140  DCHECK(IsLoaded() || IsErroneous());
141  DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
142  return GetCopiedMethodsSliceUnchecked(pointer_size);
143}
144
145inline ArraySlice<ArtMethod> Class::GetCopiedMethodsSliceUnchecked(size_t pointer_size) {
146  LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
147  return ArraySlice<ArtMethod>(methods,
148                               GetCopiedMethodsStartOffset(),
149                               NumMethods(),
150                               ArtMethod::Size(pointer_size),
151                               ArtMethod::Alignment(pointer_size));
152}
153
154inline LengthPrefixedArray<ArtMethod>* Class::GetMethodsPtr() {
155  return reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
156      GetField64(OFFSET_OF_OBJECT_MEMBER(Class, methods_)));
157}
158
159template<VerifyObjectFlags kVerifyFlags>
160inline ArraySlice<ArtMethod> Class::GetMethodsSlice(size_t pointer_size) {
161  DCHECK(IsLoaded() || IsErroneous());
162  LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
163  return ArraySlice<ArtMethod>(methods,
164                               0,
165                               NumMethods(),
166                               ArtMethod::Size(pointer_size),
167                               ArtMethod::Alignment(pointer_size));
168}
169
170
171inline uint32_t Class::NumMethods() {
172  LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
173  return (methods == nullptr) ? 0 : methods->size();
174}
175
176inline ArtMethod* Class::GetDirectMethodUnchecked(size_t i, size_t pointer_size) {
177  CheckPointerSize(pointer_size);
178  return &GetDirectMethodsSliceUnchecked(pointer_size).At(i);
179}
180
181inline ArtMethod* Class::GetDirectMethod(size_t i, size_t pointer_size) {
182  CheckPointerSize(pointer_size);
183  return &GetDirectMethodsSlice(pointer_size).At(i);
184}
185
186inline void Class::SetMethodsPtr(LengthPrefixedArray<ArtMethod>* new_methods,
187                                 uint32_t num_direct,
188                                 uint32_t num_virtual) {
189  DCHECK(GetMethodsPtr() == nullptr);
190  SetMethodsPtrUnchecked(new_methods, num_direct, num_virtual);
191}
192
193
194inline void Class::SetMethodsPtrUnchecked(LengthPrefixedArray<ArtMethod>* new_methods,
195                                          uint32_t num_direct,
196                                          uint32_t num_virtual) {
197  DCHECK_LE(num_direct + num_virtual, (new_methods == nullptr) ? 0 : new_methods->size());
198  SetMethodsPtrInternal(new_methods);
199  SetFieldShort<false>(OFFSET_OF_OBJECT_MEMBER(Class, copied_methods_offset_),
200                    dchecked_integral_cast<uint16_t>(num_direct + num_virtual));
201  SetFieldShort<false>(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_offset_),
202                       dchecked_integral_cast<uint16_t>(num_direct));
203}
204
205inline void Class::SetMethodsPtrInternal(LengthPrefixedArray<ArtMethod>* new_methods) {
206  SetField64<false>(OFFSET_OF_OBJECT_MEMBER(Class, methods_),
207                    reinterpret_cast<uint64_t>(new_methods));
208}
209
210template<VerifyObjectFlags kVerifyFlags>
211inline ArtMethod* Class::GetVirtualMethod(size_t i, size_t pointer_size) {
212  CheckPointerSize(pointer_size);
213  DCHECK(IsResolved<kVerifyFlags>() || IsErroneous<kVerifyFlags>())
214      << PrettyClass(this) << " status=" << GetStatus();
215  return GetVirtualMethodUnchecked(i, pointer_size);
216}
217
218inline ArtMethod* Class::GetVirtualMethodDuringLinking(size_t i, size_t pointer_size) {
219  CheckPointerSize(pointer_size);
220  DCHECK(IsLoaded() || IsErroneous());
221  return GetVirtualMethodUnchecked(i, pointer_size);
222}
223
224inline ArtMethod* Class::GetVirtualMethodUnchecked(size_t i, size_t pointer_size) {
225  CheckPointerSize(pointer_size);
226  return &GetVirtualMethodsSliceUnchecked(pointer_size).At(i);
227}
228
229inline PointerArray* Class::GetVTable() {
230  DCHECK(IsResolved() || IsErroneous());
231  return GetFieldObject<PointerArray>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_));
232}
233
234inline PointerArray* Class::GetVTableDuringLinking() {
235  DCHECK(IsLoaded() || IsErroneous());
236  return GetFieldObject<PointerArray>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_));
237}
238
239inline void Class::SetVTable(PointerArray* new_vtable) {
240  SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable);
241}
242
243inline MemberOffset Class::EmbeddedImTableEntryOffset(uint32_t i, size_t pointer_size) {
244  DCHECK_LT(i, kImtSize);
245  return MemberOffset(
246      EmbeddedImTableOffset(pointer_size).Uint32Value() + i * ImTableEntrySize(pointer_size));
247}
248
249inline ArtMethod* Class::GetEmbeddedImTableEntry(uint32_t i, size_t pointer_size) {
250  DCHECK(ShouldHaveEmbeddedImtAndVTable());
251  return GetFieldPtrWithSize<ArtMethod*>(
252      EmbeddedImTableEntryOffset(i, pointer_size), pointer_size);
253}
254
255inline void Class::SetEmbeddedImTableEntry(uint32_t i, ArtMethod* method, size_t pointer_size) {
256  DCHECK(ShouldHaveEmbeddedImtAndVTable());
257  SetFieldPtrWithSize<false>(EmbeddedImTableEntryOffset(i, pointer_size), method, pointer_size);
258}
259
260inline bool Class::HasVTable() {
261  return GetVTable() != nullptr || ShouldHaveEmbeddedImtAndVTable();
262}
263
264inline int32_t Class::GetVTableLength() {
265  if (ShouldHaveEmbeddedImtAndVTable()) {
266    return GetEmbeddedVTableLength();
267  }
268  return GetVTable() != nullptr ? GetVTable()->GetLength() : 0;
269}
270
271inline ArtMethod* Class::GetVTableEntry(uint32_t i, size_t pointer_size) {
272  if (ShouldHaveEmbeddedImtAndVTable()) {
273    return GetEmbeddedVTableEntry(i, pointer_size);
274  }
275  auto* vtable = GetVTable();
276  DCHECK(vtable != nullptr);
277  return vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size);
278}
279
280inline int32_t Class::GetEmbeddedVTableLength() {
281  return GetField32(MemberOffset(EmbeddedVTableLengthOffset()));
282}
283
284inline void Class::SetEmbeddedVTableLength(int32_t len) {
285  SetField32<false>(MemberOffset(EmbeddedVTableLengthOffset()), len);
286}
287
288inline MemberOffset Class::EmbeddedVTableEntryOffset(uint32_t i, size_t pointer_size) {
289  return MemberOffset(
290      EmbeddedVTableOffset(pointer_size).Uint32Value() + i * VTableEntrySize(pointer_size));
291}
292
293inline ArtMethod* Class::GetEmbeddedVTableEntry(uint32_t i, size_t pointer_size) {
294  return GetFieldPtrWithSize<ArtMethod*>(EmbeddedVTableEntryOffset(i, pointer_size), pointer_size);
295}
296
297inline void Class::SetEmbeddedVTableEntryUnchecked(
298    uint32_t i, ArtMethod* method, size_t pointer_size) {
299  SetFieldPtrWithSize<false>(EmbeddedVTableEntryOffset(i, pointer_size), method, pointer_size);
300}
301
302inline void Class::SetEmbeddedVTableEntry(uint32_t i, ArtMethod* method, size_t pointer_size) {
303  auto* vtable = GetVTableDuringLinking();
304  CHECK_EQ(method, vtable->GetElementPtrSize<ArtMethod*>(i, pointer_size));
305  SetEmbeddedVTableEntryUnchecked(i, method, pointer_size);
306}
307
308inline bool Class::Implements(Class* klass) {
309  DCHECK(klass != nullptr);
310  DCHECK(klass->IsInterface()) << PrettyClass(this);
311  // All interfaces implemented directly and by our superclass, and
312  // recursively all super-interfaces of those interfaces, are listed
313  // in iftable_, so we can just do a linear scan through that.
314  int32_t iftable_count = GetIfTableCount();
315  IfTable* iftable = GetIfTable();
316  for (int32_t i = 0; i < iftable_count; i++) {
317    if (iftable->GetInterface(i) == klass) {
318      return true;
319    }
320  }
321  return false;
322}
323
324// Determine whether "this" is assignable from "src", where both of these
325// are array classes.
326//
327// Consider an array class, e.g. Y[][], where Y is a subclass of X.
328//   Y[][]            = Y[][] --> true (identity)
329//   X[][]            = Y[][] --> true (element superclass)
330//   Y                = Y[][] --> false
331//   Y[]              = Y[][] --> false
332//   Object           = Y[][] --> true (everything is an object)
333//   Object[]         = Y[][] --> true
334//   Object[][]       = Y[][] --> true
335//   Object[][][]     = Y[][] --> false (too many []s)
336//   Serializable     = Y[][] --> true (all arrays are Serializable)
337//   Serializable[]   = Y[][] --> true
338//   Serializable[][] = Y[][] --> false (unless Y is Serializable)
339//
340// Don't forget about primitive types.
341//   Object[]         = int[] --> false
342//
343inline bool Class::IsArrayAssignableFromArray(Class* src) {
344  DCHECK(IsArrayClass())  << PrettyClass(this);
345  DCHECK(src->IsArrayClass()) << PrettyClass(src);
346  return GetComponentType()->IsAssignableFrom(src->GetComponentType());
347}
348
349inline bool Class::IsAssignableFromArray(Class* src) {
350  DCHECK(!IsInterface()) << PrettyClass(this);  // handled first in IsAssignableFrom
351  DCHECK(src->IsArrayClass()) << PrettyClass(src);
352  if (!IsArrayClass()) {
353    // If "this" is not also an array, it must be Object.
354    // src's super should be java_lang_Object, since it is an array.
355    Class* java_lang_Object = src->GetSuperClass();
356    DCHECK(java_lang_Object != nullptr) << PrettyClass(src);
357    DCHECK(java_lang_Object->GetSuperClass() == nullptr) << PrettyClass(src);
358    return this == java_lang_Object;
359  }
360  return IsArrayAssignableFromArray(src);
361}
362
363template <bool throw_on_failure, bool use_referrers_cache>
364inline bool Class::ResolvedFieldAccessTest(Class* access_to, ArtField* field,
365                                           uint32_t field_idx, DexCache* dex_cache) {
366  DCHECK_EQ(use_referrers_cache, dex_cache == nullptr);
367  if (UNLIKELY(!this->CanAccess(access_to))) {
368    // The referrer class can't access the field's declaring class but may still be able
369    // to access the field if the FieldId specifies an accessible subclass of the declaring
370    // class rather than the declaring class itself.
371    DexCache* referrer_dex_cache = use_referrers_cache ? this->GetDexCache() : dex_cache;
372    uint32_t class_idx = referrer_dex_cache->GetDexFile()->GetFieldId(field_idx).class_idx_;
373    // The referenced class has already been resolved with the field, get it from the dex cache.
374    Class* dex_access_to = referrer_dex_cache->GetResolvedType(class_idx);
375    DCHECK(dex_access_to != nullptr);
376    if (UNLIKELY(!this->CanAccess(dex_access_to))) {
377      if (throw_on_failure) {
378        ThrowIllegalAccessErrorClass(this, dex_access_to);
379      }
380      return false;
381    }
382    DCHECK_EQ(this->CanAccessMember(access_to, field->GetAccessFlags()),
383              this->CanAccessMember(dex_access_to, field->GetAccessFlags()));
384  }
385  if (LIKELY(this->CanAccessMember(access_to, field->GetAccessFlags()))) {
386    return true;
387  }
388  if (throw_on_failure) {
389    ThrowIllegalAccessErrorField(this, field);
390  }
391  return false;
392}
393
394template <bool throw_on_failure, bool use_referrers_cache, InvokeType throw_invoke_type>
395inline bool Class::ResolvedMethodAccessTest(Class* access_to, ArtMethod* method,
396                                            uint32_t method_idx, DexCache* dex_cache) {
397  static_assert(throw_on_failure || throw_invoke_type == kStatic, "Non-default throw invoke type");
398  DCHECK_EQ(use_referrers_cache, dex_cache == nullptr);
399  if (UNLIKELY(!this->CanAccess(access_to))) {
400    // The referrer class can't access the method's declaring class but may still be able
401    // to access the method if the MethodId specifies an accessible subclass of the declaring
402    // class rather than the declaring class itself.
403    DexCache* referrer_dex_cache = use_referrers_cache ? this->GetDexCache() : dex_cache;
404    uint32_t class_idx = referrer_dex_cache->GetDexFile()->GetMethodId(method_idx).class_idx_;
405    // The referenced class has already been resolved with the method, get it from the dex cache.
406    Class* dex_access_to = referrer_dex_cache->GetResolvedType(class_idx);
407    DCHECK(dex_access_to != nullptr);
408    if (UNLIKELY(!this->CanAccess(dex_access_to))) {
409      if (throw_on_failure) {
410        ThrowIllegalAccessErrorClassForMethodDispatch(this, dex_access_to,
411                                                      method, throw_invoke_type);
412      }
413      return false;
414    }
415    DCHECK_EQ(this->CanAccessMember(access_to, method->GetAccessFlags()),
416              this->CanAccessMember(dex_access_to, method->GetAccessFlags()));
417  }
418  if (LIKELY(this->CanAccessMember(access_to, method->GetAccessFlags()))) {
419    return true;
420  }
421  if (throw_on_failure) {
422    ThrowIllegalAccessErrorMethod(this, method);
423  }
424  return false;
425}
426
427inline bool Class::CanAccessResolvedField(Class* access_to, ArtField* field,
428                                          DexCache* dex_cache, uint32_t field_idx) {
429  return ResolvedFieldAccessTest<false, false>(access_to, field, field_idx, dex_cache);
430}
431
432inline bool Class::CheckResolvedFieldAccess(Class* access_to, ArtField* field,
433                                            uint32_t field_idx) {
434  return ResolvedFieldAccessTest<true, true>(access_to, field, field_idx, nullptr);
435}
436
437inline bool Class::CanAccessResolvedMethod(Class* access_to, ArtMethod* method,
438                                           DexCache* dex_cache, uint32_t method_idx) {
439  return ResolvedMethodAccessTest<false, false, kStatic>(access_to, method, method_idx, dex_cache);
440}
441
442template <InvokeType throw_invoke_type>
443inline bool Class::CheckResolvedMethodAccess(Class* access_to, ArtMethod* method,
444                                             uint32_t method_idx) {
445  return ResolvedMethodAccessTest<true, true, throw_invoke_type>(access_to, method, method_idx,
446                                                                 nullptr);
447}
448
449inline bool Class::IsSubClass(Class* klass) {
450  DCHECK(!IsInterface()) << PrettyClass(this);
451  DCHECK(!IsArrayClass()) << PrettyClass(this);
452  Class* current = this;
453  do {
454    if (current == klass) {
455      return true;
456    }
457    current = current->GetSuperClass();
458  } while (current != nullptr);
459  return false;
460}
461
462inline ArtMethod* Class::FindVirtualMethodForInterface(ArtMethod* method, size_t pointer_size) {
463  Class* declaring_class = method->GetDeclaringClass();
464  DCHECK(declaring_class != nullptr) << PrettyClass(this);
465  DCHECK(declaring_class->IsInterface()) << PrettyMethod(method);
466  // TODO cache to improve lookup speed
467  const int32_t iftable_count = GetIfTableCount();
468  IfTable* iftable = GetIfTable();
469  for (int32_t i = 0; i < iftable_count; i++) {
470    if (iftable->GetInterface(i) == declaring_class) {
471      return iftable->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>(
472          method->GetMethodIndex(), pointer_size);
473    }
474  }
475  return nullptr;
476}
477
478inline ArtMethod* Class::FindVirtualMethodForVirtual(ArtMethod* method, size_t pointer_size) {
479  // Only miranda or default methods may come from interfaces and be used as a virtual.
480  DCHECK(!method->GetDeclaringClass()->IsInterface() || method->IsDefault() || method->IsMiranda());
481  // The argument method may from a super class.
482  // Use the index to a potentially overridden one for this instance's class.
483  return GetVTableEntry(method->GetMethodIndex(), pointer_size);
484}
485
486inline ArtMethod* Class::FindVirtualMethodForSuper(ArtMethod* method, size_t pointer_size) {
487  DCHECK(!method->GetDeclaringClass()->IsInterface());
488  return GetSuperClass()->GetVTableEntry(method->GetMethodIndex(), pointer_size);
489}
490
491inline ArtMethod* Class::FindVirtualMethodForVirtualOrInterface(ArtMethod* method,
492                                                                size_t pointer_size) {
493  if (method->IsDirect()) {
494    return method;
495  }
496  if (method->GetDeclaringClass()->IsInterface() && !method->IsMiranda()) {
497    return FindVirtualMethodForInterface(method, pointer_size);
498  }
499  return FindVirtualMethodForVirtual(method, pointer_size);
500}
501
502inline IfTable* Class::GetIfTable() {
503  return GetFieldObject<IfTable>(OFFSET_OF_OBJECT_MEMBER(Class, iftable_));
504}
505
506inline int32_t Class::GetIfTableCount() {
507  IfTable* iftable = GetIfTable();
508  if (iftable == nullptr) {
509    return 0;
510  }
511  return iftable->Count();
512}
513
514inline void Class::SetIfTable(IfTable* new_iftable) {
515  SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), new_iftable);
516}
517
518inline LengthPrefixedArray<ArtField>* Class::GetIFieldsPtr() {
519  DCHECK(IsLoaded() || IsErroneous());
520  return GetFieldPtr<LengthPrefixedArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_));
521}
522
523inline MemberOffset Class::GetFirstReferenceInstanceFieldOffset() {
524  Class* super_class = GetSuperClass();
525  return (super_class != nullptr)
526      ? MemberOffset(RoundUp(super_class->GetObjectSize(),
527                             sizeof(mirror::HeapReference<mirror::Object>)))
528      : ClassOffset();
529}
530
531inline MemberOffset Class::GetFirstReferenceStaticFieldOffset(size_t pointer_size) {
532  DCHECK(IsResolved());
533  uint32_t base = sizeof(mirror::Class);  // Static fields come after the class.
534  if (ShouldHaveEmbeddedImtAndVTable()) {
535    // Static fields come after the embedded tables.
536    base = mirror::Class::ComputeClassSize(
537        true, GetEmbeddedVTableLength(), 0, 0, 0, 0, 0, pointer_size);
538  }
539  return MemberOffset(base);
540}
541
542inline MemberOffset Class::GetFirstReferenceStaticFieldOffsetDuringLinking(size_t pointer_size) {
543  DCHECK(IsLoaded());
544  uint32_t base = sizeof(mirror::Class);  // Static fields come after the class.
545  if (ShouldHaveEmbeddedImtAndVTable()) {
546    // Static fields come after the embedded tables.
547    base = mirror::Class::ComputeClassSize(true, GetVTableDuringLinking()->GetLength(),
548                                           0, 0, 0, 0, 0, pointer_size);
549  }
550  return MemberOffset(base);
551}
552
553inline void Class::SetIFieldsPtr(LengthPrefixedArray<ArtField>* new_ifields) {
554  DCHECK(GetIFieldsPtrUnchecked() == nullptr);
555  return SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields);
556}
557
558inline void Class::SetIFieldsPtrUnchecked(LengthPrefixedArray<ArtField>* new_ifields) {
559  SetFieldPtr<false, true, kVerifyNone>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields);
560}
561
562inline LengthPrefixedArray<ArtField>* Class::GetSFieldsPtrUnchecked() {
563  return GetFieldPtr<LengthPrefixedArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_));
564}
565
566inline LengthPrefixedArray<ArtField>* Class::GetIFieldsPtrUnchecked() {
567  return GetFieldPtr<LengthPrefixedArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_));
568}
569
570inline LengthPrefixedArray<ArtField>* Class::GetSFieldsPtr() {
571  DCHECK(IsLoaded() || IsErroneous()) << GetStatus();
572  return GetSFieldsPtrUnchecked();
573}
574
575inline void Class::SetSFieldsPtr(LengthPrefixedArray<ArtField>* new_sfields) {
576  DCHECK((IsRetired() && new_sfields == nullptr) ||
577         GetFieldPtr<ArtField*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_)) == nullptr);
578  SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields);
579}
580
581inline void Class::SetSFieldsPtrUnchecked(LengthPrefixedArray<ArtField>* new_sfields) {
582  SetFieldPtr<false, true, kVerifyNone>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields);
583}
584
585inline ArtField* Class::GetStaticField(uint32_t i) {
586  return &GetSFieldsPtr()->At(i);
587}
588
589inline ArtField* Class::GetInstanceField(uint32_t i) {
590  return &GetIFieldsPtr()->At(i);
591}
592
593template<VerifyObjectFlags kVerifyFlags>
594inline uint32_t Class::GetReferenceInstanceOffsets() {
595  DCHECK(IsResolved<kVerifyFlags>() || IsErroneous<kVerifyFlags>());
596  return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_));
597}
598
599inline void Class::SetClinitThreadId(pid_t new_clinit_thread_id) {
600  if (Runtime::Current()->IsActiveTransaction()) {
601    SetField32<true>(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), new_clinit_thread_id);
602  } else {
603    SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), new_clinit_thread_id);
604  }
605}
606
607template<VerifyObjectFlags kVerifyFlags>
608inline uint32_t Class::GetAccessFlags() {
609  // Check class is loaded/retired or this is java.lang.String that has a
610  // circularity issue during loading the names of its members
611  DCHECK(IsIdxLoaded<kVerifyFlags>() || IsRetired<kVerifyFlags>() ||
612         IsErroneous<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>() ||
613         this == String::GetJavaLangString())
614      << "IsIdxLoaded=" << IsIdxLoaded<kVerifyFlags>()
615      << " IsRetired=" << IsRetired<kVerifyFlags>()
616      << " IsErroneous=" <<
617          IsErroneous<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>()
618      << " IsString=" << (this == String::GetJavaLangString())
619      << " descriptor=" << PrettyDescriptor(this);
620  return GetField32<kVerifyFlags>(AccessFlagsOffset());
621}
622
623inline String* Class::GetName() {
624  return GetFieldObject<String>(OFFSET_OF_OBJECT_MEMBER(Class, name_));
625}
626
627inline void Class::SetName(String* name) {
628  if (Runtime::Current()->IsActiveTransaction()) {
629    SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Class, name_), name);
630  } else {
631    SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, name_), name);
632  }
633}
634
635template<VerifyObjectFlags kVerifyFlags>
636inline Primitive::Type Class::GetPrimitiveType() {
637  static_assert(sizeof(Primitive::Type) == sizeof(int32_t),
638                "art::Primitive::Type and int32_t have different sizes.");
639  int32_t v32 = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_));
640  Primitive::Type type = static_cast<Primitive::Type>(v32 & 0xFFFF);
641  DCHECK_EQ(static_cast<size_t>(v32 >> 16), Primitive::ComponentSizeShift(type));
642  return type;
643}
644
645template<VerifyObjectFlags kVerifyFlags>
646inline size_t Class::GetPrimitiveTypeSizeShift() {
647  static_assert(sizeof(Primitive::Type) == sizeof(int32_t),
648                "art::Primitive::Type and int32_t have different sizes.");
649  int32_t v32 = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_));
650  size_t size_shift = static_cast<Primitive::Type>(v32 >> 16);
651  DCHECK_EQ(size_shift, Primitive::ComponentSizeShift(static_cast<Primitive::Type>(v32 & 0xFFFF)));
652  return size_shift;
653}
654
655inline void Class::CheckObjectAlloc() {
656  DCHECK(!IsArrayClass())
657      << PrettyClass(this)
658      << "A array shouldn't be allocated through this "
659      << "as it requires a pre-fence visitor that sets the class size.";
660  DCHECK(!IsClassClass())
661      << PrettyClass(this)
662      << "A class object shouldn't be allocated through this "
663      << "as it requires a pre-fence visitor that sets the class size.";
664  DCHECK(!IsStringClass())
665      << PrettyClass(this)
666      << "A string shouldn't be allocated through this "
667      << "as it requires a pre-fence visitor that sets the class size.";
668  DCHECK(IsInstantiable()) << PrettyClass(this);
669  // TODO: decide whether we want this check. It currently fails during bootstrap.
670  // DCHECK(!Runtime::Current()->IsStarted() || IsInitializing()) << PrettyClass(this);
671  DCHECK_GE(this->object_size_, sizeof(Object));
672}
673
674template<bool kIsInstrumented, bool kCheckAddFinalizer>
675inline Object* Class::Alloc(Thread* self, gc::AllocatorType allocator_type) {
676  CheckObjectAlloc();
677  gc::Heap* heap = Runtime::Current()->GetHeap();
678  const bool add_finalizer = kCheckAddFinalizer && IsFinalizable();
679  if (!kCheckAddFinalizer) {
680    DCHECK(!IsFinalizable());
681  }
682  mirror::Object* obj =
683      heap->AllocObjectWithAllocator<kIsInstrumented, false>(self, this, this->object_size_,
684                                                             allocator_type, VoidFunctor());
685  if (add_finalizer && LIKELY(obj != nullptr)) {
686    heap->AddFinalizerReference(self, &obj);
687    if (UNLIKELY(self->IsExceptionPending())) {
688      // Failed to allocate finalizer reference, it means that the whole allocation failed.
689      obj = nullptr;
690    }
691  }
692  return obj;
693}
694
695inline Object* Class::AllocObject(Thread* self) {
696  return Alloc<true>(self, Runtime::Current()->GetHeap()->GetCurrentAllocator());
697}
698
699inline Object* Class::AllocNonMovableObject(Thread* self) {
700  return Alloc<true>(self, Runtime::Current()->GetHeap()->GetCurrentNonMovingAllocator());
701}
702
703inline uint32_t Class::ComputeClassSize(bool has_embedded_tables,
704                                        uint32_t num_vtable_entries,
705                                        uint32_t num_8bit_static_fields,
706                                        uint32_t num_16bit_static_fields,
707                                        uint32_t num_32bit_static_fields,
708                                        uint32_t num_64bit_static_fields,
709                                        uint32_t num_ref_static_fields,
710                                        size_t pointer_size) {
711  // Space used by java.lang.Class and its instance fields.
712  uint32_t size = sizeof(Class);
713  // Space used by embedded tables.
714  if (has_embedded_tables) {
715    const uint32_t embedded_imt_size = kImtSize * ImTableEntrySize(pointer_size);
716    const uint32_t embedded_vtable_size = num_vtable_entries * VTableEntrySize(pointer_size);
717    size = RoundUp(size + sizeof(uint32_t) /* embedded vtable len */, pointer_size) +
718        embedded_imt_size + embedded_vtable_size;
719  }
720
721  // Space used by reference statics.
722  size += num_ref_static_fields * sizeof(HeapReference<Object>);
723  if (!IsAligned<8>(size) && num_64bit_static_fields > 0) {
724    uint32_t gap = 8 - (size & 0x7);
725    size += gap;  // will be padded
726    // Shuffle 4-byte fields forward.
727    while (gap >= sizeof(uint32_t) && num_32bit_static_fields != 0) {
728      --num_32bit_static_fields;
729      gap -= sizeof(uint32_t);
730    }
731    // Shuffle 2-byte fields forward.
732    while (gap >= sizeof(uint16_t) && num_16bit_static_fields != 0) {
733      --num_16bit_static_fields;
734      gap -= sizeof(uint16_t);
735    }
736    // Shuffle byte fields forward.
737    while (gap >= sizeof(uint8_t) && num_8bit_static_fields != 0) {
738      --num_8bit_static_fields;
739      gap -= sizeof(uint8_t);
740    }
741  }
742  // Guaranteed to be at least 4 byte aligned. No need for further alignments.
743  // Space used for primitive static fields.
744  size += num_8bit_static_fields * sizeof(uint8_t) + num_16bit_static_fields * sizeof(uint16_t) +
745      num_32bit_static_fields * sizeof(uint32_t) + num_64bit_static_fields * sizeof(uint64_t);
746  return size;
747}
748
749template <typename Visitor>
750inline void Class::VisitReferences(mirror::Class* klass, const Visitor& visitor) {
751  VisitInstanceFieldsReferences(klass, visitor);
752  // Right after a class is allocated, but not yet loaded
753  // (kStatusNotReady, see ClassLinker::LoadClass()), GC may find it
754  // and scan it. IsTemp() may call Class::GetAccessFlags() but may
755  // fail in the DCHECK in Class::GetAccessFlags() because the class
756  // status is kStatusNotReady. To avoid it, rely on IsResolved()
757  // only. This is fine because a temp class never goes into the
758  // kStatusResolved state.
759  if (IsResolved()) {
760    // Temp classes don't ever populate imt/vtable or static fields and they are not even
761    // allocated with the right size for those. Also, unresolved classes don't have fields
762    // linked yet.
763    VisitStaticFieldsReferences(this, visitor);
764  }
765  // Since this class is reachable, we must also visit the associated roots when we scan it.
766  VisitNativeRoots(visitor, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
767}
768
769template<ReadBarrierOption kReadBarrierOption>
770inline bool Class::IsReferenceClass() const {
771  return this == Reference::GetJavaLangRefReference<kReadBarrierOption>();
772}
773
774template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
775inline bool Class::IsClassClass() {
776  Class* java_lang_Class = GetClass<kVerifyFlags, kReadBarrierOption>()->
777      template GetClass<kVerifyFlags, kReadBarrierOption>();
778  return this == java_lang_Class;
779}
780
781inline const DexFile& Class::GetDexFile() {
782  return *GetDexCache()->GetDexFile();
783}
784
785inline bool Class::DescriptorEquals(const char* match) {
786  if (IsArrayClass()) {
787    return match[0] == '[' && GetComponentType()->DescriptorEquals(match + 1);
788  } else if (IsPrimitive()) {
789    return strcmp(Primitive::Descriptor(GetPrimitiveType()), match) == 0;
790  } else if (IsProxyClass()) {
791    return ProxyDescriptorEquals(match);
792  } else {
793    const DexFile& dex_file = GetDexFile();
794    const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
795    return strcmp(dex_file.GetTypeDescriptor(type_id), match) == 0;
796  }
797}
798
799inline void Class::AssertInitializedOrInitializingInThread(Thread* self) {
800  if (kIsDebugBuild && !IsInitialized()) {
801    CHECK(IsInitializing()) << PrettyClass(this) << " is not initializing: " << GetStatus();
802    CHECK_EQ(GetClinitThreadId(), self->GetTid()) << PrettyClass(this)
803                                                  << " is initializing in a different thread";
804  }
805}
806
807inline ObjectArray<Class>* Class::GetInterfaces() {
808  CHECK(IsProxyClass());
809  // First static field.
810  auto* field = GetStaticField(0);
811  DCHECK_STREQ(field->GetName(), "interfaces");
812  MemberOffset field_offset = field->GetOffset();
813  return GetFieldObject<ObjectArray<Class>>(field_offset);
814}
815
816inline ObjectArray<ObjectArray<Class>>* Class::GetThrows() {
817  CHECK(IsProxyClass());
818  // Second static field.
819  auto* field = GetStaticField(1);
820  DCHECK_STREQ(field->GetName(), "throws");
821  MemberOffset field_offset = field->GetOffset();
822  return GetFieldObject<ObjectArray<ObjectArray<Class>>>(field_offset);
823}
824
825inline MemberOffset Class::GetDisableIntrinsicFlagOffset() {
826  CHECK(IsReferenceClass());
827  // First static field
828  auto* field = GetStaticField(0);
829  DCHECK_STREQ(field->GetName(), "disableIntrinsic");
830  return field->GetOffset();
831}
832
833inline MemberOffset Class::GetSlowPathFlagOffset() {
834  CHECK(IsReferenceClass());
835  // Second static field
836  auto* field = GetStaticField(1);
837  DCHECK_STREQ(field->GetName(), "slowPathEnabled");
838  return field->GetOffset();
839}
840
841inline bool Class::GetSlowPathEnabled() {
842  return GetFieldBoolean(GetSlowPathFlagOffset());
843}
844
845inline void Class::SetSlowPath(bool enabled) {
846  SetFieldBoolean<false, false>(GetSlowPathFlagOffset(), enabled);
847}
848
849inline void Class::InitializeClassVisitor::operator()(
850    mirror::Object* obj, size_t usable_size) const {
851  DCHECK_LE(class_size_, usable_size);
852  // Avoid AsClass as object is not yet in live bitmap or allocation stack.
853  mirror::Class* klass = down_cast<mirror::Class*>(obj);
854  // DCHECK(klass->IsClass());
855  klass->SetClassSize(class_size_);
856  klass->SetPrimitiveType(Primitive::kPrimNot);  // Default to not being primitive.
857  klass->SetDexClassDefIndex(DexFile::kDexNoIndex16);  // Default to no valid class def index.
858  klass->SetDexTypeIndex(DexFile::kDexNoIndex16);  // Default to no valid type index.
859}
860
861inline void Class::SetAccessFlags(uint32_t new_access_flags) {
862  // Called inside a transaction when setting pre-verified flag during boot image compilation.
863  if (Runtime::Current()->IsActiveTransaction()) {
864    SetField32<true>(AccessFlagsOffset(), new_access_flags);
865  } else {
866    SetField32<false>(AccessFlagsOffset(), new_access_flags);
867  }
868}
869
870inline void Class::SetClassFlags(uint32_t new_flags) {
871  if (Runtime::Current()->IsActiveTransaction()) {
872    SetField32<true>(OFFSET_OF_OBJECT_MEMBER(Class, class_flags_), new_flags);
873  } else {
874    SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, class_flags_), new_flags);
875  }
876}
877
878inline uint32_t Class::NumDirectInterfaces() {
879  if (IsPrimitive()) {
880    return 0;
881  } else if (IsArrayClass()) {
882    return 2;
883  } else if (IsProxyClass()) {
884    mirror::ObjectArray<mirror::Class>* interfaces = GetInterfaces();
885    return interfaces != nullptr ? interfaces->GetLength() : 0;
886  } else {
887    const DexFile::TypeList* interfaces = GetInterfaceTypeList();
888    if (interfaces == nullptr) {
889      return 0;
890    } else {
891      return interfaces->Size();
892    }
893  }
894}
895
896inline void Class::SetDexCacheStrings(GcRoot<String>* new_dex_cache_strings) {
897  SetFieldPtr<false>(DexCacheStringsOffset(), new_dex_cache_strings);
898}
899
900inline GcRoot<String>* Class::GetDexCacheStrings() {
901  return GetFieldPtr<GcRoot<String>*>(DexCacheStringsOffset());
902}
903
904template<class Visitor>
905void mirror::Class::VisitNativeRoots(Visitor& visitor, size_t pointer_size) {
906  for (ArtField& field : GetSFieldsUnchecked()) {
907    // Visit roots first in case the declaring class gets moved.
908    field.VisitRoots(visitor);
909    if (kIsDebugBuild && IsResolved()) {
910      CHECK_EQ(field.GetDeclaringClass(), this) << GetStatus();
911    }
912  }
913  for (ArtField& field : GetIFieldsUnchecked()) {
914    // Visit roots first in case the declaring class gets moved.
915    field.VisitRoots(visitor);
916    if (kIsDebugBuild && IsResolved()) {
917      CHECK_EQ(field.GetDeclaringClass(), this) << GetStatus();
918    }
919  }
920  for (ArtMethod& method : GetMethods(pointer_size)) {
921    method.VisitRoots(visitor, pointer_size);
922  }
923}
924
925inline IterationRange<StrideIterator<ArtMethod>> Class::GetDirectMethods(size_t pointer_size) {
926  CheckPointerSize(pointer_size);
927  return GetDirectMethodsSliceUnchecked(pointer_size).AsRange();
928}
929
930inline IterationRange<StrideIterator<ArtMethod>> Class::GetDeclaredMethods(
931      size_t pointer_size) {
932  CheckPointerSize(pointer_size);
933  return GetDeclaredMethodsSliceUnchecked(pointer_size).AsRange();
934}
935
936inline IterationRange<StrideIterator<ArtMethod>> Class::GetDeclaredVirtualMethods(
937      size_t pointer_size) {
938  CheckPointerSize(pointer_size);
939  return GetDeclaredVirtualMethodsSliceUnchecked(pointer_size).AsRange();
940}
941
942inline IterationRange<StrideIterator<ArtMethod>> Class::GetVirtualMethods(size_t pointer_size) {
943  CheckPointerSize(pointer_size);
944  return GetVirtualMethodsSliceUnchecked(pointer_size).AsRange();
945}
946
947inline IterationRange<StrideIterator<ArtMethod>> Class::GetCopiedMethods(size_t pointer_size) {
948  CheckPointerSize(pointer_size);
949  return GetCopiedMethodsSliceUnchecked(pointer_size).AsRange();
950}
951
952
953inline IterationRange<StrideIterator<ArtMethod>> Class::GetMethods(size_t pointer_size) {
954  CheckPointerSize(pointer_size);
955  return MakeIterationRangeFromLengthPrefixedArray(GetMethodsPtr(),
956                                                   ArtMethod::Size(pointer_size),
957                                                   ArtMethod::Alignment(pointer_size));
958}
959
960inline IterationRange<StrideIterator<ArtField>> Class::GetIFields() {
961  return MakeIterationRangeFromLengthPrefixedArray(GetIFieldsPtr());
962}
963
964inline IterationRange<StrideIterator<ArtField>> Class::GetSFields() {
965  return MakeIterationRangeFromLengthPrefixedArray(GetSFieldsPtr());
966}
967
968inline IterationRange<StrideIterator<ArtField>> Class::GetIFieldsUnchecked() {
969  return MakeIterationRangeFromLengthPrefixedArray(GetIFieldsPtrUnchecked());
970}
971
972inline IterationRange<StrideIterator<ArtField>> Class::GetSFieldsUnchecked() {
973  return MakeIterationRangeFromLengthPrefixedArray(GetSFieldsPtrUnchecked());
974}
975
976inline MemberOffset Class::EmbeddedImTableOffset(size_t pointer_size) {
977  CheckPointerSize(pointer_size);
978  // Round up since we want the embedded imt and vtable to be pointer size aligned in case 64 bits.
979  // Add 32 bits for embedded vtable length.
980  return MemberOffset(
981      RoundUp(EmbeddedVTableLengthOffset().Uint32Value() + sizeof(uint32_t), pointer_size));
982}
983
984inline MemberOffset Class::EmbeddedVTableOffset(size_t pointer_size) {
985  CheckPointerSize(pointer_size);
986  return MemberOffset(EmbeddedImTableOffset(pointer_size).Uint32Value() +
987                      kImtSize * ImTableEntrySize(pointer_size));
988}
989
990inline void Class::CheckPointerSize(size_t pointer_size) {
991  DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
992  DCHECK_EQ(pointer_size, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
993}
994
995template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
996inline Class* Class::GetComponentType() {
997  return GetFieldObject<Class, kVerifyFlags, kReadBarrierOption>(ComponentTypeOffset());
998}
999
1000template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
1001inline bool Class::IsArrayClass() {
1002  return GetComponentType<kVerifyFlags, kReadBarrierOption>() != nullptr;
1003}
1004
1005inline bool Class::IsAssignableFrom(Class* src) {
1006  DCHECK(src != nullptr);
1007  if (this == src) {
1008    // Can always assign to things of the same type.
1009    return true;
1010  } else if (IsObjectClass()) {
1011    // Can assign any reference to java.lang.Object.
1012    return !src->IsPrimitive();
1013  } else if (IsInterface()) {
1014    return src->Implements(this);
1015  } else if (src->IsArrayClass()) {
1016    return IsAssignableFromArray(src);
1017  } else {
1018    return !src->IsInterface() && src->IsSubClass(this);
1019  }
1020}
1021
1022inline uint32_t Class::NumDirectMethods() {
1023  return GetVirtualMethodsStartOffset();
1024}
1025
1026inline uint32_t Class::NumDeclaredVirtualMethods() {
1027  return GetCopiedMethodsStartOffset() - GetVirtualMethodsStartOffset();
1028}
1029
1030inline uint32_t Class::NumVirtualMethods() {
1031  return NumMethods() - GetVirtualMethodsStartOffset();
1032}
1033
1034inline uint32_t Class::NumInstanceFields() {
1035  LengthPrefixedArray<ArtField>* arr = GetIFieldsPtrUnchecked();
1036  return arr != nullptr ? arr->size() : 0u;
1037}
1038
1039inline uint32_t Class::NumStaticFields() {
1040  LengthPrefixedArray<ArtField>* arr = GetSFieldsPtrUnchecked();
1041  return arr != nullptr ? arr->size() : 0u;
1042}
1043
1044template <typename Visitor>
1045inline void Class::FixupNativePointers(mirror::Class* dest,
1046                                       size_t pointer_size,
1047                                       const Visitor& visitor) {
1048  // Update the field arrays.
1049  LengthPrefixedArray<ArtField>* const sfields = GetSFieldsPtr();
1050  LengthPrefixedArray<ArtField>* const new_sfields = visitor(sfields);
1051  if (sfields != new_sfields) {
1052    dest->SetSFieldsPtrUnchecked(new_sfields);
1053  }
1054  LengthPrefixedArray<ArtField>* const ifields = GetIFieldsPtr();
1055  LengthPrefixedArray<ArtField>* const new_ifields = visitor(ifields);
1056  if (ifields != new_ifields) {
1057    dest->SetIFieldsPtrUnchecked(new_ifields);
1058  }
1059  // Update method array.
1060  LengthPrefixedArray<ArtMethod>* methods = GetMethodsPtr();
1061  LengthPrefixedArray<ArtMethod>* new_methods = visitor(methods);
1062  if (methods != new_methods) {
1063    dest->SetMethodsPtrInternal(new_methods);
1064  }
1065  // Update dex cache strings.
1066  GcRoot<mirror::String>* strings = GetDexCacheStrings();
1067  GcRoot<mirror::String>* new_strings = visitor(strings);
1068  if (strings != new_strings) {
1069    dest->SetDexCacheStrings(new_strings);
1070  }
1071  // Fix up embedded tables.
1072  if (!IsTemp() && ShouldHaveEmbeddedImtAndVTable()) {
1073    for (int32_t i = 0, count = GetEmbeddedVTableLength(); i < count; ++i) {
1074      ArtMethod* method = GetEmbeddedVTableEntry(i, pointer_size);
1075      ArtMethod* new_method = visitor(method);
1076      if (method != new_method) {
1077        dest->SetEmbeddedVTableEntryUnchecked(i, new_method, pointer_size);
1078      }
1079    }
1080    for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
1081      ArtMethod* method = GetEmbeddedImTableEntry(i, pointer_size);
1082      ArtMethod* new_method = visitor(method);
1083      if (method != new_method) {
1084        dest->SetEmbeddedImTableEntry(i, new_method, pointer_size);
1085      }
1086    }
1087  }
1088}
1089
1090}  // namespace mirror
1091}  // namespace art
1092
1093#endif  // ART_RUNTIME_MIRROR_CLASS_INL_H_
1094