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