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