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