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