blob: 98f5aeeb4cf4d72b0ecddf9b94189f8ccd94b610 [file] [log] [blame]
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001/*
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
Mathieu Chartiere401d142015-04-22 13:56:20 -070017#ifndef ART_RUNTIME_ART_METHOD_H_
18#define ART_RUNTIME_ART_METHOD_H_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080019
Nicolas Geoffray6bc43742015-10-12 18:11:10 +010020#include "base/bit_utils.h"
Vladimir Marko05792b92015-08-03 11:56:49 +010021#include "base/casts.h"
Jeff Hao790ad902013-05-22 15:02:08 -070022#include "dex_file.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070023#include "gc_root.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080024#include "invoke_type.h"
Mathieu Chartier36b58f52014-12-10 12:06:45 -080025#include "method_reference.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026#include "modifiers.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070027#include "mirror/object.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070028#include "read_barrier_option.h"
Sebastien Hertze4b7c892014-12-17 20:02:50 +010029#include "stack.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070030#include "utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080031
32namespace art {
33
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034union JValue;
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +010035class OatQuickMethodHeader;
Nicolas Geoffray5550ca82015-08-21 18:38:30 +010036class ProfilingInfo;
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070037class ScopedObjectAccessAlreadyRunnable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038class StringPiece;
Jeff Hao16743632013-05-08 10:59:04 -070039class ShadowFrame;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080040
41namespace mirror {
Mathieu Chartiere401d142015-04-22 13:56:20 -070042class Array;
43class Class;
44class PointerArray;
45} // namespace mirror
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080046
Mathieu Chartiere401d142015-04-22 13:56:20 -070047class ArtMethod FINAL {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080048 public:
Mathieu Chartiere401d142015-04-22 13:56:20 -070049 ArtMethod() : access_flags_(0), dex_code_item_offset_(0), dex_method_index_(0),
50 method_index_(0) { }
51
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +000052 ArtMethod(ArtMethod* src, size_t image_pointer_size) {
53 CopyFrom(src, image_pointer_size);
Mathieu Chartiere401d142015-04-22 13:56:20 -070054 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -070055
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070056 static ArtMethod* FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa,
57 jobject jlr_method)
Mathieu Chartier90443472015-07-16 20:32:27 -070058 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers62f05122014-03-21 11:21:29 -070059
Mathieu Chartier90443472015-07-16 20:32:27 -070060 ALWAYS_INLINE mirror::Class* GetDeclaringClass() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080061
Mathieu Chartiere401d142015-04-22 13:56:20 -070062 ALWAYS_INLINE mirror::Class* GetDeclaringClassNoBarrier()
Mathieu Chartier90443472015-07-16 20:32:27 -070063 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -070064
65 ALWAYS_INLINE mirror::Class* GetDeclaringClassUnchecked()
Mathieu Chartier90443472015-07-16 20:32:27 -070066 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -070067
68 void SetDeclaringClass(mirror::Class *new_declaring_class)
Mathieu Chartier90443472015-07-16 20:32:27 -070069 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080070
Mathieu Chartier10e5ea92015-08-13 12:56:31 -070071 bool CASDeclaringClass(mirror::Class* expected_class, mirror::Class* desired_class)
72 SHARED_REQUIRES(Locks::mutator_lock_);
73
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080074 static MemberOffset DeclaringClassOffset() {
Brian Carlstromea46f952013-07-30 01:26:50 -070075 return MemberOffset(OFFSETOF_MEMBER(ArtMethod, declaring_class_));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080076 }
77
Andreas Gampecbc96b82015-09-30 20:05:24 +000078 // Note: GetAccessFlags acquires the mutator lock in debug mode to check that it is not called for
79 // a proxy method.
80 ALWAYS_INLINE uint32_t GetAccessFlags();
Jeff Hao5d917302013-02-27 17:57:33 -080081
Mathieu Chartiere401d142015-04-22 13:56:20 -070082 void SetAccessFlags(uint32_t new_access_flags) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010083 // Not called within a transaction.
Mathieu Chartiere401d142015-04-22 13:56:20 -070084 access_flags_ = new_access_flags;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080085 }
86
87 // Approximate what kind of method call would be used for this method.
Mathieu Chartier90443472015-07-16 20:32:27 -070088 InvokeType GetInvokeType() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080089
90 // Returns true if the method is declared public.
Andreas Gampecbc96b82015-09-30 20:05:24 +000091 bool IsPublic() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080092 return (GetAccessFlags() & kAccPublic) != 0;
93 }
94
95 // Returns true if the method is declared private.
Andreas Gampecbc96b82015-09-30 20:05:24 +000096 bool IsPrivate() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080097 return (GetAccessFlags() & kAccPrivate) != 0;
98 }
99
100 // Returns true if the method is declared static.
Andreas Gampecbc96b82015-09-30 20:05:24 +0000101 bool IsStatic() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800102 return (GetAccessFlags() & kAccStatic) != 0;
103 }
104
105 // Returns true if the method is a constructor.
Andreas Gampecbc96b82015-09-30 20:05:24 +0000106 bool IsConstructor() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800107 return (GetAccessFlags() & kAccConstructor) != 0;
108 }
109
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700110 // Returns true if the method is a class initializer.
Andreas Gampecbc96b82015-09-30 20:05:24 +0000111 bool IsClassInitializer() {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700112 return IsConstructor() && IsStatic();
113 }
114
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800115 // Returns true if the method is static, private, or a constructor.
Andreas Gampecbc96b82015-09-30 20:05:24 +0000116 bool IsDirect() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800117 return IsDirect(GetAccessFlags());
118 }
119
120 static bool IsDirect(uint32_t access_flags) {
Andreas Gampecbc96b82015-09-30 20:05:24 +0000121 constexpr uint32_t direct = kAccStatic | kAccPrivate | kAccConstructor;
122 return (access_flags & direct) != 0;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800123 }
124
125 // Returns true if the method is declared synchronized.
Andreas Gampecbc96b82015-09-30 20:05:24 +0000126 bool IsSynchronized() {
127 constexpr uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800128 return (GetAccessFlags() & synchonized) != 0;
129 }
130
Andreas Gampecbc96b82015-09-30 20:05:24 +0000131 bool IsFinal() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800132 return (GetAccessFlags() & kAccFinal) != 0;
133 }
134
Andreas Gampecbc96b82015-09-30 20:05:24 +0000135 bool IsMiranda() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800136 return (GetAccessFlags() & kAccMiranda) != 0;
137 }
138
Alex Light9139e002015-10-09 15:59:48 -0700139 // Returns true if invoking this method will not throw an AbstractMethodError or
140 // IncompatibleClassChangeError.
141 bool IsInvokable() {
142 return !IsAbstract() && !IsDefaultConflicting();
143 }
144
145 // A default conflict method is a special sentinel method that stands for a conflict between
146 // multiple default methods. It cannot be invoked, throwing an IncompatibleClassChangeError if one
147 // attempts to do so.
148 bool IsDefaultConflicting() {
149 return (GetAccessFlags() & kAccDefaultConflict) != 0u;
150 }
151
Alex Lighteb7c1442015-08-31 13:17:42 -0700152 // This is set by the class linker.
153 bool IsDefault() {
154 return (GetAccessFlags() & kAccDefault) != 0;
155 }
156
Andreas Gampecbc96b82015-09-30 20:05:24 +0000157 bool IsNative() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800158 return (GetAccessFlags() & kAccNative) != 0;
159 }
160
Andreas Gampecbc96b82015-09-30 20:05:24 +0000161 bool IsFastNative() {
162 constexpr uint32_t mask = kAccFastNative | kAccNative;
Ian Rogers16ce0922014-01-10 14:59:36 -0800163 return (GetAccessFlags() & mask) == mask;
Ian Rogers1eb512d2013-10-18 15:42:20 -0700164 }
165
Andreas Gampecbc96b82015-09-30 20:05:24 +0000166 bool IsAbstract() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800167 return (GetAccessFlags() & kAccAbstract) != 0;
168 }
169
Andreas Gampecbc96b82015-09-30 20:05:24 +0000170 bool IsSynthetic() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800171 return (GetAccessFlags() & kAccSynthetic) != 0;
172 }
173
Igor Murashkin457e8742015-10-22 17:37:50 -0700174 // Does this method live on a declaring class that is itself any proxy class?
175 // -- Returns true for both java.lang.reflect.Proxy and java.lang.LambdaProxy subclasses.
Mathieu Chartier90443472015-07-16 20:32:27 -0700176 bool IsProxyMethod() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800177
Igor Murashkin457e8742015-10-22 17:37:50 -0700178 // Does this method live in a java.lang.reflect.Proxy subclass?
179 bool IsReflectProxyMethod() SHARED_REQUIRES(Locks::mutator_lock_);
180
181 // Does this method live in a java.lang.LambdaProxy subclass?
182 bool IsLambdaProxyMethod() SHARED_REQUIRES(Locks::mutator_lock_);
183
Andreas Gampecbc96b82015-09-30 20:05:24 +0000184 bool IsPreverified() {
Sebastien Hertz233ea8e2013-06-06 11:57:09 +0200185 return (GetAccessFlags() & kAccPreverified) != 0;
186 }
187
Andreas Gampecbc96b82015-09-30 20:05:24 +0000188 void SetPreverified() {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800189 DCHECK(!IsPreverified());
Sebastien Hertz233ea8e2013-06-06 11:57:09 +0200190 SetAccessFlags(GetAccessFlags() | kAccPreverified);
191 }
192
Alex Lighteb7c1442015-08-31 13:17:42 -0700193 // Returns true if this method could be overridden by a default method.
Alex Light9139e002015-10-09 15:59:48 -0700194 bool IsOverridableByDefaultMethod() SHARED_REQUIRES(Locks::mutator_lock_);
Alex Lighteb7c1442015-08-31 13:17:42 -0700195
Mathieu Chartier90443472015-07-16 20:32:27 -0700196 bool CheckIncompatibleClassChange(InvokeType type) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800197
Alex Light9139e002015-10-09 15:59:48 -0700198 // Throws the error that would result from trying to invoke this method (i.e.
199 // IncompatibleClassChangeError or AbstractMethodError). Only call if !IsInvokable();
200 void ThrowInvocationTimeError() SHARED_REQUIRES(Locks::mutator_lock_);
201
Mathieu Chartier90443472015-07-16 20:32:27 -0700202 uint16_t GetMethodIndex() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800203
Mathieu Chartier9f3629d2014-10-28 18:23:02 -0700204 // Doesn't do erroneous / unresolved class checks.
Mathieu Chartier90443472015-07-16 20:32:27 -0700205 uint16_t GetMethodIndexDuringLinking() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier9f3629d2014-10-28 18:23:02 -0700206
Mathieu Chartier90443472015-07-16 20:32:27 -0700207 size_t GetVtableIndex() SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800208 return GetMethodIndex();
209 }
210
Mathieu Chartier90443472015-07-16 20:32:27 -0700211 void SetMethodIndex(uint16_t new_method_index) SHARED_REQUIRES(Locks::mutator_lock_) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100212 // Not called within a transaction.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700213 method_index_ = new_method_index;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800214 }
215
Vladimir Markoc1363122015-04-09 14:13:13 +0100216 static MemberOffset DexMethodIndexOffset() {
217 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_method_index_);
218 }
219
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800220 static MemberOffset MethodIndexOffset() {
Brian Carlstromea46f952013-07-30 01:26:50 -0700221 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800222 }
223
Mathieu Chartiere401d142015-04-22 13:56:20 -0700224 uint32_t GetCodeItemOffset() {
225 return dex_code_item_offset_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800226 }
227
Mathieu Chartiere401d142015-04-22 13:56:20 -0700228 void SetCodeItemOffset(uint32_t new_code_off) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100229 // Not called within a transaction.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700230 dex_code_item_offset_ = new_code_off;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800231 }
232
233 // Number of 32bit registers that would be required to hold all the arguments
234 static size_t NumArgRegisters(const StringPiece& shorty);
235
Mathieu Chartier90443472015-07-16 20:32:27 -0700236 ALWAYS_INLINE uint32_t GetDexMethodIndex() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800237
Mathieu Chartiere401d142015-04-22 13:56:20 -0700238 void SetDexMethodIndex(uint32_t new_idx) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100239 // Not called within a transaction.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700240 dex_method_index_ = new_idx;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800241 }
242
Vladimir Marko05792b92015-08-03 11:56:49 +0100243 ALWAYS_INLINE ArtMethod** GetDexCacheResolvedMethods(size_t pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700244 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100245 ALWAYS_INLINE ArtMethod* GetDexCacheResolvedMethod(uint16_t method_index, size_t ptr_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700246 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100247 ALWAYS_INLINE void SetDexCacheResolvedMethod(uint16_t method_index,
248 ArtMethod* new_method,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700249 size_t ptr_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700250 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100251 ALWAYS_INLINE void SetDexCacheResolvedMethods(ArtMethod** new_dex_cache_methods, size_t ptr_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700252 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100253 bool HasDexCacheResolvedMethods(size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
254 bool HasSameDexCacheResolvedMethods(ArtMethod* other, size_t pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700255 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100256 bool HasSameDexCacheResolvedMethods(ArtMethod** other_cache, size_t pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700257 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800258
Andreas Gampe58a5af82014-07-31 16:23:49 -0700259 template <bool kWithCheck = true>
Vladimir Marko05792b92015-08-03 11:56:49 +0100260 mirror::Class* GetDexCacheResolvedType(uint32_t type_idx, size_t ptr_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700261 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100262 void SetDexCacheResolvedTypes(GcRoot<mirror::Class>* new_dex_cache_types, size_t ptr_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700263 SHARED_REQUIRES(Locks::mutator_lock_);
Vladimir Marko05792b92015-08-03 11:56:49 +0100264 bool HasDexCacheResolvedTypes(size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
265 bool HasSameDexCacheResolvedTypes(ArtMethod* other, size_t pointer_size)
266 SHARED_REQUIRES(Locks::mutator_lock_);
267 bool HasSameDexCacheResolvedTypes(GcRoot<mirror::Class>* other_cache, size_t pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700268 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800269
Ian Rogersa0485602014-12-02 15:48:04 -0800270 // Get the Class* from the type index into this method's dex cache.
Vladimir Marko05792b92015-08-03 11:56:49 +0100271 mirror::Class* GetClassFromTypeIndex(uint16_t type_idx, bool resolve, size_t ptr_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700272 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersa0485602014-12-02 15:48:04 -0800273
Ian Rogerse0a02da2014-12-02 14:10:53 -0800274 // Find the method that this method overrides.
Mathieu Chartier90443472015-07-16 20:32:27 -0700275 ArtMethod* FindOverriddenMethod(size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800276
Ian Rogerse0a02da2014-12-02 14:10:53 -0800277 // Find the method index for this method within other_dexfile. If this method isn't present then
278 // return DexFile::kDexNoIndex. The name_and_signature_idx MUST refer to a MethodId with the same
279 // name and signature in the other_dexfile, such as the method index used to resolve this method
280 // in the other_dexfile.
281 uint32_t FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile,
282 uint32_t name_and_signature_idx)
Mathieu Chartier90443472015-07-16 20:32:27 -0700283 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogerse0a02da2014-12-02 14:10:53 -0800284
Igor Murashkin457e8742015-10-22 17:37:50 -0700285 // Invoke this method, passing all the virtual registers in args.
286 // -- args_size must be the size in bytes (not size in words)!
287 // -- shorty must be the method shorty (i.e. it includes the return type).
288 // The result is set when the method finishes execution successfully.
289 void Invoke(Thread* self,
290 uint32_t* args,
291 uint32_t args_size, // NOTE: size in bytes
292 /*out*/JValue* result,
293 const char* shorty)
Mathieu Chartier90443472015-07-16 20:32:27 -0700294 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800295
Mathieu Chartiere401d142015-04-22 13:56:20 -0700296 const void* GetEntryPointFromQuickCompiledCode() {
Mathieu Chartier2d721012014-11-10 11:08:06 -0800297 return GetEntryPointFromQuickCompiledCodePtrSize(sizeof(void*));
298 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700299 ALWAYS_INLINE const void* GetEntryPointFromQuickCompiledCodePtrSize(size_t pointer_size) {
Vladimir Marko05792b92015-08-03 11:56:49 +0100300 return GetNativePointer<const void*>(
Mathieu Chartier2d721012014-11-10 11:08:06 -0800301 EntryPointFromQuickCompiledCodeOffset(pointer_size), pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800302 }
303
Mathieu Chartiere401d142015-04-22 13:56:20 -0700304 void SetEntryPointFromQuickCompiledCode(const void* entry_point_from_quick_compiled_code) {
Mathieu Chartier2d721012014-11-10 11:08:06 -0800305 SetEntryPointFromQuickCompiledCodePtrSize(entry_point_from_quick_compiled_code,
306 sizeof(void*));
307 }
Mathieu Chartier2d721012014-11-10 11:08:06 -0800308 ALWAYS_INLINE void SetEntryPointFromQuickCompiledCodePtrSize(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700309 const void* entry_point_from_quick_compiled_code, size_t pointer_size) {
Vladimir Marko05792b92015-08-03 11:56:49 +0100310 SetNativePointer(EntryPointFromQuickCompiledCodeOffset(pointer_size),
311 entry_point_from_quick_compiled_code, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800312 }
313
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700314 void RegisterNative(const void* native_method, bool is_fast)
Mathieu Chartier90443472015-07-16 20:32:27 -0700315 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800316
Mathieu Chartier90443472015-07-16 20:32:27 -0700317 void UnregisterNative() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800318
Vladimir Marko05792b92015-08-03 11:56:49 +0100319 static MemberOffset DexCacheResolvedMethodsOffset(size_t pointer_size) {
320 return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
321 PtrSizedFields, dex_cache_resolved_methods_) / sizeof(void*) * pointer_size);
322 }
323
324 static MemberOffset DexCacheResolvedTypesOffset(size_t pointer_size) {
325 return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
326 PtrSizedFields, dex_cache_resolved_types_) / sizeof(void*) * pointer_size);
327 }
328
Mathieu Chartier2d721012014-11-10 11:08:06 -0800329 static MemberOffset EntryPointFromJniOffset(size_t pointer_size) {
Mathieu Chartiereace4582014-11-24 18:29:54 -0800330 return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
Mathieu Chartier2d721012014-11-10 11:08:06 -0800331 PtrSizedFields, entry_point_from_jni_) / sizeof(void*) * pointer_size);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800332 }
333
Mathieu Chartier2d721012014-11-10 11:08:06 -0800334 static MemberOffset EntryPointFromQuickCompiledCodeOffset(size_t pointer_size) {
Mathieu Chartiereace4582014-11-24 18:29:54 -0800335 return MemberOffset(PtrSizedFieldsOffset(pointer_size) + OFFSETOF_MEMBER(
Mathieu Chartier2d721012014-11-10 11:08:06 -0800336 PtrSizedFields, entry_point_from_quick_compiled_code_) / sizeof(void*) * pointer_size);
337 }
338
Mathieu Chartier1147b9b2015-09-14 18:50:08 -0700339 ProfilingInfo* GetProfilingInfo(size_t pointer_size) {
340 return reinterpret_cast<ProfilingInfo*>(GetEntryPointFromJniPtrSize(pointer_size));
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100341 }
342
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000343 ALWAYS_INLINE void SetProfilingInfo(ProfilingInfo* info) {
344 SetEntryPointFromJniPtrSize(info, sizeof(void*));
345 }
346
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000347 ALWAYS_INLINE void SetProfilingInfoPtrSize(ProfilingInfo* info, size_t pointer_size) {
348 SetEntryPointFromJniPtrSize(info, pointer_size);
349 }
350
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000351 static MemberOffset ProfilingInfoOffset() {
352 return EntryPointFromJniOffset(sizeof(void*));
353 }
354
Mathieu Chartiere401d142015-04-22 13:56:20 -0700355 void* GetEntryPointFromJni() {
Mathieu Chartier2d721012014-11-10 11:08:06 -0800356 return GetEntryPointFromJniPtrSize(sizeof(void*));
357 }
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100358
Mathieu Chartiere401d142015-04-22 13:56:20 -0700359 ALWAYS_INLINE void* GetEntryPointFromJniPtrSize(size_t pointer_size) {
Vladimir Marko05792b92015-08-03 11:56:49 +0100360 return GetNativePointer<void*>(EntryPointFromJniOffset(pointer_size), pointer_size);
Mathieu Chartier2d721012014-11-10 11:08:06 -0800361 }
362
Andreas Gampecbc96b82015-09-30 20:05:24 +0000363 void SetEntryPointFromJni(const void* entrypoint) {
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100364 DCHECK(IsNative());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700365 SetEntryPointFromJniPtrSize(entrypoint, sizeof(void*));
Mathieu Chartier2d721012014-11-10 11:08:06 -0800366 }
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100367
Mathieu Chartiere401d142015-04-22 13:56:20 -0700368 ALWAYS_INLINE void SetEntryPointFromJniPtrSize(const void* entrypoint, size_t pointer_size) {
Vladimir Marko05792b92015-08-03 11:56:49 +0100369 SetNativePointer(EntryPointFromJniOffset(pointer_size), entrypoint, pointer_size);
Mathieu Chartier2d721012014-11-10 11:08:06 -0800370 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800371
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800372 // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
373 // conventions for a method of managed code. Returns false for Proxy methods.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700374 ALWAYS_INLINE bool IsRuntimeMethod();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800375
376 // Is this a hand crafted method used for something like describing callee saves?
Mathieu Chartier90443472015-07-16 20:32:27 -0700377 bool IsCalleeSaveMethod() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800378
Mathieu Chartier90443472015-07-16 20:32:27 -0700379 bool IsResolutionMethod() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800380
Mathieu Chartier90443472015-07-16 20:32:27 -0700381 bool IsImtConflictMethod() SHARED_REQUIRES(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700382
Mathieu Chartier90443472015-07-16 20:32:27 -0700383 bool IsImtUnimplementedMethod() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700384
Mathieu Chartier90443472015-07-16 20:32:27 -0700385 MethodReference ToMethodReference() SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartier36b58f52014-12-10 12:06:45 -0800386 return MethodReference(GetDexFile(), GetDexMethodIndex());
387 }
388
Ian Rogersc449aa82013-07-29 14:35:46 -0700389 // Find the catch block for the given exception type and dex_pc. When a catch block is found,
390 // indicates whether the found catch block is responsible for clearing the exception or whether
391 // a move-exception instruction is present.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700392 uint32_t FindCatchBlock(Handle<mirror::Class> exception_type, uint32_t dex_pc,
393 bool* has_no_move_exception)
Mathieu Chartier90443472015-07-16 20:32:27 -0700394 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800395
Mathieu Chartierda7c6502015-07-23 16:01:26 -0700396 // NO_THREAD_SAFETY_ANALYSIS since we don't know what the callback requires.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700397 template<typename RootVisitorType>
Mathieu Chartier1147b9b2015-09-14 18:50:08 -0700398 void VisitRoots(RootVisitorType& visitor, size_t pointer_size) NO_THREAD_SAFETY_ANALYSIS;
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800399
Mathieu Chartier90443472015-07-16 20:32:27 -0700400 const DexFile* GetDexFile() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700401
Mathieu Chartier90443472015-07-16 20:32:27 -0700402 const char* GetDeclaringClassDescriptor() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700403
Mathieu Chartier90443472015-07-16 20:32:27 -0700404 const char* GetShorty() SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700405 uint32_t unused_length;
406 return GetShorty(&unused_length);
407 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700408
Mathieu Chartier90443472015-07-16 20:32:27 -0700409 const char* GetShorty(uint32_t* out_length) SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700410
Mathieu Chartier90443472015-07-16 20:32:27 -0700411 const Signature GetSignature() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700412
Mathieu Chartier90443472015-07-16 20:32:27 -0700413 ALWAYS_INLINE const char* GetName() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700414
Mathieu Chartier90443472015-07-16 20:32:27 -0700415 mirror::String* GetNameAsString(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers6b14d552014-10-28 21:50:58 -0700416
Mathieu Chartier90443472015-07-16 20:32:27 -0700417 const DexFile::CodeItem* GetCodeItem() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700418
Vladimir Marko05792b92015-08-03 11:56:49 +0100419 bool IsResolvedTypeIdx(uint16_t type_idx, size_t ptr_size) SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700420
Mathieu Chartier90443472015-07-16 20:32:27 -0700421 int32_t GetLineNumFromDexPC(uint32_t dex_pc) SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700422
Mathieu Chartier90443472015-07-16 20:32:27 -0700423 const DexFile::ProtoId& GetPrototype() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700424
Mathieu Chartier90443472015-07-16 20:32:27 -0700425 const DexFile::TypeList* GetParameterTypeList() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700426
Mathieu Chartier90443472015-07-16 20:32:27 -0700427 const char* GetDeclaringClassSourceFile() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700428
Mathieu Chartier90443472015-07-16 20:32:27 -0700429 uint16_t GetClassDefIndex() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700430
Mathieu Chartier90443472015-07-16 20:32:27 -0700431 const DexFile::ClassDef& GetClassDef() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700432
Mathieu Chartier90443472015-07-16 20:32:27 -0700433 const char* GetReturnTypeDescriptor() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700434
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700435 const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx)
Mathieu Chartier90443472015-07-16 20:32:27 -0700436 SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700437
Ian Rogersded66a02014-10-28 18:12:55 -0700438 // May cause thread suspension due to GetClassFromTypeIdx calling ResolveType this caused a large
439 // number of bugs at call sites.
Vladimir Marko05792b92015-08-03 11:56:49 +0100440 mirror::Class* GetReturnType(bool resolve, size_t ptr_size)
441 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersded66a02014-10-28 18:12:55 -0700442
Mathieu Chartier90443472015-07-16 20:32:27 -0700443 mirror::ClassLoader* GetClassLoader() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700444
Mathieu Chartier90443472015-07-16 20:32:27 -0700445 mirror::DexCache* GetDexCache() SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700446
Igor Murashkin457e8742015-10-22 17:37:50 -0700447 // Returns the current method ('this') if this is a regular, non-proxy method.
448 // Otherwise, when this class is a proxy (IsProxyMethod), look-up the original interface's
449 // method (that the proxy is "overriding") and return that.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700450 ALWAYS_INLINE ArtMethod* GetInterfaceMethodIfProxy(size_t pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700451 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700452
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700453 // May cause thread suspension due to class resolution.
454 bool EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params)
Mathieu Chartier90443472015-07-16 20:32:27 -0700455 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700456
Vladimir Marko14632852015-08-17 12:07:23 +0100457 // Size of an instance of this native class.
458 static size_t Size(size_t pointer_size) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700459 return RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size) +
Mathieu Chartiereace4582014-11-24 18:29:54 -0800460 (sizeof(PtrSizedFields) / sizeof(void*)) * pointer_size;
Mathieu Chartier2d721012014-11-10 11:08:06 -0800461 }
462
Vladimir Marko14632852015-08-17 12:07:23 +0100463 // Alignment of an instance of this native class.
464 static size_t Alignment(size_t pointer_size) {
Vladimir Markocf36d492015-08-12 19:27:26 +0100465 // The ArtMethod alignment is the same as image pointer size. This differs from
Vladimir Marko14632852015-08-17 12:07:23 +0100466 // alignof(ArtMethod) if cross-compiling with pointer_size != sizeof(void*).
Vladimir Markocf36d492015-08-12 19:27:26 +0100467 return pointer_size;
468 }
469
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000470 void CopyFrom(ArtMethod* src, size_t image_pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700471 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700472
Vladimir Marko05792b92015-08-03 11:56:49 +0100473 ALWAYS_INLINE GcRoot<mirror::Class>* GetDexCacheResolvedTypes(size_t pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700474 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700475
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100476 uint16_t IncrementCounter() {
477 return ++hotness_count_;
478 }
479
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100480 void ClearCounter() {
481 hotness_count_ = 0;
482 }
483
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100484 const uint8_t* GetQuickenedInfo() SHARED_REQUIRES(Locks::mutator_lock_);
485
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100486 // Returns the method header for the compiled code containing 'pc'. Note that runtime
487 // methods will return null for this method, as they are not oat based.
488 const OatQuickMethodHeader* GetOatQuickMethodHeader(uintptr_t pc)
489 SHARED_REQUIRES(Locks::mutator_lock_);
490
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000491 // Returns whether the method has any compiled code, JIT or AOT.
492 bool HasAnyCompiledCode() SHARED_REQUIRES(Locks::mutator_lock_);
493
Mathieu Chartier2d721012014-11-10 11:08:06 -0800494 protected:
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800495 // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
Ian Rogersef7d42f2014-01-06 12:55:46 -0800496 // The class we are a part of.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700497 GcRoot<mirror::Class> declaring_class_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800498
Ian Rogersef7d42f2014-01-06 12:55:46 -0800499 // Access flags; low 16 bits are defined by spec.
500 uint32_t access_flags_;
501
502 /* Dex file fields. The defining dex file is available via declaring_class_->dex_cache_ */
503
504 // Offset to the CodeItem.
505 uint32_t dex_code_item_offset_;
506
507 // Index into method_ids of the dex file associated with this method.
508 uint32_t dex_method_index_;
509
510 /* End of dex file fields. */
511
512 // Entry within a dispatch table for this method. For static/direct methods the index is into
513 // the declaringClass.directMethods, for virtual methods the vtable and for interface methods the
514 // ifTable.
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100515 uint16_t method_index_;
516
517 // The hotness we measure for this method. Incremented by the interpreter. Not atomic, as we allow
518 // missing increments: if the method is hot, we will see it eventually.
519 uint16_t hotness_count_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800520
Mathieu Chartiereace4582014-11-24 18:29:54 -0800521 // Fake padding field gets inserted here.
Mathieu Chartier2d721012014-11-10 11:08:06 -0800522
523 // Must be the last fields in the method.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700524 // PACKED(4) is necessary for the correctness of
525 // RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size).
Mathieu Chartier2d721012014-11-10 11:08:06 -0800526 struct PACKED(4) PtrSizedFields {
Vladimir Marko05792b92015-08-03 11:56:49 +0100527 // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
528 ArtMethod** dex_cache_resolved_methods_;
529
530 // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
531 GcRoot<mirror::Class>* dex_cache_resolved_types_;
532
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100533 // Pointer to JNI function registered to this method, or a function to resolve the JNI function,
534 // or the profiling data for non-native methods.
Mathieu Chartier2d721012014-11-10 11:08:06 -0800535 void* entry_point_from_jni_;
536
537 // Method dispatch from quick compiled code invokes this pointer which may cause bridging into
Elliott Hughes956af0f2014-12-11 14:34:28 -0800538 // the interpreter.
Mathieu Chartier2d721012014-11-10 11:08:06 -0800539 void* entry_point_from_quick_compiled_code_;
Mathieu Chartier2d721012014-11-10 11:08:06 -0800540 } ptr_sized_fields_;
541
Mathieu Chartier02e25112013-08-14 16:14:24 -0700542 private:
Mathieu Chartiereace4582014-11-24 18:29:54 -0800543 static size_t PtrSizedFieldsOffset(size_t pointer_size) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700544 // Round up to pointer size for padding field.
545 return RoundUp(OFFSETOF_MEMBER(ArtMethod, ptr_sized_fields_), pointer_size);
546 }
547
548 template<typename T>
Vladimir Marko05792b92015-08-03 11:56:49 +0100549 ALWAYS_INLINE T GetNativePointer(MemberOffset offset, size_t pointer_size) const {
550 static_assert(std::is_pointer<T>::value, "T must be a pointer type");
Mathieu Chartiere401d142015-04-22 13:56:20 -0700551 DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
552 const auto addr = reinterpret_cast<uintptr_t>(this) + offset.Uint32Value();
553 if (pointer_size == sizeof(uint32_t)) {
554 return reinterpret_cast<T>(*reinterpret_cast<const uint32_t*>(addr));
555 } else {
556 auto v = *reinterpret_cast<const uint64_t*>(addr);
Vladimir Marko05792b92015-08-03 11:56:49 +0100557 return reinterpret_cast<T>(dchecked_integral_cast<uintptr_t>(v));
Mathieu Chartiere401d142015-04-22 13:56:20 -0700558 }
559 }
560
561 template<typename T>
Vladimir Marko05792b92015-08-03 11:56:49 +0100562 ALWAYS_INLINE void SetNativePointer(MemberOffset offset, T new_value, size_t pointer_size) {
563 static_assert(std::is_pointer<T>::value, "T must be a pointer type");
Mathieu Chartiere401d142015-04-22 13:56:20 -0700564 DCHECK(ValidPointerSize(pointer_size)) << pointer_size;
565 const auto addr = reinterpret_cast<uintptr_t>(this) + offset.Uint32Value();
566 if (pointer_size == sizeof(uint32_t)) {
567 uintptr_t ptr = reinterpret_cast<uintptr_t>(new_value);
Vladimir Marko05792b92015-08-03 11:56:49 +0100568 *reinterpret_cast<uint32_t*>(addr) = dchecked_integral_cast<uint32_t>(ptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700569 } else {
570 *reinterpret_cast<uint64_t*>(addr) = reinterpret_cast<uintptr_t>(new_value);
571 }
Mathieu Chartier2d721012014-11-10 11:08:06 -0800572 }
573
Mathieu Chartiere401d142015-04-22 13:56:20 -0700574 DISALLOW_COPY_AND_ASSIGN(ArtMethod); // Need to use CopyFrom to deal with 32 vs 64 bits.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800575};
576
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800577} // namespace art
578
Mathieu Chartiere401d142015-04-22 13:56:20 -0700579#endif // ART_RUNTIME_ART_METHOD_H_