class.h revision 1fb463e42cf1d67595cff66d19c0f99e3046f4c4
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 "dex_file.h" 21#include "gc_root.h" 22#include "gc/allocator_type.h" 23#include "invoke_type.h" 24#include "modifiers.h" 25#include "object.h" 26#include "object_array.h" 27#include "object_callbacks.h" 28#include "primitive.h" 29#include "read_barrier_option.h" 30 31/* 32 * A magic value for refOffsets. Ignore the bits and walk the super 33 * chain when this is the value. 34 * [This is an unlikely "natural" value, since it would be 30 non-ref instance 35 * fields followed by 2 ref instance fields.] 36 */ 37#define CLASS_WALK_SUPER 3U 38#define CLASS_BITS_PER_WORD (sizeof(uint32_t) * 8) 39#define CLASS_OFFSET_ALIGNMENT 4 40#define CLASS_HIGH_BIT (1U << (CLASS_BITS_PER_WORD - 1)) 41/* 42 * Given an offset, return the bit number which would encode that offset. 43 * Local use only. 44 */ 45#define _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) \ 46 ((unsigned int)(byteOffset) / \ 47 CLASS_OFFSET_ALIGNMENT) 48/* 49 * Is the given offset too large to be encoded? 50 */ 51#define CLASS_CAN_ENCODE_OFFSET(byteOffset) \ 52 (_CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) < CLASS_BITS_PER_WORD) 53/* 54 * Return a single bit, encoding the offset. 55 * Undefined if the offset is too large, as defined above. 56 */ 57#define CLASS_BIT_FROM_OFFSET(byteOffset) \ 58 (CLASS_HIGH_BIT >> _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset)) 59/* 60 * Return an offset, given a bit number as returned from CLZ. 61 */ 62#define CLASS_OFFSET_FROM_CLZ(rshift) \ 63 MemberOffset((static_cast<int>(rshift) * CLASS_OFFSET_ALIGNMENT)) 64 65namespace art { 66 67struct ClassOffsets; 68class Signature; 69class StringPiece; 70template<size_t kNumReferences> class PACKED(4) StackHandleScope; 71 72namespace mirror { 73 74class ArtField; 75class ArtMethod; 76class ClassLoader; 77class DexCache; 78class IfTable; 79 80// C++ mirror of java.lang.Class 81class MANAGED Class FINAL : public Object { 82 public: 83 // Interface method table size. Increasing this value reduces the chance of two interface methods 84 // colliding in the interface method table but increases the size of classes that implement 85 // (non-marker) interfaces. 86 static constexpr size_t kImtSize = 64; 87 88 // imtable entry embedded in class object. 89 struct MANAGED ImTableEntry { 90 HeapReference<ArtMethod> method; 91 }; 92 93 // vtable entry embedded in class object. 94 struct MANAGED VTableEntry { 95 HeapReference<ArtMethod> method; 96 }; 97 98 // Class Status 99 // 100 // kStatusNotReady: If a Class cannot be found in the class table by 101 // FindClass, it allocates an new one with AllocClass in the 102 // kStatusNotReady and calls LoadClass. Note if it does find a 103 // class, it may not be kStatusResolved and it will try to push it 104 // forward toward kStatusResolved. 105 // 106 // kStatusIdx: LoadClass populates with Class with information from 107 // the DexFile, moving the status to kStatusIdx, indicating that the 108 // Class value in super_class_ has not been populated. The new Class 109 // can then be inserted into the classes table. 110 // 111 // kStatusLoaded: After taking a lock on Class, the ClassLinker will 112 // attempt to move a kStatusIdx class forward to kStatusLoaded by 113 // using ResolveClass to initialize the super_class_ and ensuring the 114 // interfaces are resolved. 115 // 116 // kStatusResolving: Class is just cloned with the right size from 117 // temporary class that's acting as a placeholder for linking. The old 118 // class will be retired. New class is set to this status first before 119 // moving on to being resolved. 120 // 121 // kStatusResolved: Still holding the lock on Class, the ClassLinker 122 // shows linking is complete and fields of the Class populated by making 123 // it kStatusResolved. Java allows circularities of the form where a super 124 // class has a field that is of the type of the sub class. We need to be able 125 // to fully resolve super classes while resolving types for fields. 126 // 127 // kStatusRetryVerificationAtRuntime: The verifier sets a class to 128 // this state if it encounters a soft failure at compile time. This 129 // often happens when there are unresolved classes in other dex 130 // files, and this status marks a class as needing to be verified 131 // again at runtime. 132 // 133 // TODO: Explain the other states 134 enum Status { 135 kStatusRetired = -2, 136 kStatusError = -1, 137 kStatusNotReady = 0, 138 kStatusIdx = 1, // Loaded, DEX idx in super_class_type_idx_ and interfaces_type_idx_. 139 kStatusLoaded = 2, // DEX idx values resolved. 140 kStatusResolving = 3, // Just cloned from temporary class object. 141 kStatusResolved = 4, // Part of linking. 142 kStatusVerifying = 5, // In the process of being verified. 143 kStatusRetryVerificationAtRuntime = 6, // Compile time verification failed, retry at runtime. 144 kStatusVerifyingAtRuntime = 7, // Retrying verification at runtime. 145 kStatusVerified = 8, // Logically part of linking; done pre-init. 146 kStatusInitializing = 9, // Class init in progress. 147 kStatusInitialized = 10, // Ready to go. 148 kStatusMax = 11, 149 }; 150 151 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 152 Status GetStatus() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 153 COMPILE_ASSERT(sizeof(Status) == sizeof(uint32_t), size_of_status_not_uint32); 154 return static_cast<Status>( 155 GetField32Volatile<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, status_))); 156 } 157 158 void SetStatus(Status new_status, Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 159 160 static MemberOffset StatusOffset() { 161 return OFFSET_OF_OBJECT_MEMBER(Class, status_); 162 } 163 164 // Returns true if the class has been retired. 165 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 166 bool IsRetired() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 167 return GetStatus<kVerifyFlags>() == kStatusRetired; 168 } 169 170 // Returns true if the class has failed to link. 171 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 172 bool IsErroneous() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 173 return GetStatus<kVerifyFlags>() == kStatusError; 174 } 175 176 // Returns true if the class has been loaded. 177 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 178 bool IsIdxLoaded() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 179 return GetStatus<kVerifyFlags>() >= kStatusIdx; 180 } 181 182 // Returns true if the class has been loaded. 183 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 184 bool IsLoaded() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 185 return GetStatus<kVerifyFlags>() >= kStatusLoaded; 186 } 187 188 // Returns true if the class has been linked. 189 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 190 bool IsResolved() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 191 return GetStatus<kVerifyFlags>() >= kStatusResolved; 192 } 193 194 // Returns true if the class was compile-time verified. 195 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 196 bool IsCompileTimeVerified() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 197 return GetStatus<kVerifyFlags>() >= kStatusRetryVerificationAtRuntime; 198 } 199 200 // Returns true if the class has been verified. 201 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 202 bool IsVerified() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 203 return GetStatus<kVerifyFlags>() >= kStatusVerified; 204 } 205 206 // Returns true if the class is initializing. 207 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 208 bool IsInitializing() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 209 return GetStatus<kVerifyFlags>() >= kStatusInitializing; 210 } 211 212 // Returns true if the class is initialized. 213 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 214 bool IsInitialized() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 215 return GetStatus<kVerifyFlags>() == kStatusInitialized; 216 } 217 218 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 219 ALWAYS_INLINE uint32_t GetAccessFlags() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 220 221 void SetAccessFlags(uint32_t new_access_flags) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 222 223 // Returns true if the class is an interface. 224 ALWAYS_INLINE bool IsInterface() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 225 return (GetAccessFlags() & kAccInterface) != 0; 226 } 227 228 // Returns true if the class is declared public. 229 ALWAYS_INLINE bool IsPublic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 230 return (GetAccessFlags() & kAccPublic) != 0; 231 } 232 233 // Returns true if the class is declared final. 234 ALWAYS_INLINE bool IsFinal() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 235 return (GetAccessFlags() & kAccFinal) != 0; 236 } 237 238 ALWAYS_INLINE bool IsFinalizable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 239 return (GetAccessFlags() & kAccClassIsFinalizable) != 0; 240 } 241 242 ALWAYS_INLINE void SetFinalizable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 243 uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_)); 244 SetAccessFlags(flags | kAccClassIsFinalizable); 245 } 246 247 // Returns true if the class is abstract. 248 ALWAYS_INLINE bool IsAbstract() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 249 return (GetAccessFlags() & kAccAbstract) != 0; 250 } 251 252 // Returns true if the class is an annotation. 253 ALWAYS_INLINE bool IsAnnotation() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 254 return (GetAccessFlags() & kAccAnnotation) != 0; 255 } 256 257 // Returns true if the class is synthetic. 258 ALWAYS_INLINE bool IsSynthetic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 259 return (GetAccessFlags() & kAccSynthetic) != 0; 260 } 261 262 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 263 bool IsTypeOfReferenceClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 264 return (GetAccessFlags<kVerifyFlags>() & kAccClassIsReference) != 0; 265 } 266 267 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 268 bool IsWeakReferenceClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 269 return (GetAccessFlags<kVerifyFlags>() & kAccClassIsWeakReference) != 0; 270 } 271 272 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 273 bool IsSoftReferenceClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 274 return (GetAccessFlags<kVerifyFlags>() & kAccReferenceFlagsMask) == kAccClassIsReference; 275 } 276 277 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 278 bool IsFinalizerReferenceClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 279 return (GetAccessFlags<kVerifyFlags>() & kAccClassIsFinalizerReference) != 0; 280 } 281 282 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 283 bool IsPhantomReferenceClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 284 return (GetAccessFlags<kVerifyFlags>() & kAccClassIsPhantomReference) != 0; 285 } 286 287 // Can references of this type be assigned to by things of another type? For non-array types 288 // this is a matter of whether sub-classes may exist - which they can't if the type is final. 289 // For array classes, where all the classes are final due to there being no sub-classes, an 290 // Object[] may be assigned to by a String[] but a String[] may not be assigned to by other 291 // types as the component is final. 292 bool CannotBeAssignedFromOtherTypes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 293 if (!IsArrayClass()) { 294 return IsFinal(); 295 } else { 296 Class* component = GetComponentType(); 297 if (component->IsPrimitive()) { 298 return true; 299 } else { 300 return component->CannotBeAssignedFromOtherTypes(); 301 } 302 } 303 } 304 305 // Returns true if this class is the placeholder and should retire and 306 // be replaced with a class with the right size for embedded imt/vtable. 307 bool IsTemp() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 308 Status s = GetStatus(); 309 return s < Status::kStatusResolving && ShouldHaveEmbeddedImtAndVTable(); 310 } 311 312 String* GetName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Returns the cached name. 313 void SetName(String* name) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Sets the cached name. 314 // Computes the name, then sets the cached value. 315 static String* ComputeName(Handle<Class> h_this) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 316 317 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 318 bool IsProxyClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 319 // Read access flags without using getter as whether something is a proxy can be check in 320 // any loaded state 321 // TODO: switch to a check if the super class is java.lang.reflect.Proxy? 322 uint32_t access_flags = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_)); 323 return (access_flags & kAccClassIsProxy) != 0; 324 } 325 326 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 327 Primitive::Type GetPrimitiveType() ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 328 329 void SetPrimitiveType(Primitive::Type new_type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 330 DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t)); 331 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), new_type); 332 } 333 334 // Returns true if the class is a primitive type. 335 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 336 bool IsPrimitive() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 337 return GetPrimitiveType<kVerifyFlags>() != Primitive::kPrimNot; 338 } 339 340 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 341 bool IsPrimitiveBoolean() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 342 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimBoolean; 343 } 344 345 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 346 bool IsPrimitiveByte() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 347 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimByte; 348 } 349 350 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 351 bool IsPrimitiveChar() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 352 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimChar; 353 } 354 355 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 356 bool IsPrimitiveShort() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 357 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimShort; 358 } 359 360 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 361 bool IsPrimitiveInt() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 362 return GetPrimitiveType() == Primitive::kPrimInt; 363 } 364 365 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 366 bool IsPrimitiveLong() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 367 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimLong; 368 } 369 370 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 371 bool IsPrimitiveFloat() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 372 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimFloat; 373 } 374 375 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 376 bool IsPrimitiveDouble() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 377 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimDouble; 378 } 379 380 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 381 bool IsPrimitiveVoid() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 382 return GetPrimitiveType<kVerifyFlags>() == Primitive::kPrimVoid; 383 } 384 385 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 386 bool IsPrimitiveArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 387 return IsArrayClass<kVerifyFlags>() && 388 GetComponentType<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>()-> 389 IsPrimitive(); 390 } 391 392 // Depth of class from java.lang.Object 393 uint32_t Depth() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 394 uint32_t depth = 0; 395 for (Class* klass = this; klass->GetSuperClass() != NULL; klass = klass->GetSuperClass()) { 396 depth++; 397 } 398 return depth; 399 } 400 401 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, 402 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 403 bool IsArrayClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 404 return GetComponentType<kVerifyFlags, kReadBarrierOption>() != NULL; 405 } 406 407 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, 408 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 409 bool IsClassClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 410 411 bool IsStringClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 412 413 bool IsThrowableClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 414 415 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 416 bool IsArtFieldClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 417 418 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 419 bool IsArtMethodClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 420 421 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 422 bool IsReferenceClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 423 424 static MemberOffset ComponentTypeOffset() { 425 return OFFSET_OF_OBJECT_MEMBER(Class, component_type_); 426 } 427 428 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, 429 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 430 Class* GetComponentType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 431 return GetFieldObject<Class, kVerifyFlags, kReadBarrierOption>(ComponentTypeOffset()); 432 } 433 434 void SetComponentType(Class* new_component_type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 435 DCHECK(GetComponentType() == NULL); 436 DCHECK(new_component_type != NULL); 437 // Component type is invariant: use non-transactional mode without check. 438 SetFieldObject<false, false>(ComponentTypeOffset(), new_component_type); 439 } 440 441 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 442 size_t GetComponentSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 443 return Primitive::ComponentSize( 444 GetComponentType<kDefaultVerifyFlags, kReadBarrierOption>()->GetPrimitiveType()); 445 } 446 447 bool IsObjectClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 448 return !IsPrimitive() && GetSuperClass() == NULL; 449 } 450 bool IsInstantiable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 451 return (!IsPrimitive() && !IsInterface() && !IsAbstract()) || ((IsAbstract()) && IsArrayClass()); 452 } 453 454 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 455 bool IsObjectArrayClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 456 return GetComponentType<kVerifyFlags>() != nullptr && !GetComponentType<kVerifyFlags>()->IsPrimitive(); 457 } 458 459 // Creates a raw object instance but does not invoke the default constructor. 460 template<bool kIsInstrumented, bool kCheckAddFinalizer = true> 461 ALWAYS_INLINE Object* Alloc(Thread* self, gc::AllocatorType allocator_type) 462 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 463 464 Object* AllocObject(Thread* self) 465 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 466 Object* AllocNonMovableObject(Thread* self) 467 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 468 469 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, 470 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 471 bool IsVariableSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 472 // Classes and arrays vary in size, and so the object_size_ field cannot 473 // be used to Get their instance size 474 return IsClassClass<kVerifyFlags, kReadBarrierOption>() || 475 IsArrayClass<kVerifyFlags, kReadBarrierOption>(); 476 } 477 478 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, 479 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 480 uint32_t SizeOf() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 481 return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, class_size_)); 482 } 483 484 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 485 uint32_t GetClassSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 486 return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, class_size_)); 487 } 488 489 void SetClassSize(uint32_t new_class_size) 490 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 491 492 // Compute how many bytes would be used a class with the given elements. 493 static uint32_t ComputeClassSize(bool has_embedded_tables, 494 uint32_t num_vtable_entries, 495 uint32_t num_32bit_static_fields, 496 uint32_t num_64bit_static_fields, 497 uint32_t num_ref_static_fields); 498 499 // The size of java.lang.Class.class. 500 static uint32_t ClassClassSize() { 501 // The number of vtable entries in java.lang.Class. 502 uint32_t vtable_entries = Object::kVTableLength + 66; 503 return ComputeClassSize(true, vtable_entries, 0, 1, 0); 504 } 505 506 // The size of a java.lang.Class representing a primitive such as int.class. 507 static uint32_t PrimitiveClassSize() { 508 return ComputeClassSize(false, 0, 0, 0, 0); 509 } 510 511 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, 512 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 513 uint32_t GetObjectSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 514 515 void SetObjectSize(uint32_t new_object_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 516 DCHECK(!IsVariableSize()); 517 // Not called within a transaction. 518 return SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), new_object_size); 519 } 520 521 // Returns true if this class is in the same packages as that class. 522 bool IsInSamePackage(Class* that) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 523 524 static bool IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2); 525 526 // Returns true if this class can access that class. 527 bool CanAccess(Class* that) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 528 return that->IsPublic() || this->IsInSamePackage(that); 529 } 530 531 // Can this class access a member in the provided class with the provided member access flags? 532 // Note that access to the class isn't checked in case the declaring class is protected and the 533 // method has been exposed by a public sub-class 534 bool CanAccessMember(Class* access_to, uint32_t member_flags) 535 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 536 // Classes can access all of their own members 537 if (this == access_to) { 538 return true; 539 } 540 // Public members are trivially accessible 541 if (member_flags & kAccPublic) { 542 return true; 543 } 544 // Private members are trivially not accessible 545 if (member_flags & kAccPrivate) { 546 return false; 547 } 548 // Check for protected access from a sub-class, which may or may not be in the same package. 549 if (member_flags & kAccProtected) { 550 if (!this->IsInterface() && this->IsSubClass(access_to)) { 551 return true; 552 } 553 } 554 // Allow protected access from other classes in the same package. 555 return this->IsInSamePackage(access_to); 556 } 557 558 // Can this class access a resolved field? 559 // Note that access to field's class is checked and this may require looking up the class 560 // referenced by the FieldId in the DexFile in case the declaring class is inaccessible. 561 bool CanAccessResolvedField(Class* access_to, ArtField* field, 562 DexCache* dex_cache, uint32_t field_idx) 563 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 564 bool CheckResolvedFieldAccess(Class* access_to, ArtField* field, 565 uint32_t field_idx) 566 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 567 568 // Can this class access a resolved method? 569 // Note that access to methods's class is checked and this may require looking up the class 570 // referenced by the MethodId in the DexFile in case the declaring class is inaccessible. 571 bool CanAccessResolvedMethod(Class* access_to, ArtMethod* resolved_method, 572 DexCache* dex_cache, uint32_t method_idx) 573 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 574 template <InvokeType throw_invoke_type> 575 bool CheckResolvedMethodAccess(Class* access_to, ArtMethod* resolved_method, 576 uint32_t method_idx) 577 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 578 579 bool IsSubClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 580 581 // Can src be assigned to this class? For example, String can be assigned to Object (by an 582 // upcast), however, an Object cannot be assigned to a String as a potentially exception throwing 583 // downcast would be necessary. Similarly for interfaces, a class that implements (or an interface 584 // that extends) another can be assigned to its parent, but not vice-versa. All Classes may assign 585 // to themselves. Classes for primitive types may not assign to each other. 586 ALWAYS_INLINE bool IsAssignableFrom(Class* src) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 587 DCHECK(src != NULL); 588 if (this == src) { 589 // Can always assign to things of the same type. 590 return true; 591 } else if (IsObjectClass()) { 592 // Can assign any reference to java.lang.Object. 593 return !src->IsPrimitive(); 594 } else if (IsInterface()) { 595 return src->Implements(this); 596 } else if (src->IsArrayClass()) { 597 return IsAssignableFromArray(src); 598 } else { 599 return !src->IsInterface() && src->IsSubClass(this); 600 } 601 } 602 603 ALWAYS_INLINE Class* GetSuperClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 604 605 void SetSuperClass(Class *new_super_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 606 // Super class is assigned once, except during class linker initialization. 607 Class* old_super_class = GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_)); 608 DCHECK(old_super_class == nullptr || old_super_class == new_super_class); 609 DCHECK(new_super_class != nullptr); 610 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), new_super_class); 611 } 612 613 bool HasSuperClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 614 return GetSuperClass() != NULL; 615 } 616 617 static MemberOffset SuperClassOffset() { 618 return MemberOffset(OFFSETOF_MEMBER(Class, super_class_)); 619 } 620 621 ClassLoader* GetClassLoader() ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 622 623 void SetClassLoader(ClassLoader* new_cl) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 624 625 static MemberOffset DexCacheOffset() { 626 return MemberOffset(OFFSETOF_MEMBER(Class, dex_cache_)); 627 } 628 629 enum { 630 kDumpClassFullDetail = 1, 631 kDumpClassClassLoader = (1 << 1), 632 kDumpClassInitialized = (1 << 2), 633 }; 634 635 void DumpClass(std::ostream& os, int flags) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 636 637 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 638 DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 639 640 void SetDexCache(DexCache* new_dex_cache) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 641 642 ALWAYS_INLINE ObjectArray<ArtMethod>* GetDirectMethods() 643 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 644 645 void SetDirectMethods(ObjectArray<ArtMethod>* new_direct_methods) 646 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 647 648 ALWAYS_INLINE ArtMethod* GetDirectMethod(int32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 649 650 void SetDirectMethod(uint32_t i, ArtMethod* f) // TODO: uint16_t 651 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 652 653 // Returns the number of static, private, and constructor methods. 654 uint32_t NumDirectMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 655 656 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 657 ALWAYS_INLINE ObjectArray<ArtMethod>* GetVirtualMethods() 658 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 659 660 ALWAYS_INLINE void SetVirtualMethods(ObjectArray<ArtMethod>* new_virtual_methods) 661 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 662 663 // Returns the number of non-inherited virtual methods. 664 ALWAYS_INLINE uint32_t NumVirtualMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 665 666 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 667 ArtMethod* GetVirtualMethod(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 668 669 ArtMethod* GetVirtualMethodDuringLinking(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 670 671 void SetVirtualMethod(uint32_t i, ArtMethod* f) // TODO: uint16_t 672 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 673 674 ALWAYS_INLINE ObjectArray<ArtMethod>* GetVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 675 676 ALWAYS_INLINE ObjectArray<ArtMethod>* GetVTableDuringLinking() 677 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 678 679 void SetVTable(ObjectArray<ArtMethod>* new_vtable) 680 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 681 682 static MemberOffset VTableOffset() { 683 return OFFSET_OF_OBJECT_MEMBER(Class, vtable_); 684 } 685 686 static MemberOffset EmbeddedImTableOffset() { 687 return MemberOffset(sizeof(Class)); 688 } 689 690 static MemberOffset EmbeddedVTableLengthOffset() { 691 return MemberOffset(sizeof(Class) + kImtSize * sizeof(mirror::Class::ImTableEntry)); 692 } 693 694 static MemberOffset EmbeddedVTableOffset() { 695 return MemberOffset(sizeof(Class) + kImtSize * sizeof(ImTableEntry) + sizeof(int32_t)); 696 } 697 698 bool ShouldHaveEmbeddedImtAndVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 699 return IsInstantiable(); 700 } 701 702 bool HasVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 703 704 ArtMethod* GetEmbeddedImTableEntry(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 705 706 void SetEmbeddedImTableEntry(uint32_t i, ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 707 708 int32_t GetVTableLength() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 709 710 ArtMethod* GetVTableEntry(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 711 712 int32_t GetEmbeddedVTableLength() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 713 714 void SetEmbeddedVTableLength(int32_t len) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 715 716 ArtMethod* GetEmbeddedVTableEntry(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 717 718 void SetEmbeddedVTableEntry(uint32_t i, ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 719 720 void PopulateEmbeddedImtAndVTable(StackHandleScope<kImtSize>* imt_handle_scope) 721 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 722 723 // Given a method implemented by this class but potentially from a super class, return the 724 // specific implementation method for this class. 725 ArtMethod* FindVirtualMethodForVirtual(ArtMethod* method) 726 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 727 728 // Given a method implemented by this class' super class, return the specific implementation 729 // method for this class. 730 ArtMethod* FindVirtualMethodForSuper(ArtMethod* method) 731 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 732 733 // Given a method implemented by this class, but potentially from a 734 // super class or interface, return the specific implementation 735 // method for this class. 736 ArtMethod* FindVirtualMethodForInterface(ArtMethod* method) 737 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) ALWAYS_INLINE; 738 739 ArtMethod* FindVirtualMethodForVirtualOrInterface(ArtMethod* method) 740 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 741 742 ArtMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) 743 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 744 745 ArtMethod* FindInterfaceMethod(const StringPiece& name, const Signature& signature) 746 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 747 748 ArtMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) 749 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 750 751 ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) 752 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 753 754 ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const Signature& signature) 755 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 756 757 ArtMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) 758 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 759 760 ArtMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) 761 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 762 763 ArtMethod* FindDirectMethod(const StringPiece& name, const Signature& signature) 764 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 765 766 ArtMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) 767 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 768 769 ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) 770 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 771 772 ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const Signature& signature) 773 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 774 775 ArtMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) 776 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 777 778 ArtMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& signature) 779 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 780 781 ArtMethod* FindVirtualMethod(const StringPiece& name, const Signature& signature) 782 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 783 784 ArtMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) 785 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 786 787 ArtMethod* FindClassInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 788 789 ALWAYS_INLINE int32_t GetIfTableCount() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 790 791 ALWAYS_INLINE IfTable* GetIfTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 792 793 ALWAYS_INLINE void SetIfTable(IfTable* new_iftable) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 794 795 // Get instance fields of the class (See also GetSFields). 796 ObjectArray<ArtField>* GetIFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 797 798 void SetIFields(ObjectArray<ArtField>* new_ifields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 799 800 uint32_t NumInstanceFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 801 802 ArtField* GetInstanceField(uint32_t i) // TODO: uint16_t 803 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 804 805 void SetInstanceField(uint32_t i, ArtField* f) // TODO: uint16_t 806 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 807 808 // Returns the number of instance fields containing reference types. 809 uint32_t NumReferenceInstanceFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 810 DCHECK(IsResolved() || IsErroneous()); 811 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_)); 812 } 813 814 uint32_t NumReferenceInstanceFieldsDuringLinking() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 815 DCHECK(IsLoaded() || IsErroneous()); 816 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_)); 817 } 818 819 void SetNumReferenceInstanceFields(uint32_t new_num) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 820 // Not called within a transaction. 821 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), new_num); 822 } 823 824 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 825 uint32_t GetReferenceInstanceOffsets() ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 826 827 void SetReferenceInstanceOffsets(uint32_t new_reference_offsets) 828 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 829 830 // Returns the number of static fields containing reference types. 831 uint32_t NumReferenceStaticFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 832 DCHECK(IsResolved() || IsErroneous()); 833 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_)); 834 } 835 836 uint32_t NumReferenceStaticFieldsDuringLinking() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 837 DCHECK(IsLoaded() || IsErroneous() || IsRetired()); 838 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_)); 839 } 840 841 void SetNumReferenceStaticFields(uint32_t new_num) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 842 // Not called within a transaction. 843 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), new_num); 844 } 845 846 // Gets the static fields of the class. 847 ObjectArray<ArtField>* GetSFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 848 849 void SetSFields(ObjectArray<ArtField>* new_sfields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 850 851 uint32_t NumStaticFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 852 853 // TODO: uint16_t 854 ArtField* GetStaticField(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 855 856 // TODO: uint16_t 857 void SetStaticField(uint32_t i, ArtField* f) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 858 859 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 860 uint32_t GetReferenceStaticOffsets() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 861 return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_)); 862 } 863 864 void SetReferenceStaticOffsets(uint32_t new_reference_offsets) 865 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 866 867 // Find a static or instance field using the JLS resolution order 868 static ArtField* FindField(Thread* self, Handle<Class> klass, const StringPiece& name, 869 const StringPiece& type) 870 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 871 872 // Finds the given instance field in this class or a superclass. 873 ArtField* FindInstanceField(const StringPiece& name, const StringPiece& type) 874 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 875 876 // Finds the given instance field in this class or a superclass, only searches classes that 877 // have the same dex cache. 878 ArtField* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) 879 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 880 881 ArtField* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) 882 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 883 884 ArtField* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) 885 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 886 887 // Finds the given static field in this class or a superclass. 888 static ArtField* FindStaticField(Thread* self, Handle<Class> klass, const StringPiece& name, 889 const StringPiece& type) 890 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 891 892 // Finds the given static field in this class or superclass, only searches classes that 893 // have the same dex cache. 894 static ArtField* FindStaticField(Thread* self, Handle<Class> klass, const DexCache* dex_cache, 895 uint32_t dex_field_idx) 896 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 897 898 ArtField* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) 899 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 900 901 ArtField* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) 902 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 903 904 pid_t GetClinitThreadId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 905 DCHECK(IsIdxLoaded() || IsErroneous()); 906 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_)); 907 } 908 909 void SetClinitThreadId(pid_t new_clinit_thread_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 910 911 Class* GetVerifyErrorClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 912 // DCHECK(IsErroneous()); 913 return GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_)); 914 } 915 916 uint16_t GetDexClassDefIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 917 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_class_def_idx_)); 918 } 919 920 void SetDexClassDefIndex(uint16_t class_def_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 921 // Not called within a transaction. 922 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, dex_class_def_idx_), class_def_idx); 923 } 924 925 uint16_t GetDexTypeIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 926 return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_)); 927 } 928 929 void SetDexTypeIndex(uint16_t type_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 930 // Not called within a transaction. 931 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), type_idx); 932 } 933 934 static Class* GetJavaLangClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 935 DCHECK(!java_lang_Class_.IsNull()); 936 return java_lang_Class_.Read(); 937 } 938 939 // Can't call this SetClass or else gets called instead of Object::SetClass in places. 940 static void SetClassClass(Class* java_lang_Class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 941 static void ResetClass(); 942 static void VisitRoots(RootCallback* callback, void* arg) 943 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 944 945 // When class is verified, set the kAccPreverified flag on each method. 946 void SetPreverifiedFlagOnAllMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 947 948 template <bool kVisitClass, typename Visitor> 949 void VisitReferences(mirror::Class* klass, const Visitor& visitor) 950 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 951 952 // Visit references within the embedded tables of the class. 953 // TODO: remove NO_THREAD_SAFETY_ANALYSIS when annotalysis handles visitors better. 954 template<typename Visitor> 955 void VisitEmbeddedImtAndVTable(const Visitor& visitor) NO_THREAD_SAFETY_ANALYSIS; 956 957 // Get the descriptor of the class. In a few cases a std::string is required, rather than 958 // always create one the storage argument is populated and its internal c_str() returned. We do 959 // this to avoid memory allocation in the common case. 960 const char* GetDescriptor(std::string* storage) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 961 962 const char* GetArrayDescriptor(std::string* storage) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 963 964 bool DescriptorEquals(const char* match) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 965 966 967 const DexFile::ClassDef* GetClassDef() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 968 969 ALWAYS_INLINE uint32_t NumDirectInterfaces() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 970 971 uint16_t GetDirectInterfaceTypeIdx(uint32_t idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 972 973 static mirror::Class* GetDirectInterface(Thread* self, Handle<mirror::Class> klass, uint32_t idx) 974 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 975 976 const char* GetSourceFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 977 978 std::string GetLocation() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 979 980 const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 981 982 const DexFile::TypeList* GetInterfaceTypeList() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 983 984 // Asserts we are initialized or initializing in the given thread. 985 void AssertInitializedOrInitializingInThread(Thread* self) 986 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 987 988 Class* CopyOf(Thread* self, int32_t new_length, StackHandleScope<kImtSize>* imt_handle_scope) 989 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 990 991 // For proxy class only. 992 ObjectArray<Class>* GetInterfaces() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 993 994 // For proxy class only. 995 ObjectArray<ObjectArray<Class>>* GetThrows() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 996 997 // For reference class only. 998 MemberOffset GetDisableIntrinsicFlagOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 999 MemberOffset GetSlowPathFlagOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1000 bool GetSlowPathEnabled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1001 void SetSlowPath(bool enabled) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1002 1003 // Used to initialize a class in the allocation code path to ensure it is guarded by a StoreStore 1004 // fence. 1005 class InitializeClassVisitor { 1006 public: 1007 explicit InitializeClassVisitor(uint32_t class_size) : class_size_(class_size) { 1008 } 1009 1010 void operator()(mirror::Object* obj, size_t usable_size) const 1011 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1012 1013 private: 1014 const uint32_t class_size_; 1015 1016 DISALLOW_COPY_AND_ASSIGN(InitializeClassVisitor); 1017 }; 1018 1019 private: 1020 void SetVerifyErrorClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1021 1022 template <bool throw_on_failure, bool use_referrers_cache> 1023 bool ResolvedFieldAccessTest(Class* access_to, ArtField* field, 1024 uint32_t field_idx, DexCache* dex_cache) 1025 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1026 template <bool throw_on_failure, bool use_referrers_cache, InvokeType throw_invoke_type> 1027 bool ResolvedMethodAccessTest(Class* access_to, ArtMethod* resolved_method, 1028 uint32_t method_idx, DexCache* dex_cache) 1029 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1030 1031 bool Implements(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1032 bool IsArrayAssignableFromArray(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1033 bool IsAssignableFromArray(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1034 1035 void CheckObjectAlloc() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1036 1037 // defining class loader, or NULL for the "bootstrap" system loader 1038 HeapReference<ClassLoader> class_loader_; 1039 1040 // For array classes, the component class object for instanceof/checkcast 1041 // (for String[][][], this will be String[][]). NULL for non-array classes. 1042 HeapReference<Class> component_type_; 1043 1044 // DexCache of resolved constant pool entries (will be NULL for classes generated by the 1045 // runtime such as arrays and primitive classes). 1046 HeapReference<DexCache> dex_cache_; 1047 1048 // static, private, and <init> methods 1049 HeapReference<ObjectArray<ArtMethod>> direct_methods_; 1050 1051 // instance fields 1052 // 1053 // These describe the layout of the contents of an Object. 1054 // Note that only the fields directly declared by this class are 1055 // listed in ifields; fields declared by a superclass are listed in 1056 // the superclass's Class.ifields. 1057 // 1058 // All instance fields that refer to objects are guaranteed to be at 1059 // the beginning of the field list. num_reference_instance_fields_ 1060 // specifies the number of reference fields. 1061 HeapReference<ObjectArray<ArtField>> ifields_; 1062 1063 // The interface table (iftable_) contains pairs of a interface class and an array of the 1064 // interface methods. There is one pair per interface supported by this class. That means one 1065 // pair for each interface we support directly, indirectly via superclass, or indirectly via a 1066 // superinterface. This will be null if neither we nor our superclass implement any interfaces. 1067 // 1068 // Why we need this: given "class Foo implements Face", declare "Face faceObj = new Foo()". 1069 // Invoke faceObj.blah(), where "blah" is part of the Face interface. We can't easily use a 1070 // single vtable. 1071 // 1072 // For every interface a concrete class implements, we create an array of the concrete vtable_ 1073 // methods for the methods in the interface. 1074 HeapReference<IfTable> iftable_; 1075 1076 // Interface method table (imt), for quick "invoke-interface". 1077 HeapReference<ObjectArray<ArtMethod>> imtable_; 1078 1079 // Descriptor for the class such as "java.lang.Class" or "[C". Lazily initialized by ComputeName 1080 HeapReference<String> name_; 1081 1082 // Static fields 1083 HeapReference<ObjectArray<ArtField>> sfields_; 1084 1085 // The superclass, or NULL if this is java.lang.Object, an interface or primitive type. 1086 HeapReference<Class> super_class_; 1087 1088 // If class verify fails, we must return same error on subsequent tries. 1089 HeapReference<Class> verify_error_class_; 1090 1091 // Virtual methods defined in this class; invoked through vtable. 1092 HeapReference<ObjectArray<ArtMethod>> virtual_methods_; 1093 1094 // Virtual method table (vtable), for use by "invoke-virtual". The vtable from the superclass is 1095 // copied in, and virtual methods from our class either replace those from the super or are 1096 // appended. For abstract classes, methods may be created in the vtable that aren't in 1097 // virtual_ methods_ for miranda methods. 1098 HeapReference<ObjectArray<ArtMethod>> vtable_; 1099 1100 // Access flags; low 16 bits are defined by VM spec. 1101 uint32_t access_flags_; 1102 1103 // Total size of the Class instance; used when allocating storage on gc heap. 1104 // See also object_size_. 1105 uint32_t class_size_; 1106 1107 // Tid used to check for recursive <clinit> invocation. 1108 pid_t clinit_thread_id_; 1109 1110 // ClassDef index in dex file, -1 if no class definition such as an array. 1111 // TODO: really 16bits 1112 int32_t dex_class_def_idx_; 1113 1114 // Type index in dex file. 1115 // TODO: really 16bits 1116 int32_t dex_type_idx_; 1117 1118 // Number of instance fields that are object refs. 1119 uint32_t num_reference_instance_fields_; 1120 1121 // Number of static fields that are object refs, 1122 uint32_t num_reference_static_fields_; 1123 1124 // Total object size; used when allocating storage on gc heap. 1125 // (For interfaces and abstract classes this will be zero.) 1126 // See also class_size_. 1127 uint32_t object_size_; 1128 1129 // Primitive type value, or Primitive::kPrimNot (0); set for generated primitive classes. 1130 Primitive::Type primitive_type_; 1131 1132 // Bitmap of offsets of ifields. 1133 uint32_t reference_instance_offsets_; 1134 1135 // Bitmap of offsets of sfields. 1136 uint32_t reference_static_offsets_; 1137 1138 // State of class initialization. 1139 Status status_; 1140 1141 // TODO: ? 1142 // initiating class loader list 1143 // NOTE: for classes with low serialNumber, these are unused, and the 1144 // values are kept in a table in gDvm. 1145 // InitiatingLoaderList initiating_loader_list_; 1146 1147 // The following data exist in real class objects. 1148 // Embedded Imtable, for class object that's not an interface, fixed size. 1149 ImTableEntry embedded_imtable_[0]; 1150 // Embedded Vtable, for class object that's not an interface, variable size. 1151 VTableEntry embedded_vtable_[0]; 1152 // Static fields, variable size. 1153 uint32_t fields_[0]; 1154 1155 // java.lang.Class 1156 static GcRoot<Class> java_lang_Class_; 1157 1158 friend struct art::ClassOffsets; // for verifying offset information 1159 DISALLOW_IMPLICIT_CONSTRUCTORS(Class); 1160}; 1161 1162std::ostream& operator<<(std::ostream& os, const Class::Status& rhs); 1163 1164} // namespace mirror 1165} // namespace art 1166 1167#endif // ART_RUNTIME_MIRROR_CLASS_H_ 1168