class ArtField; class ArtMethod; template <class T> class Handle; class LockWord; class Monitor; struct ObjectOffsets; class Thread; class VoidFunctor;
namespace mirror {
class Array; classClass; class ClassLoader; class DexCache; class FinalizerReference; template<class T> class ObjectArray; template<class T> class PrimitiveArray; using BooleanArray = PrimitiveArray<uint8_t>; using ByteArray = PrimitiveArray<int8_t>; using CharArray = PrimitiveArray<uint16_t>; using DoubleArray = PrimitiveArray<double>; using FloatArray = PrimitiveArray<float>; using IntArray = PrimitiveArray<int32_t>; using LongArray = PrimitiveArray<int64_t>; using ShortArray = PrimitiveArray<int16_t>; class Reference; class String; class Throwable;
// Fields within mirror objects aren't accessed directly so that the appropriate amount of // handshaking is done with GC (for example, read and write barriers). This macro is used to // compute an offset for the Set/Get methods defined in Object that can safely access fields. #define OFFSET_OF_OBJECT_MEMBER(type, field) \
MemberOffset(OFFSETOF_MEMBER(type, field))
// Checks that we don't do field assignments which violate the typing system. static constexpr bool kCheckFieldAssignments = false;
// Size of Object. static constexpr uint32_t kObjectHeaderSize = 8;
// C++ mirror of java.lang.Object class EXPORT MANAGED LOCKABLE Object { public:
MIRROR_CLASS("Ljava/lang/Object;");
// The number of vtable entries in java.lang.Object. static constexpr size_t kVTableLength = 11;
// The size of the java.lang.Class representing a java.lang.Object. static uint32_t ClassSize(PointerSize pointer_size);
// Size of an instance of java.lang.Object. static constexpr uint32_t InstanceSize() { returnsizeof(Object);
}
// Get the read barrier state with a fake address dependency. // '*fake_address_dependency' will be set to 0.
ALWAYS_INLINE uint32_t GetReadBarrierState(uintptr_t* fake_address_dependency)
REQUIRES_SHARED(Locks::mutator_lock_); // This version does not offer any special mechanism to prevent load-load reordering.
ALWAYS_INLINE uint32_t GetReadBarrierState() REQUIRES_SHARED(Locks::mutator_lock_); // Get the read barrier state with a load-acquire.
ALWAYS_INLINE uint32_t GetReadBarrierStateAcquire() REQUIRES_SHARED(Locks::mutator_lock_);
// Assert that the read barrier state is in the default (white, i.e. non-gray) state.
ALWAYS_INLINE void AssertReadBarrierState() const REQUIRES_SHARED(Locks::mutator_lock_);
// The verifier treats all interfaces as java.lang.Object and relies on runtime checks in // invoke-interface to detect incompatible interface types. template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> bool VerifierInstanceOf(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
ALWAYS_INLINE bool InstanceOf(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_);
// Returns a nonzero value that fits into lockword slot.
int32_t IdentityHashCode()
REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!Locks::thread_list_lock_,
!Locks::thread_suspend_count_lock_);
// Identical to the above, but returns 0 if monitor inflation would otherwise be needed.
int32_t IdentityHashCodeNoInflation() REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
// As_volatile can be false if the mutators are suspended. This is an optimization since it // avoids the barriers. template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
LockWord GetLockWord(bool as_volatile) REQUIRES_SHARED(Locks::mutator_lock_); template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void SetLockWord(LockWord new_val, bool as_volatile) REQUIRES_SHARED(Locks::mutator_lock_); bool CasLockWord(LockWord old_val, LockWord new_val, CASMode mode, std::memory_order memory_order)
REQUIRES_SHARED(Locks::mutator_lock_); bool IsLockOwnedByMe(const Thread* self) REQUIRES_SHARED(Locks::mutator_lock_);
// Try to enter the monitor, returns non null if we succeeded.
ObjPtr<mirror::Object> MonitorTryEnter(Thread* self)
EXCLUSIVE_LOCK_FUNCTION()
REQUIRES(!Roles::uninterruptible_)
REQUIRES_SHARED(Locks::mutator_lock_);
ObjPtr<mirror::Object> MonitorEnter(Thread* self)
EXCLUSIVE_LOCK_FUNCTION()
REQUIRES(!Roles::uninterruptible_)
REQUIRES_SHARED(Locks::mutator_lock_); bool MonitorExit(Thread* self)
REQUIRES(!Roles::uninterruptible_)
REQUIRES_SHARED(Locks::mutator_lock_)
UNLOCK_FUNCTION(); void Notify(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_); void NotifyAll(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_); void Wait(Thread* self, int64_t timeout, int32_t nanos) REQUIRES_SHARED(Locks::mutator_lock_);
// Base class for accessors used to describe accesses performed by VarHandle methods. template <typename T> class Accessor { public: virtual ~Accessor() {
static_assert(std::is_arithmetic<T>::value, "unsupported type");
} virtualvoid Access(T* field_address) = 0;
};
// Getter method that exposes the raw address of a primitive value-type field to an Accessor // instance. This are used by VarHandle accessor methods to read fields with a wider range of // memory orderings than usually required. template<typename T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void GetPrimitiveFieldViaAccessor(MemberOffset field_offset, Accessor<T>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_);
// Update methods that expose the raw address of a primitive value-type to an Accessor instance // that will attempt to update the field. These are used by VarHandle accessor methods to // atomically update fields with a wider range of memory orderings than usually required. template<bool kTransactionActive, bool kCheckTransaction = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void UpdateFieldBooleanViaAccessor(MemberOffset field_offset, Accessor<uint8_t>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_); template<bool kTransactionActive, bool kCheckTransaction = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void UpdateFieldByteViaAccessor(MemberOffset field_offset, Accessor<int8_t>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_); template<bool kTransactionActive, bool kCheckTransaction = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void UpdateFieldCharViaAccessor(MemberOffset field_offset, Accessor<uint16_t>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_); template<bool kTransactionActive, bool kCheckTransaction = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void UpdateFieldShortViaAccessor(MemberOffset field_offset, Accessor<int16_t>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_); template<bool kTransactionActive, bool kCheckTransaction = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void UpdateField32ViaAccessor(MemberOffset field_offset, Accessor<int32_t>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_); template<bool kTransactionActive, bool kCheckTransaction = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> void UpdateField64ViaAccessor(MemberOffset field_offset, Accessor<int64_t>* accessor)
REQUIRES_SHARED(Locks::mutator_lock_);
// TODO fix thread safety analysis broken by the use of template. This should be // REQUIRES_SHARED(Locks::mutator_lock_). template <bool kVisitNativeRoots = true,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
ReadBarrierOption kReadBarrierOption = kWithReadBarrier, typename Visitor, typename JavaLangRefVisitor = VoidFunctor>
ALWAYS_INLINE void FastVisitReferences( const Visitor& visitor, const JavaLangRefVisitor& ref_visitor) NO_THREAD_SAFETY_ANALYSIS;
// Used by object_test. staticvoid SetHashCodeSeed(uint32_t new_seed); // Generate an identity hash code. Public for object test. static uint32_t GenerateIdentityHashCode();
// Returns a human-readable form of the name of the *class* of the given object. // So given an instance of java.lang.String, the output would // be "java.lang.String". Given an array of int, the output would be "int[]". // Given String.class, the output would be "java.lang.Class<java.lang.String>". static std::string PrettyTypeOf(ObjPtr<mirror::Object> obj)
REQUIRES_SHARED(Locks::mutator_lock_);
std::string PrettyTypeOf()
REQUIRES_SHARED(Locks::mutator_lock_);
// Dump non-null references and their type. template <bool kDumpNativeRoots> void DumpReferences(std::ostream& osi, bool dump_type_of); // A utility function that does a raw copy of `src`'s data into the buffer `dst_bytes`. // Skips the object header. staticvoid CopyRawObjectData(uint8_t* dst_bytes,
ObjPtr<mirror::Object> src,
size_t num_bytes)
REQUIRES_SHARED(Locks::mutator_lock_);
// Get a field with acquire semantics. template<typename kSize>
ALWAYS_INLINE kSize GetFieldAcquire(MemberOffset field_offset)
REQUIRES_SHARED(Locks::mutator_lock_);
// Verify the type correctness of stores to fields. // TODO: This can cause thread suspension and isn't moving GC safe. void CheckFieldAssignmentImpl(MemberOffset field_offset, ObjPtr<Object> new_value)
REQUIRES_SHARED(Locks::mutator_lock_); void CheckFieldAssignment(MemberOffset field_offset, ObjPtr<Object>new_value)
REQUIRES_SHARED(Locks::mutator_lock_) { if (kCheckFieldAssignments) {
CheckFieldAssignmentImpl(field_offset, new_value);
}
}
// Not ObjPtr since the values may be unaligned for logic in verification.cc. template<VerifyObjectFlags kVerifyFlags, typename Reference>
ALWAYS_INLINE staticvoid VerifyRead(Reference value) REQUIRES_SHARED(Locks::mutator_lock_) { if (kVerifyFlags & kVerifyReads) {
VerifyObject(value);
}
}
// Verify transaction is active (if required). template<bool kTransactionActive, bool kCheckTransaction>
ALWAYS_INLINE void VerifyTransaction();
// A utility function that copies an object in a read barrier and write barrier-aware way. // This is internally used by Clone() and Class::CopyOf(). If the object is finalizable, // it is the callers job to call Heap::AddFinalizerReference. static ObjPtr<Object> CopyObject(ObjPtr<mirror::Object> dest,
ObjPtr<mirror::Object> src,
size_t num_bytes)
REQUIRES_SHARED(Locks::mutator_lock_);
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
