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