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