• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_ART_METHOD_H_
18 #define ART_RUNTIME_MIRROR_ART_METHOD_H_
19 
20 #include "dex_file.h"
21 #include "gc_root.h"
22 #include "invoke_type.h"
23 #include "modifiers.h"
24 #include "object.h"
25 #include "object_callbacks.h"
26 #include "quick/quick_method_frame_info.h"
27 #include "read_barrier_option.h"
28 
29 namespace art {
30 
31 struct ArtMethodOffsets;
32 struct ConstructorMethodOffsets;
33 union JValue;
34 class MethodHelper;
35 class ScopedObjectAccessAlreadyRunnable;
36 class StringPiece;
37 class ShadowFrame;
38 
39 namespace mirror {
40 
41 typedef void (EntryPointFromInterpreter)(Thread* self, MethodHelper& mh,
42     const DexFile::CodeItem* code_item, ShadowFrame* shadow_frame, JValue* result);
43 
44 // C++ mirror of java.lang.reflect.ArtMethod.
45 class MANAGED ArtMethod FINAL : public Object {
46  public:
47   // Size of java.lang.reflect.ArtMethod.class.
48   static uint32_t ClassSize();
49 
50   // Size of an instance of java.lang.reflect.ArtMethod not including its value array.
InstanceSize()51   static constexpr uint32_t InstanceSize() {
52     return sizeof(ArtMethod);
53   }
54 
55   static ArtMethod* FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa,
56                                         jobject jlr_method)
57       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
58 
59   Class* GetDeclaringClass() ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
60 
61   void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
62 
DeclaringClassOffset()63   static MemberOffset DeclaringClassOffset() {
64     return MemberOffset(OFFSETOF_MEMBER(ArtMethod, declaring_class_));
65   }
66 
67   uint32_t GetAccessFlags() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
68 
SetAccessFlags(uint32_t new_access_flags)69   void SetAccessFlags(uint32_t new_access_flags) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
70     // Not called within a transaction.
71     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, access_flags_), new_access_flags);
72   }
73 
74   // Approximate what kind of method call would be used for this method.
75   InvokeType GetInvokeType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
76 
77   // Returns true if the method is declared public.
IsPublic()78   bool IsPublic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
79     return (GetAccessFlags() & kAccPublic) != 0;
80   }
81 
82   // Returns true if the method is declared private.
IsPrivate()83   bool IsPrivate() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
84     return (GetAccessFlags() & kAccPrivate) != 0;
85   }
86 
87   // Returns true if the method is declared static.
IsStatic()88   bool IsStatic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
89     return (GetAccessFlags() & kAccStatic) != 0;
90   }
91 
92   // Returns true if the method is a constructor.
IsConstructor()93   bool IsConstructor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
94     return (GetAccessFlags() & kAccConstructor) != 0;
95   }
96 
97   // Returns true if the method is a class initializer.
IsClassInitializer()98   bool IsClassInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
99     return IsConstructor() && IsStatic();
100   }
101 
102   // Returns true if the method is static, private, or a constructor.
IsDirect()103   bool IsDirect() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
104     return IsDirect(GetAccessFlags());
105   }
106 
IsDirect(uint32_t access_flags)107   static bool IsDirect(uint32_t access_flags) {
108     return (access_flags & (kAccStatic | kAccPrivate | kAccConstructor)) != 0;
109   }
110 
111   // Returns true if the method is declared synchronized.
IsSynchronized()112   bool IsSynchronized() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
113     uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
114     return (GetAccessFlags() & synchonized) != 0;
115   }
116 
IsFinal()117   bool IsFinal() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
118     return (GetAccessFlags() & kAccFinal) != 0;
119   }
120 
IsMiranda()121   bool IsMiranda() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
122     return (GetAccessFlags() & kAccMiranda) != 0;
123   }
124 
IsNative()125   bool IsNative() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
126     return (GetAccessFlags() & kAccNative) != 0;
127   }
128 
IsFastNative()129   bool IsFastNative() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
130     uint32_t mask = kAccFastNative | kAccNative;
131     return (GetAccessFlags() & mask) == mask;
132   }
133 
IsAbstract()134   bool IsAbstract() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
135     return (GetAccessFlags() & kAccAbstract) != 0;
136   }
137 
IsSynthetic()138   bool IsSynthetic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
139     return (GetAccessFlags() & kAccSynthetic) != 0;
140   }
141 
142   bool IsProxyMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
143 
IsPreverified()144   bool IsPreverified() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
145     return (GetAccessFlags() & kAccPreverified) != 0;
146   }
147 
SetPreverified()148   void SetPreverified() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
149     DCHECK(!IsPreverified());
150     SetAccessFlags(GetAccessFlags() | kAccPreverified);
151   }
152 
IsPortableCompiled()153   bool IsPortableCompiled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
154     return kUsePortableCompiler && ((GetAccessFlags() & kAccPortableCompiled) != 0);
155   }
156 
SetIsPortableCompiled()157   void SetIsPortableCompiled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
158     DCHECK(!IsPortableCompiled());
159     SetAccessFlags(GetAccessFlags() | kAccPortableCompiled);
160   }
161 
ClearIsPortableCompiled()162   void ClearIsPortableCompiled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
163     DCHECK(IsPortableCompiled());
164     SetAccessFlags(GetAccessFlags() & ~kAccPortableCompiled);
165   }
166 
167   bool CheckIncompatibleClassChange(InvokeType type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
168 
169   uint16_t GetMethodIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
170 
GetVtableIndex()171   size_t GetVtableIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
172     return GetMethodIndex();
173   }
174 
SetMethodIndex(uint16_t new_method_index)175   void SetMethodIndex(uint16_t new_method_index) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
176     // Not called within a transaction.
177     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_), new_method_index);
178   }
179 
MethodIndexOffset()180   static MemberOffset MethodIndexOffset() {
181     return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_);
182   }
183 
GetCodeItemOffset()184   uint32_t GetCodeItemOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
185     return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_code_item_offset_));
186   }
187 
SetCodeItemOffset(uint32_t new_code_off)188   void SetCodeItemOffset(uint32_t new_code_off) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
189     // Not called within a transaction.
190     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_code_item_offset_), new_code_off);
191   }
192 
193   // Number of 32bit registers that would be required to hold all the arguments
194   static size_t NumArgRegisters(const StringPiece& shorty);
195 
196   uint32_t GetDexMethodIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
197 
SetDexMethodIndex(uint32_t new_idx)198   void SetDexMethodIndex(uint32_t new_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
199     // Not called within a transaction.
200     SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_method_index_), new_idx);
201   }
202 
203   ObjectArray<String>* GetDexCacheStrings() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
204   void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings)
205       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
206 
DexCacheStringsOffset()207   static MemberOffset DexCacheStringsOffset() {
208     return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_);
209   }
210 
DexCacheResolvedMethodsOffset()211   static MemberOffset DexCacheResolvedMethodsOffset() {
212     return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_);
213   }
214 
DexCacheResolvedTypesOffset()215   static MemberOffset DexCacheResolvedTypesOffset() {
216     return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_);
217   }
218 
219   ArtMethod* GetDexCacheResolvedMethod(uint16_t method_idx)
220       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
221   void SetDexCacheResolvedMethod(uint16_t method_idx, ArtMethod* new_method)
222       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
223   void SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods)
224       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
225   bool HasDexCacheResolvedMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
226   bool HasSameDexCacheResolvedMethods(ArtMethod* other) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
227   bool HasSameDexCacheResolvedMethods(ObjectArray<ArtMethod>* other_cache)
228       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
229 
230   template <bool kWithCheck = true>
231   Class* GetDexCacheResolvedType(uint32_t type_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
232   void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types)
233       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
234   bool HasDexCacheResolvedTypes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
235   bool HasSameDexCacheResolvedTypes(ArtMethod* other) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
236   bool HasSameDexCacheResolvedTypes(ObjectArray<Class>* other_cache)
237       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
238 
239   // Find the method that this method overrides
240   ArtMethod* FindOverriddenMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
241 
242   void Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, const char* shorty)
243       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
244 
245   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetEntryPointFromInterpreter()246   EntryPointFromInterpreter* GetEntryPointFromInterpreter()
247       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
248     return GetFieldPtr<EntryPointFromInterpreter*, kVerifyFlags>(
249         OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_interpreter_));
250   }
251 
252   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
SetEntryPointFromInterpreter(EntryPointFromInterpreter * entry_point_from_interpreter)253   void SetEntryPointFromInterpreter(EntryPointFromInterpreter* entry_point_from_interpreter)
254       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
255     SetFieldPtr<false, true, kVerifyFlags>(
256         OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_interpreter_),
257         entry_point_from_interpreter);
258   }
259 
260 #if defined(ART_USE_PORTABLE_COMPILER)
EntryPointFromPortableCompiledCodeOffset()261   static MemberOffset EntryPointFromPortableCompiledCodeOffset() {
262     return MemberOffset(OFFSETOF_MEMBER(ArtMethod, entry_point_from_portable_compiled_code_));
263   }
264 
265   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetEntryPointFromPortableCompiledCode()266   const void* GetEntryPointFromPortableCompiledCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
267     return GetFieldPtr<const void*, kVerifyFlags>(
268         EntryPointFromPortableCompiledCodeOffset());
269   }
270 
271   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
SetEntryPointFromPortableCompiledCode(const void * entry_point_from_portable_compiled_code)272   void SetEntryPointFromPortableCompiledCode(const void* entry_point_from_portable_compiled_code)
273       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
274     SetFieldPtr<false, true, kVerifyFlags>(
275         EntryPointFromPortableCompiledCodeOffset(), entry_point_from_portable_compiled_code);
276   }
277 #endif
278 
EntryPointFromQuickCompiledCodeOffset()279   static MemberOffset EntryPointFromQuickCompiledCodeOffset() {
280     return MemberOffset(OFFSETOF_MEMBER(ArtMethod, entry_point_from_quick_compiled_code_));
281   }
282 
283   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetEntryPointFromQuickCompiledCode()284   const void* GetEntryPointFromQuickCompiledCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
285     return GetFieldPtr<const void*, kVerifyFlags>(EntryPointFromQuickCompiledCodeOffset());
286   }
287 
288   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
SetEntryPointFromQuickCompiledCode(const void * entry_point_from_quick_compiled_code)289   void SetEntryPointFromQuickCompiledCode(const void* entry_point_from_quick_compiled_code)
290       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
291     SetFieldPtr<false, true, kVerifyFlags>(
292         EntryPointFromQuickCompiledCodeOffset(), entry_point_from_quick_compiled_code);
293   }
294 
295   uint32_t GetCodeSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
296 
IsWithinQuickCode(uintptr_t pc)297   bool IsWithinQuickCode(uintptr_t pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
298     uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromQuickCompiledCode());
299     if (code == 0) {
300       return pc == 0;
301     }
302     /*
303      * During a stack walk, a return PC may point past-the-end of the code
304      * in the case that the last instruction is a call that isn't expected to
305      * return.  Thus, we check <= code + GetCodeSize().
306      *
307      * NOTE: For Thumb both pc and code are offset by 1 indicating the Thumb state.
308      */
309     return code <= pc && pc <= code + GetCodeSize();
310   }
311 
312   void AssertPcIsWithinQuickCode(uintptr_t pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
313 
314 #if defined(ART_USE_PORTABLE_COMPILER)
315   uint32_t GetPortableOatCodeOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
316   void SetPortableOatCodeOffset(uint32_t code_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
317 #endif
318   uint32_t GetQuickOatCodeOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
319   void SetQuickOatCodeOffset(uint32_t code_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
320 
EntryPointToCodePointer(const void * entry_point)321   static const void* EntryPointToCodePointer(const void* entry_point) ALWAYS_INLINE {
322     uintptr_t code = reinterpret_cast<uintptr_t>(entry_point);
323     code &= ~0x1;  // TODO: Make this Thumb2 specific.
324     return reinterpret_cast<const void*>(code);
325   }
326 
327   // Actual entry point pointer to compiled oat code or nullptr.
328   const void* GetQuickOatEntryPoint() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
329   // Actual pointer to compiled oat code or nullptr.
330   const void* GetQuickOatCodePointer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
331 
332   // Callers should wrap the uint8_t* in a MappingTable instance for convenient access.
333   const uint8_t* GetMappingTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
334   const uint8_t* GetMappingTable(const void* code_pointer)
335       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
336 
337   // Callers should wrap the uint8_t* in a VmapTable instance for convenient access.
338   const uint8_t* GetVmapTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
339   const uint8_t* GetVmapTable(const void* code_pointer)
340       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
341 
GetNativeGcMap()342   const uint8_t* GetNativeGcMap() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
343     return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_));
344   }
345   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
SetNativeGcMap(const uint8_t * data)346   void SetNativeGcMap(const uint8_t* data) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
347     SetFieldPtr<false, true, kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_), data);
348   }
349 
350   // When building the oat need a convenient place to stuff the offset of the native GC map.
351   void SetOatNativeGcMapOffset(uint32_t gc_map_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
352   uint32_t GetOatNativeGcMapOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
353 
354   template <bool kCheckFrameSize = true>
GetFrameSizeInBytes()355   uint32_t GetFrameSizeInBytes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
356     uint32_t result = GetQuickFrameInfo().FrameSizeInBytes();
357     if (kCheckFrameSize) {
358       DCHECK_LE(static_cast<size_t>(kStackAlignment), result);
359     }
360     return result;
361   }
362 
363   QuickMethodFrameInfo GetQuickFrameInfo() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
364   QuickMethodFrameInfo GetQuickFrameInfo(const void* code_pointer)
365       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
366 
GetReturnPcOffsetInBytes()367   size_t GetReturnPcOffsetInBytes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
368     return GetReturnPcOffsetInBytes(GetFrameSizeInBytes());
369   }
370 
GetReturnPcOffsetInBytes(uint32_t frame_size_in_bytes)371   size_t GetReturnPcOffsetInBytes(uint32_t frame_size_in_bytes)
372       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
373     DCHECK_EQ(frame_size_in_bytes, GetFrameSizeInBytes());
374     return frame_size_in_bytes - kPointerSize;
375   }
376 
GetHandleScopeOffsetInBytes()377   size_t GetHandleScopeOffsetInBytes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
378     return kPointerSize;
379   }
380 
381   void RegisterNative(Thread* self, const void* native_method, bool is_fast)
382       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
383 
384   void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
385 
NativeMethodOffset()386   static MemberOffset NativeMethodOffset() {
387     return OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_jni_);
388   }
389 
GetNativeMethod()390   const void* GetNativeMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
391     return GetFieldPtr<const void*>(NativeMethodOffset());
392   }
393 
394   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
395   void SetNativeMethod(const void*) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
396 
GetMethodIndexOffset()397   static MemberOffset GetMethodIndexOffset() {
398     return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_);
399   }
400 
401   // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
402   // conventions for a method of managed code. Returns false for Proxy methods.
403   bool IsRuntimeMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
404 
405   // Is this a hand crafted method used for something like describing callee saves?
406   bool IsCalleeSaveMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
407 
408   bool IsResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
409 
410   bool IsImtConflictMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
411 
412   uintptr_t NativePcOffset(const uintptr_t pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
413   uintptr_t NativePcOffset(const uintptr_t pc, const void* quick_entry_point)
414       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
415 
416   // Converts a native PC to a dex PC.
417   uint32_t ToDexPc(const uintptr_t pc, bool abort_on_failure = true)
418       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
419 
420   // Converts a dex PC to a native PC.
421   uintptr_t ToNativePc(const uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
422 
423   // Find the catch block for the given exception type and dex_pc. When a catch block is found,
424   // indicates whether the found catch block is responsible for clearing the exception or whether
425   // a move-exception instruction is present.
426   static uint32_t FindCatchBlock(Handle<ArtMethod> h_this, Handle<Class> exception_type,
427                                  uint32_t dex_pc, bool* has_no_move_exception)
428       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
429 
430   static void SetClass(Class* java_lang_reflect_ArtMethod);
431 
432   template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
433   static Class* GetJavaLangReflectArtMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
434 
435   static void ResetClass();
436 
437   static void VisitRoots(RootCallback* callback, void* arg)
438       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
439 
440   const DexFile* GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
441 
442   const char* GetDeclaringClassDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
443 
GetShorty()444   const char* GetShorty() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
445     uint32_t unused_length;
446     return GetShorty(&unused_length);
447   }
448 
449   const char* GetShorty(uint32_t* out_length) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
450 
451   const Signature GetSignature() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
452 
453   ALWAYS_INLINE const char* GetName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
454 
455   const DexFile::CodeItem* GetCodeItem() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
456 
457   bool IsResolvedTypeIdx(uint16_t type_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
458 
459   int32_t GetLineNumFromDexPC(uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
460 
461   const DexFile::ProtoId& GetPrototype() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
462 
463   const DexFile::TypeList* GetParameterTypeList() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
464 
465   const char* GetDeclaringClassSourceFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
466 
467   uint16_t GetClassDefIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
468 
469   const DexFile::ClassDef& GetClassDef() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
470 
471   const char* GetReturnTypeDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
472 
473   const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx)
474       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
475 
476   mirror::ClassLoader* GetClassLoader() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
477 
478   mirror::DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
479 
480   ALWAYS_INLINE ArtMethod* GetInterfaceMethodIfProxy() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
481 
482  protected:
483   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
484   // The class we are a part of.
485   HeapReference<Class> declaring_class_;
486 
487   // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
488   HeapReference<ObjectArray<ArtMethod>> dex_cache_resolved_methods_;
489 
490   // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
491   HeapReference<ObjectArray<Class>> dex_cache_resolved_types_;
492 
493   // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
494   HeapReference<ObjectArray<String>> dex_cache_strings_;
495 
496   // Method dispatch from the interpreter invokes this pointer which may cause a bridge into
497   // compiled code.
498   uint64_t entry_point_from_interpreter_;
499 
500   // Pointer to JNI function registered to this method, or a function to resolve the JNI function.
501   uint64_t entry_point_from_jni_;
502 
503   // Method dispatch from portable compiled code invokes this pointer which may cause bridging into
504   // quick compiled code or the interpreter.
505 #if defined(ART_USE_PORTABLE_COMPILER)
506   uint64_t entry_point_from_portable_compiled_code_;
507 #endif
508 
509   // Method dispatch from quick compiled code invokes this pointer which may cause bridging into
510   // portable compiled code or the interpreter.
511   uint64_t entry_point_from_quick_compiled_code_;
512 
513   // Pointer to a data structure created by the compiler and used by the garbage collector to
514   // determine which registers hold live references to objects within the heap. Keyed by native PC
515   // offsets for the quick compiler and dex PCs for the portable.
516   uint64_t gc_map_;
517 
518   // Access flags; low 16 bits are defined by spec.
519   uint32_t access_flags_;
520 
521   /* Dex file fields. The defining dex file is available via declaring_class_->dex_cache_ */
522 
523   // Offset to the CodeItem.
524   uint32_t dex_code_item_offset_;
525 
526   // Index into method_ids of the dex file associated with this method.
527   uint32_t dex_method_index_;
528 
529   /* End of dex file fields. */
530 
531   // Entry within a dispatch table for this method. For static/direct methods the index is into
532   // the declaringClass.directMethods, for virtual methods the vtable and for interface methods the
533   // ifTable.
534   uint32_t method_index_;
535 
536   static GcRoot<Class> java_lang_reflect_ArtMethod_;
537 
538  private:
539   ObjectArray<ArtMethod>* GetDexCacheResolvedMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
540 
541   ObjectArray<Class>* GetDexCacheResolvedTypes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
542 
543   friend struct art::ArtMethodOffsets;  // for verifying offset information
544   DISALLOW_IMPLICIT_CONSTRUCTORS(ArtMethod);
545 };
546 
547 }  // namespace mirror
548 }  // namespace art
549 
550 #endif  // ART_RUNTIME_MIRROR_ART_METHOD_H_
551