blob: a012a5a9ca4843cb8be85b58fb91c70fe2abba31 [file] [log] [blame]
* Copyright (C) 2011 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#include "base/bit_utils.h"
#include "base/casts.h"
#include "dex_file.h"
#include "gc_root.h"
#include "invoke_type.h"
#include "method_reference.h"
#include "modifiers.h"
#include "mirror/object.h"
#include "read_barrier_option.h"
#include "stack.h"
#include "utils.h"
namespace art {
union JValue;
class OatQuickMethodHeader;
class ProfilingInfo;
class ScopedObjectAccessAlreadyRunnable;
class StringPiece;
class ShadowFrame;
namespace mirror {
class Array;
class Class;
class IfTable;
class PointerArray;
} // namespace mirror
// Table to resolve IMT conflicts at runtime. The table is attached to
// the jni entrypoint of IMT conflict ArtMethods.
// The table contains a list of pairs of { interface_method, implementation_method }
// with the last entry being null to make an assembly implementation of a lookup
// faster.
class ImtConflictTable {
enum MethodIndex {
kMethodCount, // Number of elements in enum.
// Build a new table copying `other` and adding the new entry formed of
// the pair { `interface_method`, `implementation_method` }
ImtConflictTable(ImtConflictTable* other,
ArtMethod* interface_method,
ArtMethod* implementation_method,
size_t pointer_size) {
const size_t count = other->NumEntries(pointer_size);
for (size_t i = 0; i < count; ++i) {
SetInterfaceMethod(i, pointer_size, other->GetInterfaceMethod(i, pointer_size));
SetImplementationMethod(i, pointer_size, other->GetImplementationMethod(i, pointer_size));
SetInterfaceMethod(count, pointer_size, interface_method);
SetImplementationMethod(count, pointer_size, implementation_method);
// Add the null marker.
SetInterfaceMethod(count + 1, pointer_size, nullptr);
SetImplementationMethod(count + 1, pointer_size, nullptr);
// num_entries excludes the header.
ImtConflictTable(size_t num_entries, size_t pointer_size) {
SetInterfaceMethod(num_entries, pointer_size, nullptr);
SetImplementationMethod(num_entries, pointer_size, nullptr);
// Set an entry at an index.
void SetInterfaceMethod(size_t index, size_t pointer_size, ArtMethod* method) {
SetMethod(index * kMethodCount + kMethodInterface, pointer_size, method);
void SetImplementationMethod(size_t index, size_t pointer_size, ArtMethod* method) {
SetMethod(index * kMethodCount + kMethodImplementation, pointer_size, method);
ArtMethod* GetInterfaceMethod(size_t index, size_t pointer_size) const {
return GetMethod(index * kMethodCount + kMethodInterface, pointer_size);
ArtMethod* GetImplementationMethod(size_t index, size_t pointer_size) const {
return GetMethod(index * kMethodCount + kMethodImplementation, pointer_size);
// Visit all of the entries.
// NO_THREAD_SAFETY_ANALYSIS for calling with held locks. Visitor is passed a pair of ArtMethod*
// and also returns one. The order is <interface, implementation>.
template<typename Visitor>
void Visit(const Visitor& visitor, size_t pointer_size) NO_THREAD_SAFETY_ANALYSIS {
uint32_t table_index = 0;
for (;;) {
ArtMethod* interface_method = GetInterfaceMethod(table_index, pointer_size);
if (interface_method == nullptr) {
ArtMethod* implementation_method = GetImplementationMethod(table_index, pointer_size);
auto input = std::make_pair(interface_method, implementation_method);
std::pair<ArtMethod*, ArtMethod*> updated = visitor(input);
if (input.first != updated.first) {
SetInterfaceMethod(table_index, pointer_size, updated.first);
if (input.second != updated.second) {
SetImplementationMethod(table_index, pointer_size, updated.second);
// Lookup the implementation ArtMethod associated to `interface_method`. Return null
// if not found.
ArtMethod* Lookup(ArtMethod* interface_method, size_t pointer_size) const {
uint32_t table_index = 0;
for (;;) {
ArtMethod* current_interface_method = GetInterfaceMethod(table_index, pointer_size);
if (current_interface_method == nullptr) {
if (current_interface_method == interface_method) {
return GetImplementationMethod(table_index, pointer_size);
return nullptr;
// Compute the number of entries in this table.
size_t NumEntries(size_t pointer_size) const {
uint32_t table_index = 0;
while (GetInterfaceMethod(table_index, pointer_size) != nullptr) {
return table_index;
// Compute the size in bytes taken by this table.
size_t ComputeSize(size_t pointer_size) const {
// Add the end marker.
return ComputeSize(NumEntries(pointer_size), pointer_size);
// Compute the size in bytes needed for copying the given `table` and add
// one more entry.
static size_t ComputeSizeWithOneMoreEntry(ImtConflictTable* table, size_t pointer_size) {
return table->ComputeSize(pointer_size) + EntrySize(pointer_size);
// Compute size with a fixed number of entries.
static size_t ComputeSize(size_t num_entries, size_t pointer_size) {
return (num_entries + 1) * EntrySize(pointer_size); // Add one for null terminator.
static size_t EntrySize(size_t pointer_size) {
return pointer_size * static_cast<size_t>(kMethodCount);
ArtMethod* GetMethod(size_t index, size_t pointer_size) const {
if (pointer_size == 8) {
return reinterpret_cast<ArtMethod*>(static_cast<uintptr_t>(data64_[index]));
} else {
DCHECK_EQ(pointer_size, 4u);
return reinterpret_cast<ArtMethod*>(static_cast<uintptr_t>(data32_[index]));
void SetMethod(size_t index, size_t pointer_size, ArtMethod* method) {
if (pointer_size == 8) {
data64_[index] = dchecked_integral_cast<uint64_t>(reinterpret_cast<uintptr_t>(method));
} else {
DCHECK_EQ(pointer_size, 4u);
data32_[index] = dchecked_integral_cast<uint32_t>(reinterpret_cast<uintptr_t>(method));
// Array of entries that the assembly stubs will iterate over. Note that this is
// not fixed size, and we allocate data prior to calling the constructor
// of ImtConflictTable.
union {
uint32_t data32_[0];
uint64_t data64_[0];
class ArtMethod FINAL {
ArtMethod() : access_flags_(0), dex_code_item_offset_(0), dex_method_index_(0),
method_index_(0) { }
ArtMethod(ArtMethod* src, size_t image_pointer_size) {
CopyFrom(src, image_pointer_size);
static ArtMethod* FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa,
jobject jlr_method)
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
ALWAYS_INLINE mirror::Class* GetDeclaringClass() SHARED_REQUIRES(Locks::mutator_lock_);
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
ALWAYS_INLINE mirror::Class* GetDeclaringClassUnchecked()
void SetDeclaringClass(mirror::Class *new_declaring_class)
bool CASDeclaringClass(mirror::Class* expected_class, mirror::Class* desired_class)
static MemberOffset DeclaringClassOffset() {
return MemberOffset(OFFSETOF_MEMBER(ArtMethod, declaring_class_));
// Note: GetAccessFlags acquires the mutator lock in debug mode to check that it is not called for
// a proxy method.
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
ALWAYS_INLINE uint32_t GetAccessFlags();
void SetAccessFlags(uint32_t new_access_flags) {
// Not called within a transaction.
access_flags_ = new_access_flags;
// Approximate what kind of method call would be used for this method.
InvokeType GetInvokeType() SHARED_REQUIRES(Locks::mutator_lock_);
// Returns true if the method is declared public.
bool IsPublic() {
return (GetAccessFlags() & kAccPublic) != 0;
// Returns true if the method is declared private.
bool IsPrivate() {
return (GetAccessFlags() & kAccPrivate) != 0;
// Returns true if the method is declared static.
bool IsStatic() {
return (GetAccessFlags() & kAccStatic) != 0;
// Returns true if the method is a constructor.
bool IsConstructor() {
return (GetAccessFlags() & kAccConstructor) != 0;
// Returns true if the method is a class initializer.
bool IsClassInitializer() {
return IsConstructor() && IsStatic();
// Returns true if the method is static, private, or a constructor.
bool IsDirect() {
return IsDirect(GetAccessFlags());
static bool IsDirect(uint32_t access_flags) {
constexpr uint32_t direct = kAccStatic | kAccPrivate | kAccConstructor;
return (access_flags & direct) != 0;
// Returns true if the method is declared synchronized.
bool IsSynchronized() {
constexpr uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
return (GetAccessFlags() & synchonized) != 0;
bool IsFinal() {
return (GetAccessFlags() & kAccFinal) != 0;
bool IsCopied() {
const bool copied = (GetAccessFlags() & kAccCopied) != 0;
// (IsMiranda() || IsDefaultConflicting()) implies copied
DCHECK(!(IsMiranda() || IsDefaultConflicting()) || copied)
<< "Miranda or default-conflict methods must always be copied.";
return copied;
bool IsMiranda() {
return (GetAccessFlags() & kAccMiranda) != 0;
// Returns true if invoking this method will not throw an AbstractMethodError or
// IncompatibleClassChangeError.
bool IsInvokable() {
return !IsAbstract() && !IsDefaultConflicting();
bool IsCompilable() {
return (GetAccessFlags() & kAccCompileDontBother) == 0;
// A default conflict method is a special sentinel method that stands for a conflict between
// multiple default methods. It cannot be invoked, throwing an IncompatibleClassChangeError if one
// attempts to do so.
bool IsDefaultConflicting() {
return (GetAccessFlags() & kAccDefaultConflict) != 0u;
// This is set by the class linker.
bool IsDefault() {
return (GetAccessFlags() & kAccDefault) != 0;
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
bool IsNative() {
return (GetAccessFlags<kReadBarrierOption>() & kAccNative) != 0;
bool IsFastNative() {
constexpr uint32_t mask = kAccFastNative | kAccNative;
return (GetAccessFlags() & mask) == mask;
bool IsAbstract() {
return (GetAccessFlags() & kAccAbstract) != 0;
bool IsSynthetic() {
return (GetAccessFlags() & kAccSynthetic) != 0;
bool IsProxyMethod() SHARED_REQUIRES(Locks::mutator_lock_);
bool SkipAccessChecks() {
return (GetAccessFlags() & kAccSkipAccessChecks) != 0;
void SetSkipAccessChecks() {
SetAccessFlags(GetAccessFlags() | kAccSkipAccessChecks);
// Should this method be run in the interpreter and count locks (e.g., failed structured-
// locking verification)?
bool MustCountLocks() {
return (GetAccessFlags() & kAccMustCountLocks) != 0;
// Returns true if this method could be overridden by a default method.
bool IsOverridableByDefaultMethod() SHARED_REQUIRES(Locks::mutator_lock_);
bool CheckIncompatibleClassChange(InvokeType type) SHARED_REQUIRES(Locks::mutator_lock_);
// Throws the error that would result from trying to invoke this method (i.e.
// IncompatibleClassChangeError or AbstractMethodError). Only call if !IsInvokable();
void ThrowInvocationTimeError() SHARED_REQUIRES(Locks::mutator_lock_);
uint16_t GetMethodIndex() SHARED_REQUIRES(Locks::mutator_lock_);
// Doesn't do erroneous / unresolved class checks.
uint16_t GetMethodIndexDuringLinking() SHARED_REQUIRES(Locks::mutator_lock_);
size_t GetVtableIndex() SHARED_REQUIRES(Locks::mutator_lock_) {
return GetMethodIndex();
void SetMethodIndex(uint16_t new_method_index) SHARED_REQUIRES(Locks::mutator_lock_) {
// Not called within a transaction.
method_index_ = new_method_index;
static MemberOffset DexMethodIndexOffset() {
return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_method_index_);
static MemberOffset MethodIndexOffset() {
return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_);
uint32_t GetCodeItemOffset() {
return dex_code_item_offset_;
void SetCodeItemOffset(uint32_t new_code_off) {
// Not called within a transaction.
dex_code_item_offset_ = new_code_off;
// Number of 32bit registers that would be required to hold all the arguments
static size_t NumArgRegisters(const StringPiece& shorty);
ALWAYS_INLINE uint32_t GetDexMethodIndex() SHARED_REQUIRES(Locks::mutator_lock_);
void SetDexMethodIndex(uint32_t new_idx) {
// Not called within a transaction.
dex_method_index_ = new_idx;
ALWAYS_INLINE ArtMethod** GetDexCacheResolvedMethods(size_t pointer_size)
ALWAYS_INLINE ArtMethod* GetDexCacheResolvedMethod(uint16_t method_index, size_t ptr_size)
ALWAYS_INLINE void SetDexCacheResolvedMethod(uint16_t method_index,
ArtMethod* new_method,
size_t ptr_size)
ALWAYS_INLINE void SetDexCacheResolvedMethods(ArtMethod** new_dex_cache_methods, size_t ptr_size)
bool HasDexCacheResolvedMethods(size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
bool HasSameDexCacheResolvedMethods(ArtMethod* other, size_t pointer_size)
bool HasSameDexCacheResolvedMethods(ArtMethod** other_cache, size_t pointer_size)
template <bool kWithCheck = true>
mirror::Class* GetDexCacheResolvedType(uint32_t type_idx, size_t ptr_size)
void SetDexCacheResolvedTypes(GcRoot<mirror::Class>* new_dex_cache_types, size_t ptr_size)
bool HasDexCacheResolvedTypes(size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
bool HasSameDexCacheResolvedTypes(ArtMethod* other, size_t pointer_size)
bool HasSameDexCacheResolvedTypes(GcRoot<mirror::Class>* other_cache, size_t pointer_size)
// Get the Class* from the type index into this method's dex cache.
mirror::Class* GetClassFromTypeIndex(uint16_t type_idx, bool resolve, size_t ptr_size)
// Returns true if this method has the same name and signature of the other method.
bool HasSameNameAndSignature(ArtMethod* other) SHARED_REQUIRES(Locks::mutator_lock_);
// Find the method that this method overrides.
ArtMethod* FindOverriddenMethod(size_t pointer_size)
// Find the method index for this method within other_dexfile. If this method isn't present then
// return DexFile::kDexNoIndex. The name_and_signature_idx MUST refer to a MethodId with the same
// name and signature in the other_dexfile, such as the method index used to resolve this method
// in the other_dexfile.
uint32_t FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile,
uint32_t name_and_signature_idx)
void Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, const char* shorty)
const void* GetEntryPointFromQuickCompiledCode() {
return GetEntryPointFromQuickCompiledCodePtrSize(sizeof(void*));
ALWAYS_INLINE const void* GetEntryPointFromQuickCompiledCodePtrSize(size_t pointer_size) {
return GetNativePointer<const void*>(
EntryPointFromQuickCompiledCodeOffset(pointer_size), pointer_size);
void SetEntryPointFromQuickCompiledCode(const void* entry_point_from_quick_compiled_code) {
ALWAYS_INLINE void SetEntryPointFromQuickCompiledCodePtrSize(
const void* entry_point_from_quick_compiled_code, size_t pointer_size) {
entry_point_from_quick_compiled_code, pointer_size);
void RegisterNative(const void* native_method, bool is_fast)
void UnregisterNative() SHARED_REQUIRES(Locks::mutator_lock_);
static MemberOffset DexCacheResolvedMethodsOffset(size_t pointer_size) {
return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
PtrSizedFields, dex_cache_resolved_methods_) / sizeof(void*) * pointer_size);
static MemberOffset DexCacheResolvedTypesOffset(size_t pointer_size) {
return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
PtrSizedFields, dex_cache_resolved_types_) / sizeof(void*) * pointer_size);
static MemberOffset EntryPointFromJniOffset(size_t pointer_size) {
return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
PtrSizedFields, entry_point_from_jni_) / sizeof(void*) * pointer_size);
static MemberOffset EntryPointFromQuickCompiledCodeOffset(size_t pointer_size) {
return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
PtrSizedFields, entry_point_from_quick_compiled_code_) / sizeof(void*) * pointer_size);
ProfilingInfo* GetProfilingInfo(size_t pointer_size) {
return reinterpret_cast<ProfilingInfo*>(GetEntryPointFromJniPtrSize(pointer_size));
ImtConflictTable* GetImtConflictTable(size_t pointer_size) {
return reinterpret_cast<ImtConflictTable*>(GetEntryPointFromJniPtrSize(pointer_size));
ALWAYS_INLINE void SetImtConflictTable(ImtConflictTable* table, size_t pointer_size) {
SetEntryPointFromJniPtrSize(table, pointer_size);
ALWAYS_INLINE void SetProfilingInfo(ProfilingInfo* info) {
SetEntryPointFromJniPtrSize(info, sizeof(void*));
ALWAYS_INLINE void SetProfilingInfoPtrSize(ProfilingInfo* info, size_t pointer_size) {
SetEntryPointFromJniPtrSize(info, pointer_size);
static MemberOffset ProfilingInfoOffset() {
return EntryPointFromJniOffset(sizeof(void*));
void* GetEntryPointFromJni() {
return GetEntryPointFromJniPtrSize(sizeof(void*));
ALWAYS_INLINE void* GetEntryPointFromJniPtrSize(size_t pointer_size) {
return GetNativePointer<void*>(EntryPointFromJniOffset(pointer_size), pointer_size);
void SetEntryPointFromJni(const void* entrypoint) {
SetEntryPointFromJniPtrSize(entrypoint, sizeof(void*));
ALWAYS_INLINE void SetEntryPointFromJniPtrSize(const void* entrypoint, size_t pointer_size) {
SetNativePointer(EntryPointFromJniOffset(pointer_size), entrypoint, pointer_size);
// Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
// conventions for a method of managed code. Returns false for Proxy methods.
ALWAYS_INLINE bool IsRuntimeMethod();
// Is this a hand crafted method used for something like describing callee saves?
bool IsCalleeSaveMethod() SHARED_REQUIRES(Locks::mutator_lock_);
bool IsResolutionMethod() SHARED_REQUIRES(Locks::mutator_lock_);
bool IsImtUnimplementedMethod() SHARED_REQUIRES(Locks::mutator_lock_);
MethodReference ToMethodReference() SHARED_REQUIRES(Locks::mutator_lock_) {
return MethodReference(GetDexFile(), GetDexMethodIndex());
// Find the catch block for the given exception type and dex_pc. When a catch block is found,
// indicates whether the found catch block is responsible for clearing the exception or whether
// a move-exception instruction is present.
uint32_t FindCatchBlock(Handle<mirror::Class> exception_type, uint32_t dex_pc,
bool* has_no_move_exception)
// NO_THREAD_SAFETY_ANALYSIS since we don't know what the callback requires.
template<typename RootVisitorType>
void VisitRoots(RootVisitorType& visitor, size_t pointer_size) NO_THREAD_SAFETY_ANALYSIS;
const DexFile* GetDexFile() SHARED_REQUIRES(Locks::mutator_lock_);
const char* GetDeclaringClassDescriptor() SHARED_REQUIRES(Locks::mutator_lock_);
const char* GetShorty() SHARED_REQUIRES(Locks::mutator_lock_) {
uint32_t unused_length;
return GetShorty(&unused_length);
const char* GetShorty(uint32_t* out_length) SHARED_REQUIRES(Locks::mutator_lock_);
const Signature GetSignature() SHARED_REQUIRES(Locks::mutator_lock_);
ALWAYS_INLINE const char* GetName() SHARED_REQUIRES(Locks::mutator_lock_);
mirror::String* GetNameAsString(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
const DexFile::CodeItem* GetCodeItem() SHARED_REQUIRES(Locks::mutator_lock_);
bool IsResolvedTypeIdx(uint16_t type_idx, size_t ptr_size) SHARED_REQUIRES(Locks::mutator_lock_);
int32_t GetLineNumFromDexPC(uint32_t dex_pc) SHARED_REQUIRES(Locks::mutator_lock_);
const DexFile::ProtoId& GetPrototype() SHARED_REQUIRES(Locks::mutator_lock_);
const DexFile::TypeList* GetParameterTypeList() SHARED_REQUIRES(Locks::mutator_lock_);
const char* GetDeclaringClassSourceFile() SHARED_REQUIRES(Locks::mutator_lock_);
uint16_t GetClassDefIndex() SHARED_REQUIRES(Locks::mutator_lock_);
const DexFile::ClassDef& GetClassDef() SHARED_REQUIRES(Locks::mutator_lock_);
const char* GetReturnTypeDescriptor() SHARED_REQUIRES(Locks::mutator_lock_);
const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx)
// May cause thread suspension due to GetClassFromTypeIdx calling ResolveType this caused a large
// number of bugs at call sites.
mirror::Class* GetReturnType(bool resolve, size_t ptr_size)
mirror::ClassLoader* GetClassLoader() SHARED_REQUIRES(Locks::mutator_lock_);
mirror::DexCache* GetDexCache() SHARED_REQUIRES(Locks::mutator_lock_);
ALWAYS_INLINE ArtMethod* GetInterfaceMethodIfProxy(size_t pointer_size)
// May cause thread suspension due to class resolution.
bool EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params)
// Size of an instance of this native class.
static size_t Size(size_t pointer_size) {
return RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size) +
(sizeof(PtrSizedFields) / sizeof(void*)) * pointer_size;
// Alignment of an instance of this native class.
static size_t Alignment(size_t pointer_size) {
// The ArtMethod alignment is the same as image pointer size. This differs from
// alignof(ArtMethod) if cross-compiling with pointer_size != sizeof(void*).
return pointer_size;
void CopyFrom(ArtMethod* src, size_t image_pointer_size)
ALWAYS_INLINE GcRoot<mirror::Class>* GetDexCacheResolvedTypes(size_t pointer_size)
// Note, hotness_counter_ updates are non-atomic but it doesn't need to be precise. Also,
// given that the counter is only 16 bits wide we can expect wrap-around in some
// situations. Consumers of hotness_count_ must be able to deal with that.
uint16_t IncrementCounter() {
return ++hotness_count_;
void ClearCounter() {
hotness_count_ = 0;
void SetCounter(int16_t hotness_count) {
hotness_count_ = hotness_count;
uint16_t GetCounter() const {
return hotness_count_;
const uint8_t* GetQuickenedInfo() SHARED_REQUIRES(Locks::mutator_lock_);
// Returns the method header for the compiled code containing 'pc'. Note that runtime
// methods will return null for this method, as they are not oat based.
const OatQuickMethodHeader* GetOatQuickMethodHeader(uintptr_t pc)
// Returns whether the method has any compiled code, JIT or AOT.
bool HasAnyCompiledCode() SHARED_REQUIRES(Locks::mutator_lock_);
// Update heap objects and non-entrypoint pointers by the passed in visitor for image relocation.
// Does not use read barrier.
template <typename Visitor>
ALWAYS_INLINE void UpdateObjectsForImageRelocation(const Visitor& visitor, size_t pointer_size)
// Update entry points by passing them through the visitor.
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier, typename Visitor>
ALWAYS_INLINE void UpdateEntrypoints(const Visitor& visitor, size_t pointer_size);
// Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
// The class we are a part of.
GcRoot<mirror::Class> declaring_class_;
// Access flags; low 16 bits are defined by spec.
uint32_t access_flags_;
/* Dex file fields. The defining dex file is available via declaring_class_->dex_cache_ */
// Offset to the CodeItem.
uint32_t dex_code_item_offset_;
// Index into method_ids of the dex file associated with this method.
uint32_t dex_method_index_;
/* End of dex file fields. */
// Entry within a dispatch table for this method. For static/direct methods the index is into
// the declaringClass.directMethods, for virtual methods the vtable and for interface methods the
// ifTable.
uint16_t method_index_;
// The hotness we measure for this method. Managed by the interpreter. Not atomic, as we allow
// missing increments: if the method is hot, we will see it eventually.
uint16_t hotness_count_;
// Fake padding field gets inserted here.
// Must be the last fields in the method.
// PACKED(4) is necessary for the correctness of
// RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size).
struct PACKED(4) PtrSizedFields {
// Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
ArtMethod** dex_cache_resolved_methods_;
// Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
GcRoot<mirror::Class>* dex_cache_resolved_types_;
// Pointer to JNI function registered to this method, or a function to resolve the JNI function,
// or the profiling data for non-native methods, or an ImtConflictTable.
void* entry_point_from_jni_;
// Method dispatch from quick compiled code invokes this pointer which may cause bridging into
// the interpreter.
void* entry_point_from_quick_compiled_code_;
} ptr_sized_fields_;
static size_t PtrSizedFieldsOffset(size_t pointer_size) {
// Round up to pointer size for padding field.
return RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size);
template<typename T>
ALWAYS_INLINE T GetNativePointer(MemberOffset offset, size_t pointer_size) const {
static_assert(std::is_pointer<T>::value, "T must be a pointer type");
DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
const auto addr = reinterpret_cast<uintptr_t>(this) + offset.Uint32Value();
if (pointer_size == sizeof(uint32_t)) {
return reinterpret_cast<T>(*reinterpret_cast<const uint32_t*>(addr));
} else {
auto v = *reinterpret_cast<const uint64_t*>(addr);
return reinterpret_cast<T>(dchecked_integral_cast<uintptr_t>(v));
template<typename T>
ALWAYS_INLINE void SetNativePointer(MemberOffset offset, T new_value, size_t pointer_size) {
static_assert(std::is_pointer<T>::value, "T must be a pointer type");
DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
const auto addr = reinterpret_cast<uintptr_t>(this) + offset.Uint32Value();
if (pointer_size == sizeof(uint32_t)) {
uintptr_t ptr = reinterpret_cast<uintptr_t>(new_value);
*reinterpret_cast<uint32_t*>(addr) = dchecked_integral_cast<uint32_t>(ptr);
} else {
*reinterpret_cast<uint64_t*>(addr) = reinterpret_cast<uintptr_t>(new_value);
DISALLOW_COPY_AND_ASSIGN(ArtMethod); // Need to use CopyFrom to deal with 32 vs 64 bits.
} // namespace art