blob: ca361f83c96b3fac45037fba6ae1adcb0f011903 [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
Brian Carlstromea46f952013-07-30 01:26:50 -070017#ifndef ART_RUNTIME_MIRROR_ART_METHOD_INL_H_
18#define ART_RUNTIME_MIRROR_ART_METHOD_INL_H_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080019
Brian Carlstromea46f952013-07-30 01:26:50 -070020#include "art_method.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080021
Andreas Gampe58a5af82014-07-31 16:23:49 -070022#include "art_field.h"
23#include "class.h"
Ian Rogers22d5e732014-07-15 22:23:51 -070024#include "class_linker.h"
25#include "dex_cache.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026#include "dex_file.h"
Ian Rogers22d5e732014-07-15 22:23:51 -070027#include "method_helper.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070028#include "object-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070029#include "object_array.h"
Vladimir Marko96c6ab92014-04-08 14:00:50 +010030#include "oat.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010031#include "quick/quick_method_frame_info.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070032#include "read_barrier-inl.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010033#include "runtime-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034
35namespace art {
36namespace mirror {
37
Mingyao Yang98d1cc82014-05-15 17:02:16 -070038inline uint32_t ArtMethod::ClassSize() {
39 uint32_t vtable_entries = Object::kVTableLength + 8;
Fred Shih37f05ef2014-07-16 18:38:08 -070040 return Class::ComputeClassSize(true, vtable_entries, 0, 0, 0, 0, 0);
Mingyao Yang98d1cc82014-05-15 17:02:16 -070041}
42
43template<ReadBarrierOption kReadBarrierOption>
44inline Class* ArtMethod::GetJavaLangReflectArtMethod() {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070045 DCHECK(!java_lang_reflect_ArtMethod_.IsNull());
46 return java_lang_reflect_ArtMethod_.Read<kReadBarrierOption>();
Mingyao Yang98d1cc82014-05-15 17:02:16 -070047}
48
Ian Rogersef7d42f2014-01-06 12:55:46 -080049inline Class* ArtMethod::GetDeclaringClass() {
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070050 Class* result = GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, declaring_class_));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080051 DCHECK(result != NULL) << this;
52 DCHECK(result->IsIdxLoaded() || result->IsErroneous()) << this;
53 return result;
54}
55
Brian Carlstromea46f952013-07-30 01:26:50 -070056inline void ArtMethod::SetDeclaringClass(Class *new_declaring_class) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010057 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, declaring_class_),
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070058 new_declaring_class);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080059}
60
Ian Rogersef7d42f2014-01-06 12:55:46 -080061inline uint32_t ArtMethod::GetAccessFlags() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080062 DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070063 return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, access_flags_));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080064}
65
Ian Rogersef7d42f2014-01-06 12:55:46 -080066inline uint16_t ArtMethod::GetMethodIndex() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080067 DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070068 return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080069}
70
Ian Rogersef7d42f2014-01-06 12:55:46 -080071inline uint32_t ArtMethod::GetDexMethodIndex() {
Dragos Sbirlea90af14d2013-08-15 17:50:16 -070072#ifdef ART_SEA_IR_MODE
73 // TODO: Re-add this check for (PORTABLE + SMALL + ) SEA IR when PORTABLE IS fixed!
74 // DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
75#else
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080076 DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
Dragos Sbirlea90af14d2013-08-15 17:50:16 -070077#endif
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070078 return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_method_index_));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080079}
80
Ian Rogersef7d42f2014-01-06 12:55:46 -080081inline ObjectArray<String>* ArtMethod::GetDexCacheStrings() {
Ian Rogers700a4022014-05-19 16:49:03 -070082 return GetFieldObject<ObjectArray<String>>(
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070083 OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_));
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070084}
85
Ian Rogersef7d42f2014-01-06 12:55:46 -080086inline ObjectArray<ArtMethod>* ArtMethod::GetDexCacheResolvedMethods() {
Ian Rogers700a4022014-05-19 16:49:03 -070087 return GetFieldObject<ObjectArray<ArtMethod>>(
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070088 OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_));
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070089}
90
Andreas Gampe58a5af82014-07-31 16:23:49 -070091inline ArtMethod* ArtMethod::GetDexCacheResolvedMethod(uint16_t method_index) {
92 ArtMethod* method = GetDexCacheResolvedMethods()->Get(method_index);
93 if (method != nullptr && !method->GetDeclaringClass()->IsErroneous()) {
94 return method;
95 } else {
96 return nullptr;
97 }
98}
99
100inline void ArtMethod::SetDexCacheResolvedMethod(uint16_t method_idx, ArtMethod* new_method) {
101 GetDexCacheResolvedMethods()->Set<false>(method_idx, new_method);
102}
103
104inline bool ArtMethod::HasDexCacheResolvedMethods() {
105 return GetDexCacheResolvedMethods() != nullptr;
106}
107
108inline bool ArtMethod::HasSameDexCacheResolvedMethods(ObjectArray<ArtMethod>* other_cache) {
109 return GetDexCacheResolvedMethods() == other_cache;
110}
111
112inline bool ArtMethod::HasSameDexCacheResolvedMethods(ArtMethod* other) {
113 return GetDexCacheResolvedMethods() == other->GetDexCacheResolvedMethods();
114}
115
116
Ian Rogersef7d42f2014-01-06 12:55:46 -0800117inline ObjectArray<Class>* ArtMethod::GetDexCacheResolvedTypes() {
Ian Rogers700a4022014-05-19 16:49:03 -0700118 return GetFieldObject<ObjectArray<Class>>(
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700119 OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_));
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700120}
121
Andreas Gampe58a5af82014-07-31 16:23:49 -0700122template <bool kWithCheck>
123inline Class* ArtMethod::GetDexCacheResolvedType(uint32_t type_index) {
124 Class* klass;
125 if (kWithCheck) {
126 klass = GetDexCacheResolvedTypes()->Get(type_index);
127 } else {
128 klass = GetDexCacheResolvedTypes()->GetWithoutChecks(type_index);
129 }
130 return (klass != nullptr && !klass->IsErroneous()) ? klass : nullptr;
131}
132
133inline bool ArtMethod::HasDexCacheResolvedTypes() {
134 return GetDexCacheResolvedTypes() != nullptr;
135}
136
137inline bool ArtMethod::HasSameDexCacheResolvedTypes(ObjectArray<Class>* other_cache) {
138 return GetDexCacheResolvedTypes() == other_cache;
139}
140
141inline bool ArtMethod::HasSameDexCacheResolvedTypes(ArtMethod* other) {
142 return GetDexCacheResolvedTypes() == other->GetDexCacheResolvedTypes();
143}
144
Ian Rogersef7d42f2014-01-06 12:55:46 -0800145inline uint32_t ArtMethod::GetCodeSize() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800146 DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
Vladimir Marko8a630572014-04-09 18:45:35 +0100147 const void* code = EntryPointToCodePointer(GetEntryPointFromQuickCompiledCode());
148 if (code == nullptr) {
149 return 0u;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800150 }
Vladimir Marko7624d252014-05-02 14:40:15 +0100151 return reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].code_size_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800152}
153
Brian Carlstromea46f952013-07-30 01:26:50 -0700154inline bool ArtMethod::CheckIncompatibleClassChange(InvokeType type) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800155 switch (type) {
156 case kStatic:
157 return !IsStatic();
158 case kDirect:
159 return !IsDirect() || IsStatic();
160 case kVirtual: {
161 Class* methods_class = GetDeclaringClass();
162 return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
163 }
164 case kSuper:
Andreas Gampe8f252e62014-08-25 20:46:31 -0700165 // Constructors and static methods are called with invoke-direct.
166 // Interface methods cannot be invoked with invoke-super.
167 return IsConstructor() || IsStatic() || GetDeclaringClass()->IsInterface();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800168 case kInterface: {
169 Class* methods_class = GetDeclaringClass();
170 return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
171 }
172 default:
173 LOG(FATAL) << "Unreachable - invocation type: " << type;
Ian Rogers2c4257b2014-10-24 14:20:06 -0700174 UNREACHABLE();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800175 }
176}
177
Ian Rogersef7d42f2014-01-06 12:55:46 -0800178inline uint32_t ArtMethod::GetQuickOatCodeOffset() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800179 DCHECK(!Runtime::Current()->IsStarted());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800180 return PointerToLowMemUInt32(GetEntryPointFromQuickCompiledCode());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800181}
182
Ian Rogersef7d42f2014-01-06 12:55:46 -0800183inline uint32_t ArtMethod::GetPortableOatCodeOffset() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800184 DCHECK(!Runtime::Current()->IsStarted());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800185 return PointerToLowMemUInt32(GetEntryPointFromPortableCompiledCode());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800186}
187
Ian Rogersef7d42f2014-01-06 12:55:46 -0800188inline void ArtMethod::SetQuickOatCodeOffset(uint32_t code_offset) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800189 DCHECK(!Runtime::Current()->IsStarted());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800190 SetEntryPointFromQuickCompiledCode(reinterpret_cast<void*>(code_offset));
191}
192
193inline void ArtMethod::SetPortableOatCodeOffset(uint32_t code_offset) {
194 DCHECK(!Runtime::Current()->IsStarted());
195 SetEntryPointFromPortableCompiledCode(reinterpret_cast<void*>(code_offset));
196}
197
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100198inline const uint8_t* ArtMethod::GetMappingTable() {
199 const void* code_pointer = GetQuickOatCodePointer();
200 if (code_pointer == nullptr) {
201 return nullptr;
202 }
203 return GetMappingTable(code_pointer);
204}
205
206inline const uint8_t* ArtMethod::GetMappingTable(const void* code_pointer) {
207 DCHECK(code_pointer != nullptr);
208 DCHECK(code_pointer == GetQuickOatCodePointer());
209 uint32_t offset =
210 reinterpret_cast<const OatQuickMethodHeader*>(code_pointer)[-1].mapping_table_offset_;
211 if (UNLIKELY(offset == 0u)) {
212 return nullptr;
213 }
214 return reinterpret_cast<const uint8_t*>(code_pointer) - offset;
215}
216
217inline const uint8_t* ArtMethod::GetVmapTable() {
218 const void* code_pointer = GetQuickOatCodePointer();
219 if (code_pointer == nullptr) {
220 return nullptr;
221 }
222 return GetVmapTable(code_pointer);
223}
224
225inline const uint8_t* ArtMethod::GetVmapTable(const void* code_pointer) {
Ian Rogers2c4257b2014-10-24 14:20:06 -0700226 CHECK(!IsOptimized()) << "Unimplemented vmap table for optimized compiler";
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100227 DCHECK(code_pointer != nullptr);
228 DCHECK(code_pointer == GetQuickOatCodePointer());
229 uint32_t offset =
230 reinterpret_cast<const OatQuickMethodHeader*>(code_pointer)[-1].vmap_table_offset_;
231 if (UNLIKELY(offset == 0u)) {
232 return nullptr;
233 }
234 return reinterpret_cast<const uint8_t*>(code_pointer) - offset;
235}
236
Nicolas Geoffray39468442014-09-02 15:17:15 +0100237inline StackMap ArtMethod::GetStackMap(uint32_t native_pc_offset) {
Nicolas Geoffraye982f0b2014-08-13 02:11:24 +0100238 return GetOptimizedCodeInfo().GetStackMapForNativePcOffset(native_pc_offset);
239}
240
241inline CodeInfo ArtMethod::GetOptimizedCodeInfo() {
Nicolas Geoffray39468442014-09-02 15:17:15 +0100242 DCHECK(IsOptimized());
243 const void* code_pointer = GetQuickOatCodePointer();
244 DCHECK(code_pointer != nullptr);
245 uint32_t offset =
246 reinterpret_cast<const OatQuickMethodHeader*>(code_pointer)[-1].vmap_table_offset_;
247 const void* data = reinterpret_cast<const void*>(reinterpret_cast<const uint8_t*>(code_pointer) - offset);
Nicolas Geoffraye982f0b2014-08-13 02:11:24 +0100248 return CodeInfo(data);
Nicolas Geoffray39468442014-09-02 15:17:15 +0100249}
250
Brian Carlstromea46f952013-07-30 01:26:50 -0700251inline void ArtMethod::SetOatNativeGcMapOffset(uint32_t gc_map_offset) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800252 DCHECK(!Runtime::Current()->IsStarted());
253 SetNativeGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
254}
255
Ian Rogersef7d42f2014-01-06 12:55:46 -0800256inline uint32_t ArtMethod::GetOatNativeGcMapOffset() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800257 DCHECK(!Runtime::Current()->IsStarted());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800258 return PointerToLowMemUInt32(GetNativeGcMap());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800259}
260
Ian Rogersef7d42f2014-01-06 12:55:46 -0800261inline bool ArtMethod::IsRuntimeMethod() {
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700262 return GetDexMethodIndex() == DexFile::kDexNoIndex;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800263}
264
Ian Rogersef7d42f2014-01-06 12:55:46 -0800265inline bool ArtMethod::IsCalleeSaveMethod() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800266 if (!IsRuntimeMethod()) {
267 return false;
268 }
269 Runtime* runtime = Runtime::Current();
270 bool result = false;
271 for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
272 if (this == runtime->GetCalleeSaveMethod(Runtime::CalleeSaveType(i))) {
273 result = true;
274 break;
275 }
276 }
277 return result;
278}
279
Ian Rogersef7d42f2014-01-06 12:55:46 -0800280inline bool ArtMethod::IsResolutionMethod() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800281 bool result = this == Runtime::Current()->GetResolutionMethod();
282 // Check that if we do think it is phony it looks like the resolution method.
283 DCHECK(!result || IsRuntimeMethod());
284 return result;
285}
Jeff Hao88474b42013-10-23 16:24:40 -0700286
Ian Rogersef7d42f2014-01-06 12:55:46 -0800287inline bool ArtMethod::IsImtConflictMethod() {
Jeff Hao88474b42013-10-23 16:24:40 -0700288 bool result = this == Runtime::Current()->GetImtConflictMethod();
289 // Check that if we do think it is phony it looks like the imt conflict method.
290 DCHECK(!result || IsRuntimeMethod());
291 return result;
292}
Mathieu Chartier4e305412014-02-19 10:54:44 -0800293
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700294inline bool ArtMethod::IsImtUnimplementedMethod() {
295 bool result = this == Runtime::Current()->GetImtUnimplementedMethod();
296 // Check that if we do think it is phony it looks like the imt unimplemented method.
297 DCHECK(!result || IsRuntimeMethod());
298 return result;
299}
300
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700301inline uintptr_t ArtMethod::NativeQuickPcOffset(const uintptr_t pc) {
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100302 const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
303 return pc - reinterpret_cast<uintptr_t>(code);
304}
305
Mathieu Chartier4e305412014-02-19 10:54:44 -0800306template<VerifyObjectFlags kVerifyFlags>
307inline void ArtMethod::SetNativeMethod(const void* native_method) {
308 SetFieldPtr<false, true, kVerifyFlags>(
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700309 OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_jni_), native_method);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800310}
311
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100312inline QuickMethodFrameInfo ArtMethod::GetQuickFrameInfo(const void* code_pointer) {
313 DCHECK(code_pointer != nullptr);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700314 DCHECK_EQ(code_pointer, GetQuickOatCodePointer());
Vladimir Marko7624d252014-05-02 14:40:15 +0100315 return reinterpret_cast<const OatQuickMethodHeader*>(code_pointer)[-1].frame_info_;
316}
317
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700318inline const DexFile* ArtMethod::GetDexFile() {
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700319 return GetDexCache()->GetDexFile();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700320}
321
322inline const char* ArtMethod::GetDeclaringClassDescriptor() {
323 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
324 uint32_t dex_method_idx = method->GetDexMethodIndex();
325 if (UNLIKELY(dex_method_idx == DexFile::kDexNoIndex)) {
326 return "<runtime method>";
327 }
328 const DexFile* dex_file = method->GetDexFile();
329 return dex_file->GetMethodDeclaringClassDescriptor(dex_file->GetMethodId(dex_method_idx));
330}
331
332inline const char* ArtMethod::GetShorty(uint32_t* out_length) {
333 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
334 const DexFile* dex_file = method->GetDexFile();
335 return dex_file->GetMethodShorty(dex_file->GetMethodId(method->GetDexMethodIndex()), out_length);
336}
337
338inline const Signature ArtMethod::GetSignature() {
339 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
340 uint32_t dex_method_idx = method->GetDexMethodIndex();
341 if (dex_method_idx != DexFile::kDexNoIndex) {
342 const DexFile* dex_file = method->GetDexFile();
343 return dex_file->GetMethodSignature(dex_file->GetMethodId(dex_method_idx));
344 }
345 return Signature::NoSignature();
346}
347
Ian Rogers1ff3c982014-08-12 02:30:58 -0700348inline const char* ArtMethod::GetName() {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700349 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
350 uint32_t dex_method_idx = method->GetDexMethodIndex();
351 if (LIKELY(dex_method_idx != DexFile::kDexNoIndex)) {
352 const DexFile* dex_file = method->GetDexFile();
353 return dex_file->GetMethodName(dex_file->GetMethodId(dex_method_idx));
354 }
355 Runtime* runtime = Runtime::Current();
356 if (method == runtime->GetResolutionMethod()) {
357 return "<runtime internal resolution method>";
358 } else if (method == runtime->GetImtConflictMethod()) {
359 return "<runtime internal imt conflict method>";
360 } else if (method == runtime->GetCalleeSaveMethod(Runtime::kSaveAll)) {
361 return "<runtime internal callee-save all registers method>";
362 } else if (method == runtime->GetCalleeSaveMethod(Runtime::kRefsOnly)) {
363 return "<runtime internal callee-save reference registers method>";
364 } else if (method == runtime->GetCalleeSaveMethod(Runtime::kRefsAndArgs)) {
365 return "<runtime internal callee-save reference and argument registers method>";
366 } else {
367 return "<unknown runtime internal method>";
368 }
369}
370
371inline const DexFile::CodeItem* ArtMethod::GetCodeItem() {
372 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
373 return method->GetDexFile()->GetCodeItem(method->GetCodeItemOffset());
374}
375
376inline bool ArtMethod::IsResolvedTypeIdx(uint16_t type_idx) {
377 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
Andreas Gampe58a5af82014-07-31 16:23:49 -0700378 return method->GetDexCacheResolvedType(type_idx) != nullptr;
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700379}
380
381inline int32_t ArtMethod::GetLineNumFromDexPC(uint32_t dex_pc) {
382 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
383 if (dex_pc == DexFile::kDexNoIndex) {
384 return method->IsNative() ? -2 : -1;
385 }
386 return method->GetDexFile()->GetLineNumFromPC(method, dex_pc);
387}
388
389inline const DexFile::ProtoId& ArtMethod::GetPrototype() {
390 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
391 const DexFile* dex_file = method->GetDexFile();
392 return dex_file->GetMethodPrototype(dex_file->GetMethodId(method->GetDexMethodIndex()));
393}
394
395inline const DexFile::TypeList* ArtMethod::GetParameterTypeList() {
396 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
397 const DexFile* dex_file = method->GetDexFile();
398 const DexFile::ProtoId& proto = dex_file->GetMethodPrototype(
399 dex_file->GetMethodId(method->GetDexMethodIndex()));
400 return dex_file->GetProtoParameters(proto);
401}
402
403inline const char* ArtMethod::GetDeclaringClassSourceFile() {
404 return GetInterfaceMethodIfProxy()->GetDeclaringClass()->GetSourceFile();
405}
406
407inline uint16_t ArtMethod::GetClassDefIndex() {
408 return GetInterfaceMethodIfProxy()->GetDeclaringClass()->GetDexClassDefIndex();
409}
410
411inline const DexFile::ClassDef& ArtMethod::GetClassDef() {
412 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
413 return method->GetDexFile()->GetClassDef(GetClassDefIndex());
414}
415
416inline const char* ArtMethod::GetReturnTypeDescriptor() {
417 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
418 const DexFile* dex_file = method->GetDexFile();
419 const DexFile::MethodId& method_id = dex_file->GetMethodId(method->GetDexMethodIndex());
420 const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
421 uint16_t return_type_idx = proto_id.return_type_idx_;
422 return dex_file->GetTypeDescriptor(dex_file->GetTypeId(return_type_idx));
423}
424
425inline const char* ArtMethod::GetTypeDescriptorFromTypeIdx(uint16_t type_idx) {
426 mirror::ArtMethod* method = GetInterfaceMethodIfProxy();
427 const DexFile* dex_file = method->GetDexFile();
428 return dex_file->GetTypeDescriptor(dex_file->GetTypeId(type_idx));
429}
430
431inline mirror::ClassLoader* ArtMethod::GetClassLoader() {
432 return GetInterfaceMethodIfProxy()->GetDeclaringClass()->GetClassLoader();
433}
434
435inline mirror::DexCache* ArtMethod::GetDexCache() {
436 return GetInterfaceMethodIfProxy()->GetDeclaringClass()->GetDexCache();
437}
438
Ian Rogers03b6eaf2014-10-28 09:34:57 -0700439inline bool ArtMethod::IsProxyMethod() {
440 return GetDeclaringClass()->IsProxyClass();
441}
442
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700443inline ArtMethod* ArtMethod::GetInterfaceMethodIfProxy() {
Ian Rogers03b6eaf2014-10-28 09:34:57 -0700444 if (LIKELY(!IsProxyMethod())) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700445 return this;
446 }
Ian Rogers03b6eaf2014-10-28 09:34:57 -0700447 mirror::Class* klass = GetDeclaringClass();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700448 mirror::ArtMethod* interface_method = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
449 DCHECK(interface_method != nullptr);
450 DCHECK_EQ(interface_method,
451 Runtime::Current()->GetClassLinker()->FindMethodForProxy(klass, this));
452 return interface_method;
453}
454
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700455inline void ArtMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
456 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_),
457 new_dex_cache_strings);
458}
459
460inline void ArtMethod::SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods) {
461 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_),
462 new_dex_cache_methods);
463}
464
465inline void ArtMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
466 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_),
467 new_dex_cache_classes);
468}
469
Ian Rogersded66a02014-10-28 18:12:55 -0700470inline mirror::Class* ArtMethod::GetReturnType(bool resolve) {
471 DCHECK(!IsProxyMethod());
472 const DexFile* dex_file = GetDexFile();
473 const DexFile::MethodId& method_id = dex_file->GetMethodId(GetDexMethodIndex());
474 const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
475 uint16_t return_type_idx = proto_id.return_type_idx_;
476 mirror::Class* type = GetDexCacheResolvedType(return_type_idx);
477 if (type == nullptr && resolve) {
478 type = Runtime::Current()->GetClassLinker()->ResolveType(return_type_idx, this);
479 CHECK(type != nullptr || Thread::Current()->IsExceptionPending());
480 }
481 return type;
482}
483
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800484} // namespace mirror
485} // namespace art
486
Brian Carlstromea46f952013-07-30 01:26:50 -0700487#endif // ART_RUNTIME_MIRROR_ART_METHOD_INL_H_