diff options
Diffstat (limited to 'runtime/mirror/class.h')
| -rw-r--r-- | runtime/mirror/class.h | 282 |
1 files changed, 178 insertions, 104 deletions
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h index b99fc68933..ba8a693bdb 100644 --- a/runtime/mirror/class.h +++ b/runtime/mirror/class.h @@ -17,6 +17,7 @@ #ifndef ART_RUNTIME_MIRROR_CLASS_H_ #define ART_RUNTIME_MIRROR_CLASS_H_ +#include "base/iteration_range.h" #include "dex_file.h" #include "gc_root.h" #include "gc/allocator_type.h" @@ -27,6 +28,8 @@ #include "object_callbacks.h" #include "primitive.h" #include "read_barrier_option.h" +#include "stride_iterator.h" +#include "utils.h" #ifndef IMT_SIZE #error IMT_SIZE not defined @@ -35,6 +38,7 @@ namespace art { class ArtField; +class ArtMethod; struct ClassOffsets; template<class T> class Handle; template<class T> class Handle; @@ -44,7 +48,6 @@ template<size_t kNumReferences> class PACKED(4) StackHandleScope; namespace mirror { -class ArtMethod; class ClassLoader; class Constructor; class DexCache; @@ -64,16 +67,6 @@ class MANAGED Class FINAL : public Object { // (non-marker) interfaces. static constexpr size_t kImtSize = IMT_SIZE; - // imtable entry embedded in class object. - struct MANAGED ImTableEntry { - HeapReference<ArtMethod> method; - }; - - // vtable entry embedded in class object. - struct MANAGED VTableEntry { - HeapReference<ArtMethod> method; - }; - // Class Status // // kStatusRetired: Class that's temporarily used till class linking time @@ -406,13 +399,7 @@ class MANAGED Class FINAL : public Object { } // Depth of class from java.lang.Object - uint32_t Depth() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { - uint32_t depth = 0; - for (Class* klass = this; klass->GetSuperClass() != nullptr; klass = klass->GetSuperClass()) { - depth++; - } - return depth; - } + uint32_t Depth() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, ReadBarrierOption kReadBarrierOption = kWithReadBarrier> @@ -427,9 +414,6 @@ class MANAGED Class FINAL : public Object { bool IsThrowableClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> - bool IsArtMethodClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - - template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> bool IsReferenceClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); static MemberOffset ComponentTypeOffset() { @@ -469,12 +453,27 @@ class MANAGED Class FINAL : public Object { bool IsInstantiable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { return (!IsPrimitive() && !IsInterface() && !IsAbstract()) || - ((IsAbstract()) && IsArrayClass()); + (IsAbstract() && IsArrayClass()); } template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> bool IsObjectArrayClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { - return GetComponentType<kVerifyFlags>() != nullptr && !GetComponentType<kVerifyFlags>()->IsPrimitive(); + return GetComponentType<kVerifyFlags>() != nullptr && + !GetComponentType<kVerifyFlags>()->IsPrimitive(); + } + + template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> + bool IsIntArrayClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { + constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); + auto* component_type = GetComponentType<kVerifyFlags>(); + return component_type != nullptr && component_type->template IsPrimitiveInt<kNewFlags>(); + } + + template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> + bool IsLongArrayClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { + constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); + auto* component_type = GetComponentType<kVerifyFlags>(); + return component_type != nullptr && component_type->template IsPrimitiveLong<kNewFlags>(); } // Creates a raw object instance but does not invoke the default constructor. @@ -517,18 +516,19 @@ class MANAGED Class FINAL : public Object { uint32_t num_16bit_static_fields, uint32_t num_32bit_static_fields, uint32_t num_64bit_static_fields, - uint32_t num_ref_static_fields); + uint32_t num_ref_static_fields, + size_t pointer_size); // The size of java.lang.Class.class. - static uint32_t ClassClassSize() { + static uint32_t ClassClassSize(size_t pointer_size) { // The number of vtable entries in java.lang.Class. - uint32_t vtable_entries = Object::kVTableLength + 66; - return ComputeClassSize(true, vtable_entries, 0, 0, 0, 1, 0); + uint32_t vtable_entries = Object::kVTableLength + 65; + return ComputeClassSize(true, vtable_entries, 0, 0, 0, 1, 0, pointer_size); } // The size of a java.lang.Class representing a primitive such as int.class. - static uint32_t PrimitiveClassSize() { - return ComputeClassSize(false, 0, 0, 0, 0, 0, 0); + static uint32_t PrimitiveClassSize(size_t pointer_size) { + return ComputeClassSize(false, 0, 0, 0, 0, 0, 0, pointer_size); } template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, @@ -673,60 +673,82 @@ class MANAGED Class FINAL : public Object { // Also updates the dex_cache_strings_ variable from new_dex_cache. void SetDexCache(DexCache* new_dex_cache) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ALWAYS_INLINE ObjectArray<ArtMethod>* GetDirectMethods() + ALWAYS_INLINE StrideIterator<ArtMethod> DirectMethodsBegin(size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + ALWAYS_INLINE StrideIterator<ArtMethod> DirectMethodsEnd(size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - void SetDirectMethods(ObjectArray<ArtMethod>* new_direct_methods) + ALWAYS_INLINE IterationRange<StrideIterator<ArtMethod>> GetDirectMethods(size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ALWAYS_INLINE ArtMethod* GetDirectMethod(int32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ArtMethod* GetDirectMethodsPtr() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);\ + + void SetDirectMethodsPtr(ArtMethod* new_direct_methods) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + // Used by image writer. + void SetDirectMethodsPtrUnchecked(ArtMethod* new_direct_methods) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - void SetDirectMethod(uint32_t i, ArtMethod* f) // TODO: uint16_t + ALWAYS_INLINE ArtMethod* GetDirectMethod(size_t i, size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + // Use only when we are allocating populating the method arrays. + ALWAYS_INLINE ArtMethod* GetDirectMethodUnchecked(size_t i, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ALWAYS_INLINE ArtMethod* GetVirtualMethodUnchecked(size_t i, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + // Returns the number of static, private, and constructor methods. - uint32_t NumDirectMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ALWAYS_INLINE uint32_t NumDirectMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { + return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_direct_methods_)); + } + void SetNumDirectMethods(uint32_t num) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { + return SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, num_direct_methods_), num); + } template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - ALWAYS_INLINE ObjectArray<ArtMethod>* GetVirtualMethods() + ALWAYS_INLINE ArtMethod* GetVirtualMethodsPtr() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + ALWAYS_INLINE StrideIterator<ArtMethod> VirtualMethodsBegin(size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + ALWAYS_INLINE StrideIterator<ArtMethod> VirtualMethodsEnd(size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ALWAYS_INLINE void SetVirtualMethods(ObjectArray<ArtMethod>* new_virtual_methods) + ALWAYS_INLINE IterationRange<StrideIterator<ArtMethod>> GetVirtualMethods(size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + void SetVirtualMethodsPtr(ArtMethod* new_virtual_methods) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Returns the number of non-inherited virtual methods. - ALWAYS_INLINE uint32_t NumVirtualMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ALWAYS_INLINE uint32_t NumVirtualMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { + return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_virtual_methods_)); + } + void SetNumVirtualMethods(uint32_t num) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { + return SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, num_virtual_methods_), num); + } template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - ArtMethod* GetVirtualMethod(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - - ArtMethod* GetVirtualMethodDuringLinking(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ArtMethod* GetVirtualMethod(size_t i, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - void SetVirtualMethod(uint32_t i, ArtMethod* f) // TODO: uint16_t + ArtMethod* GetVirtualMethodDuringLinking(size_t i, size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ALWAYS_INLINE ObjectArray<ArtMethod>* GetVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ALWAYS_INLINE PointerArray* GetVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ALWAYS_INLINE ObjectArray<ArtMethod>* GetVTableDuringLinking() - SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ALWAYS_INLINE PointerArray* GetVTableDuringLinking() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - void SetVTable(ObjectArray<ArtMethod>* new_vtable) - SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + void SetVTable(PointerArray* new_vtable) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); static MemberOffset VTableOffset() { return OFFSET_OF_OBJECT_MEMBER(Class, vtable_); } - static MemberOffset EmbeddedImTableOffset() { - return MemberOffset(sizeof(Class)); - } - static MemberOffset EmbeddedVTableLengthOffset() { - return MemberOffset(sizeof(Class) + kImtSize * sizeof(mirror::Class::ImTableEntry)); - } - - static MemberOffset EmbeddedVTableOffset() { - return MemberOffset(sizeof(Class) + kImtSize * sizeof(ImTableEntry) + sizeof(int32_t)); + return MemberOffset(sizeof(Class)); } bool ShouldHaveEmbeddedImtAndVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { @@ -735,90 +757,117 @@ class MANAGED Class FINAL : public Object { bool HasVTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* GetEmbeddedImTableEntry(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + static MemberOffset EmbeddedImTableEntryOffset(uint32_t i, size_t pointer_size); - void SetEmbeddedImTableEntry(uint32_t i, ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + static MemberOffset EmbeddedVTableEntryOffset(uint32_t i, size_t pointer_size); + + ArtMethod* GetEmbeddedImTableEntry(uint32_t i, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + void SetEmbeddedImTableEntry(uint32_t i, ArtMethod* method, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); int32_t GetVTableLength() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* GetVTableEntry(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ArtMethod* GetVTableEntry(uint32_t i, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); int32_t GetEmbeddedVTableLength() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); void SetEmbeddedVTableLength(int32_t len) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* GetEmbeddedVTableEntry(uint32_t i) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ArtMethod* GetEmbeddedVTableEntry(uint32_t i, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - void SetEmbeddedVTableEntry(uint32_t i, ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + void SetEmbeddedVTableEntry(uint32_t i, ArtMethod* method, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - void PopulateEmbeddedImtAndVTable(StackHandleScope<kImtSize>* imt_handle_scope) + inline void SetEmbeddedVTableEntryUnchecked(uint32_t i, ArtMethod* method, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + void PopulateEmbeddedImtAndVTable(ArtMethod* const (&methods)[kImtSize], size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Given a method implemented by this class but potentially from a super class, return the // specific implementation method for this class. - ArtMethod* FindVirtualMethodForVirtual(ArtMethod* method) + ArtMethod* FindVirtualMethodForVirtual(ArtMethod* method, size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Given a method implemented by this class' super class, return the specific implementation // method for this class. - ArtMethod* FindVirtualMethodForSuper(ArtMethod* method) + ArtMethod* FindVirtualMethodForSuper(ArtMethod* method, size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Given a method implemented by this class, but potentially from a // super class or interface, return the specific implementation // method for this class. - ArtMethod* FindVirtualMethodForInterface(ArtMethod* method) + ArtMethod* FindVirtualMethodForInterface(ArtMethod* method, size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) ALWAYS_INLINE; - ArtMethod* FindVirtualMethodForVirtualOrInterface(ArtMethod* method) + ArtMethod* FindVirtualMethodForVirtualOrInterface(ArtMethod* method, size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) + ArtMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindInterfaceMethod(const StringPiece& name, const Signature& signature) + ArtMethod* FindInterfaceMethod(const StringPiece& name, const Signature& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) + ArtMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) + ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const Signature& signature) + ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const Signature& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) + ArtMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) + ArtMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDirectMethod(const StringPiece& name, const Signature& signature) + ArtMethod* FindDirectMethod(const StringPiece& name, const Signature& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) + ArtMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) + ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const Signature& signature) + ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const Signature& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) + ArtMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& signature) + ArtMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindVirtualMethod(const StringPiece& name, const Signature& signature) + ArtMethod* FindVirtualMethod(const StringPiece& name, const Signature& signature, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) + ArtMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx, + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - ArtMethod* FindClassInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + ArtMethod* FindClassInitializer(size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); ALWAYS_INLINE int32_t GetIfTableCount() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -867,7 +916,8 @@ class MANAGED Class FINAL : public Object { SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Get the offset of the first reference instance field. Other reference instance fields follow. - MemberOffset GetFirstReferenceInstanceFieldOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + MemberOffset GetFirstReferenceInstanceFieldOffset() + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Returns the number of static fields containing reference types. uint32_t NumReferenceStaticFields() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { @@ -886,10 +936,11 @@ class MANAGED Class FINAL : public Object { } // Get the offset of the first reference static field. Other reference static fields follow. - MemberOffset GetFirstReferenceStaticFieldOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + MemberOffset GetFirstReferenceStaticFieldOffset(size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Get the offset of the first reference static field. Other reference static fields follow. - MemberOffset GetFirstReferenceStaticFieldOffsetDuringLinking() + MemberOffset GetFirstReferenceStaticFieldOffsetDuringLinking(size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Gets the static fields of the class. @@ -989,22 +1040,20 @@ class MANAGED Class FINAL : public Object { static void VisitRoots(RootVisitor* visitor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + // Visit native roots visits roots which are keyed off the native pointers such as ArtFields and + // ArtMethods. template<class Visitor> - // Visit field roots. - void VisitFieldRoots(Visitor& visitor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + void VisitNativeRoots(Visitor& visitor, size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // When class is verified, set the kAccPreverified flag on each method. - void SetPreverifiedFlagOnAllMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + void SetPreverifiedFlagOnAllMethods(size_t pointer_size) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); template <bool kVisitClass, typename Visitor> void VisitReferences(mirror::Class* klass, const Visitor& visitor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - // Visit references within the embedded tables of the class. - // TODO: remove NO_THREAD_SAFETY_ANALYSIS when annotalysis handles visitors better. - template<typename Visitor> - void VisitEmbeddedImtAndVTable(const Visitor& visitor) NO_THREAD_SAFETY_ANALYSIS; - // Get the descriptor of the class. In a few cases a std::string is required, rather than // always create one the storage argument is populated and its internal c_str() returned. We do // this to avoid memory allocation in the common case. @@ -1014,7 +1063,6 @@ class MANAGED Class FINAL : public Object { bool DescriptorEquals(const char* match) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - const DexFile::ClassDef* GetClassDef() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); ALWAYS_INLINE uint32_t NumDirectInterfaces() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -1037,8 +1085,8 @@ class MANAGED Class FINAL : public Object { void AssertInitializedOrInitializingInThread(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); - Class* CopyOf(Thread* self, int32_t new_length, StackHandleScope<kImtSize>* imt_handle_scope) - SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + Class* CopyOf(Thread* self, int32_t new_length, ArtMethod* const (&imt)[mirror::Class::kImtSize], + size_t pointer_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // For proxy class only. ObjectArray<Class>* GetInterfaces() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -1060,7 +1108,7 @@ class MANAGED Class FINAL : public Object { } // May cause thread suspension due to EqualParameters. - mirror::ArtMethod* GetDeclaredConstructor( + ArtMethod* GetDeclaredConstructor( Thread* self, Handle<mirror::ObjectArray<mirror::Class>> args) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -1085,6 +1133,20 @@ class MANAGED Class FINAL : public Object { return GetClassLoader() == nullptr; } + static size_t ImTableEntrySize(size_t pointer_size) { + return pointer_size; + } + + static size_t VTableEntrySize(size_t pointer_size) { + return pointer_size; + } + + ALWAYS_INLINE ArtMethod* GetDirectMethodsPtrUnchecked() + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + ALWAYS_INLINE ArtMethod* GetVirtualMethodsPtrUnchecked() + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + private: void SetVerifyErrorClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); @@ -1109,6 +1171,12 @@ class MANAGED Class FINAL : public Object { bool ProxyDescriptorEquals(const char* match) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + // Check that the pointer size mathces the one in the class linker. + ALWAYS_INLINE static void CheckPointerSize(size_t pointer_size); + + static MemberOffset EmbeddedImTableOffset(size_t pointer_size); + static MemberOffset EmbeddedVTableOffset(size_t pointer_size); + // Defining class loader, or null for the "bootstrap" system loader. HeapReference<ClassLoader> class_loader_; @@ -1123,9 +1191,6 @@ class MANAGED Class FINAL : public Object { // Short cuts to dex_cache_ member for fast compiled code access. HeapReference<ObjectArray<String>> dex_cache_strings_; - // static, private, and <init> methods - HeapReference<ObjectArray<ArtMethod>> direct_methods_; - // The interface table (iftable_) contains pairs of a interface class and an array of the // interface methods. There is one pair per interface supported by this class. That means one // pair for each interface we support directly, indirectly via superclass, or indirectly via a @@ -1148,19 +1213,19 @@ class MANAGED Class FINAL : public Object { // If class verify fails, we must return same error on subsequent tries. HeapReference<Class> verify_error_class_; - // Virtual methods defined in this class; invoked through vtable. - HeapReference<ObjectArray<ArtMethod>> virtual_methods_; - // Virtual method table (vtable), for use by "invoke-virtual". The vtable from the superclass is // copied in, and virtual methods from our class either replace those from the super or are // appended. For abstract classes, methods may be created in the vtable that aren't in // virtual_ methods_ for miranda methods. - HeapReference<ObjectArray<ArtMethod>> vtable_; + HeapReference<PointerArray> vtable_; // Access flags; low 16 bits are defined by VM spec. // Note: Shuffled back. uint32_t access_flags_; + // static, private, and <init> methods. Pointer to an ArtMethod array. + uint64_t direct_methods_; + // instance fields // // These describe the layout of the contents of an Object. @@ -1174,6 +1239,9 @@ class MANAGED Class FINAL : public Object { // Static fields uint64_t sfields_; + // Virtual methods defined in this class; invoked through vtable. Pointer to an ArtMethod array. + uint64_t virtual_methods_; + // Total size of the Class instance; used when allocating storage on gc heap. // See also object_size_. uint32_t class_size_; @@ -1189,7 +1257,10 @@ class MANAGED Class FINAL : public Object { // TODO: really 16bits int32_t dex_type_idx_; - // Number of static fields. + // Number of direct fields. + uint32_t num_direct_methods_; + + // Number of instance fields. uint32_t num_instance_fields_; // Number of instance fields that are object refs. @@ -1201,6 +1272,9 @@ class MANAGED Class FINAL : public Object { // Number of static fields. uint32_t num_static_fields_; + // Number of virtual methods. + uint32_t num_virtual_methods_; + // Total object size; used when allocating storage on gc heap. // (For interfaces and abstract classes this will be zero.) // See also class_size_. |