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