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