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