blob: bbc60072b6e2c31813833c2d64ee5c58ca0f9ef9 [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#include "art_method.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080018
Andreas Gampe479b1de2016-07-19 18:27:17 -070019#include <cstddef>
20
Andreas Gampe46ee31b2016-12-14 10:11:49 -080021#include "android-base/stringprintf.h"
22
Ian Rogerse63db272014-07-15 15:36:11 -070023#include "arch/context.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070024#include "art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080025#include "base/stringpiece.h"
Hiroshi Yamauchi00370822015-08-18 14:47:25 -070026#include "class_linker-inl.h"
Andreas Gampe2a5c4682015-08-14 08:22:54 -070027#include "debugger.h"
David Sehrb2ec9f52018-02-21 13:20:31 -080028#include "dex/descriptors_names.h"
David Sehr9e734c72018-01-04 17:56:19 -080029#include "dex/dex_file-inl.h"
30#include "dex/dex_file_exception_helpers.h"
31#include "dex/dex_instruction.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070032#include "entrypoints/runtime_asm_entrypoints.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070033#include "gc/accounting/card_table-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034#include "interpreter/interpreter.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080035#include "jit/jit.h"
36#include "jit/jit_code_cache.h"
Nicolas Geoffray5550ca82015-08-21 18:38:30 +010037#include "jit/profiling_info.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038#include "jni_internal.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070039#include "mirror/class-inl.h"
Alex Lighta01de592016-11-15 10:43:06 -080040#include "mirror/class_ext.h"
Neil Fuller0e844392016-09-08 13:43:31 +010041#include "mirror/executable.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070042#include "mirror/object-inl.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070043#include "mirror/object_array-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070044#include "mirror/string.h"
Nicolas Geoffray9523a3e2015-07-17 11:51:28 +000045#include "oat_file-inl.h"
Alex Lightd78ddec2017-04-18 15:20:38 -070046#include "runtime_callbacks.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070047#include "scoped_thread_state_change-inl.h"
Nicolas Geoffrayb02ba932017-07-13 15:53:54 +010048#include "vdex_file.h"
Ian Rogers62f05122014-03-21 11:21:29 -070049#include "well_known_classes.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080050
51namespace art {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080052
Andreas Gampe46ee31b2016-12-14 10:11:49 -080053using android::base::StringPrintf;
54
Ian Rogers0177e532014-02-11 16:30:46 -080055extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
56 const char*);
Ian Rogers936b37f2014-02-14 00:52:24 -080057extern "C" void art_quick_invoke_static_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
58 const char*);
Jeff Hao5d917302013-02-27 17:57:33 -080059
Andreas Gampeaea05c12017-05-19 08:45:02 -070060DEFINE_RUNTIME_DEBUG_FLAG(ArtMethod, kCheckDeclaringClassState);
61
Andreas Gampec6ea7d02017-02-01 16:46:28 -080062// Enforce that we he have the right index for runtime methods.
Andreas Gampee2abbc62017-09-15 11:59:26 -070063static_assert(ArtMethod::kRuntimeMethodDexMethodIndex == dex::kDexNoIndex,
Andreas Gampec6ea7d02017-02-01 16:46:28 -080064 "Wrong runtime-method dex method index");
65
Alex Light97e78032017-06-27 17:51:55 -070066ArtMethod* ArtMethod::GetCanonicalMethod(PointerSize pointer_size) {
67 if (LIKELY(!IsDefault())) {
68 return this;
69 } else {
70 mirror::Class* declaring_class = GetDeclaringClass();
Vladimir Markoba118822017-06-12 15:41:56 +010071 DCHECK(declaring_class->IsInterface());
72 ArtMethod* ret = declaring_class->FindInterfaceMethod(declaring_class->GetDexCache(),
73 GetDexMethodIndex(),
74 pointer_size);
Alex Light97e78032017-06-27 17:51:55 -070075 DCHECK(ret != nullptr);
76 return ret;
77 }
78}
79
Alex Light4ba388a2017-01-27 10:26:49 -080080ArtMethod* ArtMethod::GetNonObsoleteMethod() {
81 DCHECK_EQ(kRuntimePointerSize, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
82 if (LIKELY(!IsObsolete())) {
83 return this;
84 } else if (IsDirect()) {
85 return &GetDeclaringClass()->GetDirectMethodsSlice(kRuntimePointerSize)[GetMethodIndex()];
86 } else {
87 return GetDeclaringClass()->GetVTableEntry(GetMethodIndex(), kRuntimePointerSize);
88 }
89}
90
Mingyao Yange8fcd012017-01-20 10:43:30 -080091ArtMethod* ArtMethod::GetSingleImplementation(PointerSize pointer_size) {
Mingyao Yang063fc772016-08-02 11:02:54 -070092 if (!IsAbstract()) {
93 // A non-abstract's single implementation is itself.
94 return this;
95 }
Mingyao Yange8fcd012017-01-20 10:43:30 -080096 return reinterpret_cast<ArtMethod*>(GetDataPtrSize(pointer_size));
Mingyao Yang063fc772016-08-02 11:02:54 -070097}
98
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070099ArtMethod* ArtMethod::FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa,
100 jobject jlr_method) {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700101 ObjPtr<mirror::Executable> executable = soa.Decode<mirror::Executable>(jlr_method);
Neil Fuller0e844392016-09-08 13:43:31 +0100102 DCHECK(executable != nullptr);
103 return executable->GetArtMethod();
Ian Rogers62f05122014-03-21 11:21:29 -0700104}
105
Alex Lighta01de592016-11-15 10:43:06 -0800106mirror::DexCache* ArtMethod::GetObsoleteDexCache() {
107 DCHECK(!Runtime::Current()->IsAotCompiler()) << PrettyMethod();
108 DCHECK(IsObsolete());
109 ObjPtr<mirror::ClassExt> ext(GetDeclaringClass()->GetExtData());
110 CHECK(!ext.IsNull());
111 ObjPtr<mirror::PointerArray> obsolete_methods(ext->GetObsoleteMethods());
112 CHECK(!obsolete_methods.IsNull());
113 DCHECK(ext->GetObsoleteDexCaches() != nullptr);
114 int32_t len = obsolete_methods->GetLength();
115 DCHECK_EQ(len, ext->GetObsoleteDexCaches()->GetLength());
Alex Light0b772572016-12-02 17:27:31 -0800116 // Using kRuntimePointerSize (instead of using the image's pointer size) is fine since images
117 // should never have obsolete methods in them so they should always be the same.
Alex Lighta01de592016-11-15 10:43:06 -0800118 PointerSize pointer_size = kRuntimePointerSize;
119 DCHECK_EQ(kRuntimePointerSize, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
120 for (int32_t i = 0; i < len; i++) {
121 if (this == obsolete_methods->GetElementPtrSize<ArtMethod*>(i, pointer_size)) {
122 return ext->GetObsoleteDexCaches()->Get(i);
123 }
124 }
125 LOG(FATAL) << "This method does not appear in the obsolete map of its class!";
126 UNREACHABLE();
127}
128
Alex Lightf2f1c9d2017-03-15 15:35:46 +0000129uint16_t ArtMethod::FindObsoleteDexClassDefIndex() {
130 DCHECK(!Runtime::Current()->IsAotCompiler()) << PrettyMethod();
131 DCHECK(IsObsolete());
132 const DexFile* dex_file = GetDexFile();
133 const dex::TypeIndex declaring_class_type = dex_file->GetMethodId(GetDexMethodIndex()).class_idx_;
134 const DexFile::ClassDef* class_def = dex_file->FindClassDef(declaring_class_type);
135 CHECK(class_def != nullptr);
136 return dex_file->GetIndexForClassDef(*class_def);
137}
138
Vladimir Marko28e012a2017-12-07 11:22:59 +0000139ObjPtr<mirror::String> ArtMethod::GetNameAsString(Thread* self) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700140 CHECK(!IsProxyMethod());
Ian Rogers6b14d552014-10-28 21:50:58 -0700141 StackHandleScope<1> hs(self);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700142 Handle<mirror::DexCache> dex_cache(hs.NewHandle(GetDexCache()));
143 auto* dex_file = dex_cache->GetDexFile();
144 uint32_t dex_method_idx = GetDexMethodIndex();
145 const DexFile::MethodId& method_id = dex_file->GetMethodId(dex_method_idx);
Vladimir Markoa64b52d2017-12-08 16:27:49 +0000146 return Runtime::Current()->GetClassLinker()->ResolveString(method_id.name_idx_, dex_cache);
Ian Rogers6b14d552014-10-28 21:50:58 -0700147}
148
Alex Light9139e002015-10-09 15:59:48 -0700149void ArtMethod::ThrowInvocationTimeError() {
150 DCHECK(!IsInvokable());
151 // NOTE: IsDefaultConflicting must be first since the actual method might or might not be abstract
152 // due to the way we select it.
153 if (IsDefaultConflicting()) {
154 ThrowIncompatibleClassChangeErrorForMethodConflict(this);
155 } else {
156 DCHECK(IsAbstract());
157 ThrowAbstractMethodError(this);
158 }
159}
160
Ian Rogersef7d42f2014-01-06 12:55:46 -0800161InvokeType ArtMethod::GetInvokeType() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800162 // TODO: kSuper?
Nicolas Geoffray3aaf9642016-06-07 14:14:37 +0000163 if (IsStatic()) {
Nicolas Geoffray12abcbd2016-06-06 15:51:58 +0000164 return kStatic;
Nicolas Geoffray3aaf9642016-06-07 14:14:37 +0000165 } else if (GetDeclaringClass()->IsInterface()) {
166 return kInterface;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800167 } else if (IsDirect()) {
168 return kDirect;
Orion Hodson43f0cdb2017-10-10 14:47:32 +0100169 } else if (IsPolymorphicSignature()) {
170 return kPolymorphic;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800171 } else {
172 return kVirtual;
173 }
174}
175
Brian Carlstromea46f952013-07-30 01:26:50 -0700176size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) {
Ian Rogers6b604a12014-09-25 15:35:37 -0700177 CHECK_LE(1U, shorty.length());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800178 uint32_t num_registers = 0;
Ian Rogers6b604a12014-09-25 15:35:37 -0700179 for (size_t i = 1; i < shorty.length(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800180 char ch = shorty[i];
181 if (ch == 'D' || ch == 'J') {
182 num_registers += 2;
183 } else {
184 num_registers += 1;
185 }
186 }
187 return num_registers;
188}
189
Alex Light6c8467f2015-11-20 15:03:26 -0800190bool ArtMethod::HasSameNameAndSignature(ArtMethod* other) {
Mathieu Chartier268764d2016-09-13 12:09:38 -0700191 ScopedAssertNoThreadSuspension ants("HasSameNameAndSignature");
Alex Light6c8467f2015-11-20 15:03:26 -0800192 const DexFile* dex_file = GetDexFile();
193 const DexFile::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex());
194 if (GetDexCache() == other->GetDexCache()) {
195 const DexFile::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex());
Ian Rogersf2247512014-12-02 16:17:08 -0800196 return mid.name_idx_ == mid2.name_idx_ && mid.proto_idx_ == mid2.proto_idx_;
197 }
Alex Light6c8467f2015-11-20 15:03:26 -0800198 const DexFile* dex_file2 = other->GetDexFile();
199 const DexFile::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex());
Ian Rogersf2247512014-12-02 16:17:08 -0800200 if (!DexFileStringEquals(dex_file, mid.name_idx_, dex_file2, mid2.name_idx_)) {
201 return false; // Name mismatch.
202 }
203 return dex_file->GetMethodSignature(mid) == dex_file2->GetMethodSignature(mid2);
204}
205
Andreas Gampe542451c2016-07-26 09:02:02 -0700206ArtMethod* ArtMethod::FindOverriddenMethod(PointerSize pointer_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800207 if (IsStatic()) {
Ian Rogersf2247512014-12-02 16:17:08 -0800208 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800209 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700210 mirror::Class* declaring_class = GetDeclaringClass();
211 mirror::Class* super_class = declaring_class->GetSuperClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800212 uint16_t method_index = GetMethodIndex();
Ian Rogersf2247512014-12-02 16:17:08 -0800213 ArtMethod* result = nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800214 // Did this method override a super class method? If so load the result from the super class'
215 // vtable
Mingyao Yang2cdbad72014-07-16 10:44:41 -0700216 if (super_class->HasVTable() && method_index < super_class->GetVTableLength()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700217 result = super_class->GetVTableEntry(method_index, pointer_size);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800218 } else {
219 // Method didn't override superclass method so search interfaces
220 if (IsProxyMethod()) {
Vladimir Marko07bfbac2017-07-06 14:55:02 +0100221 result = GetInterfaceMethodIfProxy(pointer_size);
222 DCHECK(result != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800223 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700224 mirror::IfTable* iftable = GetDeclaringClass()->GetIfTable();
Ian Rogersf2247512014-12-02 16:17:08 -0800225 for (size_t i = 0; i < iftable->Count() && result == nullptr; i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700226 mirror::Class* interface = iftable->GetInterface(i);
Alex Light51a64d52015-12-17 13:55:59 -0800227 for (ArtMethod& interface_method : interface->GetVirtualMethods(pointer_size)) {
228 if (HasSameNameAndSignature(interface_method.GetInterfaceMethodIfProxy(pointer_size))) {
229 result = &interface_method;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800230 break;
231 }
232 }
233 }
234 }
235 }
Alex Light6c8467f2015-11-20 15:03:26 -0800236 DCHECK(result == nullptr ||
Alex Light51a64d52015-12-17 13:55:59 -0800237 GetInterfaceMethodIfProxy(pointer_size)->HasSameNameAndSignature(
238 result->GetInterfaceMethodIfProxy(pointer_size)));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800239 return result;
240}
241
Ian Rogerse0a02da2014-12-02 14:10:53 -0800242uint32_t ArtMethod::FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile,
243 uint32_t name_and_signature_idx) {
244 const DexFile* dexfile = GetDexFile();
245 const uint32_t dex_method_idx = GetDexMethodIndex();
246 const DexFile::MethodId& mid = dexfile->GetMethodId(dex_method_idx);
247 const DexFile::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx);
248 DCHECK_STREQ(dexfile->GetMethodName(mid), other_dexfile.GetMethodName(name_and_sig_mid));
249 DCHECK_EQ(dexfile->GetMethodSignature(mid), other_dexfile.GetMethodSignature(name_and_sig_mid));
250 if (dexfile == &other_dexfile) {
251 return dex_method_idx;
252 }
253 const char* mid_declaring_class_descriptor = dexfile->StringByTypeIdx(mid.class_idx_);
Mathieu Chartier9507fa22015-10-29 15:08:57 -0700254 const DexFile::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor);
255 if (other_type_id != nullptr) {
256 const DexFile::MethodId* other_mid = other_dexfile.FindMethodId(
257 *other_type_id, other_dexfile.GetStringId(name_and_sig_mid.name_idx_),
258 other_dexfile.GetProtoId(name_and_sig_mid.proto_idx_));
259 if (other_mid != nullptr) {
260 return other_dexfile.GetIndexForMethodId(*other_mid);
Ian Rogerse0a02da2014-12-02 14:10:53 -0800261 }
262 }
Andreas Gampee2abbc62017-09-15 11:59:26 -0700263 return dex::kDexNoIndex;
Ian Rogerse0a02da2014-12-02 14:10:53 -0800264}
265
Mathieu Chartiere401d142015-04-22 13:56:20 -0700266uint32_t ArtMethod::FindCatchBlock(Handle<mirror::Class> exception_type,
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700267 uint32_t dex_pc, bool* has_no_move_exception) {
Jeff Haoaa961912014-04-22 13:54:32 -0700268 // Set aside the exception while we resolve its type.
269 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700270 StackHandleScope<1> hs(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000271 Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException()));
Jeff Haoaa961912014-04-22 13:54:32 -0700272 self->ClearException();
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700273 // Default to handler not found.
Andreas Gampee2abbc62017-09-15 11:59:26 -0700274 uint32_t found_dex_pc = dex::kDexNoIndex;
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700275 // Iterate over the catch handlers associated with dex_pc.
David Sehr0225f8e2018-01-31 08:52:24 +0000276 CodeItemDataAccessor accessor(DexInstructionData());
Mathieu Chartierdc578c72017-12-27 11:51:45 -0800277 for (CatchHandlerIterator it(accessor, dex_pc); it.HasNext(); it.Next()) {
Andreas Gampea5b09a62016-11-17 15:21:22 -0800278 dex::TypeIndex iter_type_idx = it.GetHandlerTypeIndex();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800279 // Catch all case
Andreas Gampea5b09a62016-11-17 15:21:22 -0800280 if (!iter_type_idx.IsValid()) {
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700281 found_dex_pc = it.GetHandlerAddress();
282 break;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800283 }
284 // Does this catch exception type apply?
Vladimir Markob45528c2017-07-27 14:14:28 +0100285 ObjPtr<mirror::Class> iter_exception_type = ResolveClassFromTypeIndex(iter_type_idx);
Ian Rogers822266b2014-05-29 16:55:06 -0700286 if (UNLIKELY(iter_exception_type == nullptr)) {
287 // Now have a NoClassDefFoundError as exception. Ignore in case the exception class was
288 // removed by a pro-guard like tool.
Andreas Gampe72b3e432014-05-13 21:42:05 -0700289 // Note: this is not RI behavior. RI would have failed when loading the class.
Ian Rogers822266b2014-05-29 16:55:06 -0700290 self->ClearException();
291 // Delete any long jump context as this routine is called during a stack walk which will
292 // release its in use context at the end.
293 delete self->GetLongJumpContext();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800294 LOG(WARNING) << "Unresolved exception class when finding catch block: "
Mathieu Chartiere401d142015-04-22 13:56:20 -0700295 << DescriptorToDot(GetTypeDescriptorFromTypeIdx(iter_type_idx));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700296 } else if (iter_exception_type->IsAssignableFrom(exception_type.Get())) {
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700297 found_dex_pc = it.GetHandlerAddress();
298 break;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800299 }
300 }
Andreas Gampee2abbc62017-09-15 11:59:26 -0700301 if (found_dex_pc != dex::kDexNoIndex) {
Mathieu Chartierdc578c72017-12-27 11:51:45 -0800302 const Instruction& first_catch_instr = accessor.InstructionAt(found_dex_pc);
Mathieu Chartier808c7a52017-12-15 11:19:33 -0800303 *has_no_move_exception = (first_catch_instr.Opcode() != Instruction::MOVE_EXCEPTION);
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700304 }
Jeff Haoaa961912014-04-22 13:54:32 -0700305 // Put the exception back.
Andreas Gampefa4333d2017-02-14 11:10:34 -0800306 if (exception != nullptr) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000307 self->SetException(exception.Get());
Jeff Haoaa961912014-04-22 13:54:32 -0700308 }
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700309 return found_dex_pc;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800310}
311
Brian Carlstromea46f952013-07-30 01:26:50 -0700312void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
Ian Rogers0177e532014-02-11 16:30:46 -0800313 const char* shorty) {
Dave Allison648d7112014-07-25 16:15:27 -0700314 if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) {
315 ThrowStackOverflowError(self);
316 return;
317 }
318
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800319 if (kIsDebugBuild) {
320 self->AssertThreadSuspensionIsAllowable();
321 CHECK_EQ(kRunnable, self->GetState());
Andreas Gampe542451c2016-07-26 09:02:02 -0700322 CHECK_STREQ(GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(), shorty);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800323 }
324
325 // Push a transition back into managed code onto the linked list in thread.
326 ManagedStack fragment;
327 self->PushManagedStackFragment(&fragment);
328
Ian Rogers62d6c772013-02-27 08:32:07 -0800329 Runtime* runtime = Runtime::Current();
Jeff Hao74180ca2013-03-27 15:29:11 -0700330 // Call the invoke stub, passing everything as arguments.
Daniel Mihalyieb076692014-08-22 17:33:31 +0200331 // If the runtime is not yet started or it is required by the debugger, then perform the
Aart Bik01223202016-05-05 15:10:42 -0700332 // Invocation by the interpreter, explicitly forcing interpretation over JIT to prevent
333 // cycling around the various JIT/Interpreter methods that handle method invocation.
Daniel Mihalyieb076692014-08-22 17:33:31 +0200334 if (UNLIKELY(!runtime->IsStarted() || Dbg::IsForcedInterpreterNeededForCalling(self, this))) {
Ian Rogers5d27faf2014-05-02 17:17:18 -0700335 if (IsStatic()) {
Aart Bik01223202016-05-05 15:10:42 -0700336 art::interpreter::EnterInterpreterFromInvoke(
337 self, this, nullptr, args, result, /*stay_in_interpreter*/ true);
Ian Rogers5d27faf2014-05-02 17:17:18 -0700338 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700339 mirror::Object* receiver =
340 reinterpret_cast<StackReference<mirror::Object>*>(&args[0])->AsMirrorPtr();
Aart Bik01223202016-05-05 15:10:42 -0700341 art::interpreter::EnterInterpreterFromInvoke(
342 self, this, receiver, args + 1, result, /*stay_in_interpreter*/ true);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800343 }
344 } else {
Andreas Gampe542451c2016-07-26 09:02:02 -0700345 DCHECK_EQ(runtime->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700346
347 constexpr bool kLogInvocationStartAndReturn = false;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800348 bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr;
Elliott Hughes956af0f2014-12-11 14:34:28 -0800349 if (LIKELY(have_quick_code)) {
Jeff Hao790ad902013-05-22 15:02:08 -0700350 if (kLogInvocationStartAndReturn) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700351 LOG(INFO) << StringPrintf(
David Sehr709b0702016-10-13 09:12:37 -0700352 "Invoking '%s' quick code=%p static=%d", PrettyMethod().c_str(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700353 GetEntryPointFromQuickCompiledCode(), static_cast<int>(IsStatic() ? 1 : 0));
Jeff Hao790ad902013-05-22 15:02:08 -0700354 }
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700355
Elliott Hughes956af0f2014-12-11 14:34:28 -0800356 // Ensure that we won't be accidentally calling quick compiled code when -Xint.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800357 if (kIsDebugBuild && runtime->GetInstrumentation()->IsForcedInterpretOnly()) {
Calin Juravleffc87072016-04-20 14:22:09 +0100358 CHECK(!runtime->UseJitCompilation());
Alex Lightdb01a092017-04-03 15:39:55 -0700359 const void* oat_quick_code =
360 (IsNative() || !IsInvokable() || IsProxyMethod() || IsObsolete())
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100361 ? nullptr
362 : GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize());
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100363 CHECK(oat_quick_code == nullptr || oat_quick_code != GetEntryPointFromQuickCompiledCode())
David Sehr709b0702016-10-13 09:12:37 -0700364 << "Don't call compiled code when -Xint " << PrettyMethod();
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700365 }
366
Elliott Hughes956af0f2014-12-11 14:34:28 -0800367 if (!IsStatic()) {
Ian Rogers0177e532014-02-11 16:30:46 -0800368 (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800369 } else {
Elliott Hughes956af0f2014-12-11 14:34:28 -0800370 (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800371 }
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000372 if (UNLIKELY(self->GetException() == Thread::GetDeoptimizationException())) {
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200373 // Unusual case where we were running generated code and an
Jeff Hao790ad902013-05-22 15:02:08 -0700374 // exception was thrown to force the activations to be removed from the
375 // stack. Continue execution in the interpreter.
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000376 self->DeoptimizeWithDeoptimizationException(result);
Jeff Hao790ad902013-05-22 15:02:08 -0700377 }
378 if (kLogInvocationStartAndReturn) {
David Sehr709b0702016-10-13 09:12:37 -0700379 LOG(INFO) << StringPrintf("Returned '%s' quick code=%p", PrettyMethod().c_str(),
Elliott Hughes956af0f2014-12-11 14:34:28 -0800380 GetEntryPointFromQuickCompiledCode());
Jeff Hao5d917302013-02-27 17:57:33 -0800381 }
382 } else {
David Sehr709b0702016-10-13 09:12:37 -0700383 LOG(INFO) << "Not invoking '" << PrettyMethod() << "' code=null";
Ian Rogersf2247512014-12-02 16:17:08 -0800384 if (result != nullptr) {
Jeff Hao5d917302013-02-27 17:57:33 -0800385 result->SetJ(0);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800386 }
387 }
388 }
389
390 // Pop transition.
391 self->PopManagedStackFragment(fragment);
392}
393
Vladimir Markob0a6aee2017-10-27 10:34:04 +0100394const void* ArtMethod::RegisterNative(const void* native_method) {
David Sehr709b0702016-10-13 09:12:37 -0700395 CHECK(IsNative()) << PrettyMethod();
David Sehr709b0702016-10-13 09:12:37 -0700396 CHECK(native_method != nullptr) << PrettyMethod();
Alex Lightd78ddec2017-04-18 15:20:38 -0700397 void* new_native_method = nullptr;
398 Runtime::Current()->GetRuntimeCallbacks()->RegisterNativeMethod(this,
399 native_method,
400 /*out*/&new_native_method);
401 SetEntryPointFromJni(new_native_method);
402 return new_native_method;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800403}
404
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700405void ArtMethod::UnregisterNative() {
Vladimir Markob0a6aee2017-10-27 10:34:04 +0100406 CHECK(IsNative()) << PrettyMethod();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800407 // restore stub to lookup native pointer via dlsym
Alex Lightd78ddec2017-04-18 15:20:38 -0700408 SetEntryPointFromJni(GetJniDlsymLookupStub());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800409}
410
Alex Light9139e002015-10-09 15:59:48 -0700411bool ArtMethod::IsOverridableByDefaultMethod() {
412 return GetDeclaringClass()->IsInterface();
413}
414
Orion Hodsoneb4d19b2017-11-06 15:49:23 +0000415bool ArtMethod::IsPolymorphicSignature() {
416 // Methods with a polymorphic signature have constraints that they
417 // are native and varargs and belong to either MethodHandle or VarHandle.
418 if (!IsNative() || !IsVarargs()) {
419 return false;
420 }
421 mirror::Class* cls = GetDeclaringClass();
422 return (cls == WellKnownClasses::ToClass(WellKnownClasses::java_lang_invoke_MethodHandle) ||
423 cls == WellKnownClasses::ToClass(WellKnownClasses::java_lang_invoke_VarHandle));
424}
425
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100426static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file,
427 uint16_t class_def_idx,
428 uint32_t method_idx) {
429 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
430 const uint8_t* class_data = dex_file.GetClassData(class_def);
431 CHECK(class_data != nullptr);
432 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartiere17cf242017-06-19 11:05:51 -0700433 it.SkipAllFields();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100434 // Process methods
435 size_t class_def_method_index = 0;
436 while (it.HasNextDirectMethod()) {
437 if (it.GetMemberIndex() == method_idx) {
438 return class_def_method_index;
439 }
440 class_def_method_index++;
441 it.Next();
442 }
443 while (it.HasNextVirtualMethod()) {
444 if (it.GetMemberIndex() == method_idx) {
445 return class_def_method_index;
446 }
447 class_def_method_index++;
448 it.Next();
449 }
450 DCHECK(!it.HasNext());
451 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
452 UNREACHABLE();
453}
454
Alex Lighteee0bd42017-02-14 15:31:45 +0000455// We use the method's DexFile and declaring class name to find the OatMethod for an obsolete
456// method. This is extremely slow but we need it if we want to be able to have obsolete native
457// methods since we need this to find the size of its stack frames.
458//
459// NB We could (potentially) do this differently and rely on the way the transformation is applied
460// in order to use the entrypoint to find this information. However, for debugging reasons (most
461// notably making sure that new invokes of obsolete methods fail) we choose to instead get the data
462// directly from the dex file.
463static const OatFile::OatMethod FindOatMethodFromDexFileFor(ArtMethod* method, bool* found)
464 REQUIRES_SHARED(Locks::mutator_lock_) {
465 DCHECK(method->IsObsolete() && method->IsNative());
466 const DexFile* dex_file = method->GetDexFile();
467
468 // recreate the class_def_index from the descriptor.
469 std::string descriptor_storage;
470 const DexFile::TypeId* declaring_class_type_id =
471 dex_file->FindTypeId(method->GetDeclaringClass()->GetDescriptor(&descriptor_storage));
472 CHECK(declaring_class_type_id != nullptr);
473 dex::TypeIndex declaring_class_type_index = dex_file->GetIndexForTypeId(*declaring_class_type_id);
474 const DexFile::ClassDef* declaring_class_type_def =
475 dex_file->FindClassDef(declaring_class_type_index);
476 CHECK(declaring_class_type_def != nullptr);
477 uint16_t declaring_class_def_index = dex_file->GetIndexForClassDef(*declaring_class_type_def);
478
479 size_t oat_method_index = GetOatMethodIndexFromMethodIndex(*dex_file,
480 declaring_class_def_index,
481 method->GetDexMethodIndex());
482
483 OatFile::OatClass oat_class = OatFile::FindOatClass(*dex_file,
484 declaring_class_def_index,
485 found);
486 if (!(*found)) {
487 return OatFile::OatMethod::Invalid();
488 }
489 return oat_class.GetOatMethod(oat_method_index);
490}
491
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100492static const OatFile::OatMethod FindOatMethodFor(ArtMethod* method,
493 PointerSize pointer_size,
494 bool* found)
495 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteee0bd42017-02-14 15:31:45 +0000496 if (UNLIKELY(method->IsObsolete())) {
497 // We shouldn't be calling this with obsolete methods except for native obsolete methods for
498 // which we need to use the oat method to figure out how large the quick frame is.
499 DCHECK(method->IsNative()) << "We should only be finding the OatMethod of obsolete methods in "
500 << "order to allow stack walking. Other obsolete methods should "
501 << "never need to access this information.";
502 DCHECK_EQ(pointer_size, kRuntimePointerSize) << "Obsolete method in compiler!";
503 return FindOatMethodFromDexFileFor(method, found);
504 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100505 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
506 // method for direct methods (or virtual methods made direct).
507 mirror::Class* declaring_class = method->GetDeclaringClass();
508 size_t oat_method_index;
509 if (method->IsStatic() || method->IsDirect()) {
510 // Simple case where the oat method index was stashed at load time.
511 oat_method_index = method->GetMethodIndex();
512 } else {
513 // Compute the oat_method_index by search for its position in the declared virtual methods.
514 oat_method_index = declaring_class->NumDirectMethods();
515 bool found_virtual = false;
516 for (ArtMethod& art_method : declaring_class->GetVirtualMethods(pointer_size)) {
517 // Check method index instead of identity in case of duplicate method definitions.
518 if (method->GetDexMethodIndex() == art_method.GetDexMethodIndex()) {
519 found_virtual = true;
520 break;
521 }
522 oat_method_index++;
523 }
524 CHECK(found_virtual) << "Didn't find oat method index for virtual method: "
David Sehr709b0702016-10-13 09:12:37 -0700525 << method->PrettyMethod();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100526 }
527 DCHECK_EQ(oat_method_index,
528 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
529 method->GetDeclaringClass()->GetDexClassDefIndex(),
530 method->GetDexMethodIndex()));
531 OatFile::OatClass oat_class = OatFile::FindOatClass(*declaring_class->GetDexCache()->GetDexFile(),
532 declaring_class->GetDexClassDefIndex(),
533 found);
534 if (!(*found)) {
535 return OatFile::OatMethod::Invalid();
536 }
537 return oat_class.GetOatMethod(oat_method_index);
538}
539
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700540bool ArtMethod::EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params) {
541 auto* dex_cache = GetDexCache();
542 auto* dex_file = dex_cache->GetDexFile();
543 const auto& method_id = dex_file->GetMethodId(GetDexMethodIndex());
544 const auto& proto_id = dex_file->GetMethodPrototype(method_id);
545 const DexFile::TypeList* proto_params = dex_file->GetProtoParameters(proto_id);
546 auto count = proto_params != nullptr ? proto_params->Size() : 0u;
Andreas Gampefa4333d2017-02-14 11:10:34 -0800547 auto param_len = params != nullptr ? params->GetLength() : 0u;
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700548 if (param_len != count) {
549 return false;
550 }
551 auto* cl = Runtime::Current()->GetClassLinker();
552 for (size_t i = 0; i < count; ++i) {
Vladimir Marko28e012a2017-12-07 11:22:59 +0000553 dex::TypeIndex type_idx = proto_params->GetTypeItem(i).type_idx_;
554 ObjPtr<mirror::Class> type = cl->ResolveType(type_idx, this);
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700555 if (type == nullptr) {
556 Thread::Current()->AssertPendingException();
557 return false;
558 }
559 if (type != params->GetWithoutChecks(i)) {
560 return false;
561 }
562 }
563 return true;
564}
565
Mathieu Chartier210531f2018-01-12 10:15:51 -0800566ArrayRef<const uint8_t> ArtMethod::GetQuickenedInfo() {
Nicolas Geoffray8eaa8e52017-11-13 17:47:50 +0000567 const DexFile& dex_file = GetDeclaringClass()->GetDexFile();
568 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
569 if (oat_dex_file == nullptr || (oat_dex_file->GetOatFile() == nullptr)) {
Mathieu Chartier210531f2018-01-12 10:15:51 -0800570 return ArrayRef<const uint8_t>();
Nicolas Geoffray4acefd32016-10-24 13:14:58 +0100571 }
Mathieu Chartier210531f2018-01-12 10:15:51 -0800572 return oat_dex_file->GetOatFile()->GetVdexFile()->GetQuickenedInfoOf(dex_file,
573 GetDexMethodIndex());
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100574}
575
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100576const OatQuickMethodHeader* ArtMethod::GetOatQuickMethodHeader(uintptr_t pc) {
Nicolas Geoffray5a23d2e2015-11-03 18:58:57 +0000577 // Our callers should make sure they don't pass the instrumentation exit pc,
578 // as this method does not look at the side instrumentation stack.
579 DCHECK_NE(pc, reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()));
580
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000581 if (IsRuntimeMethod()) {
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100582 return nullptr;
583 }
584
585 Runtime* runtime = Runtime::Current();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100586 const void* existing_entry_point = GetEntryPointFromQuickCompiledCode();
David Sehr709b0702016-10-13 09:12:37 -0700587 CHECK(existing_entry_point != nullptr) << PrettyMethod() << "@" << this;
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100588 ClassLinker* class_linker = runtime->GetClassLinker();
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100589
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000590 if (existing_entry_point == GetQuickProxyInvokeHandler()) {
591 DCHECK(IsProxyMethod() && !IsConstructor());
592 // The proxy entry point does not have any method header.
593 return nullptr;
594 }
595
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100596 // Check whether the current entry point contains this pc.
Vladimir Marko2196c652017-11-30 16:16:07 +0000597 if (!class_linker->IsQuickGenericJniStub(existing_entry_point) &&
598 !class_linker->IsQuickResolutionStub(existing_entry_point) &&
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100599 !class_linker->IsQuickToInterpreterBridge(existing_entry_point)) {
600 OatQuickMethodHeader* method_header =
601 OatQuickMethodHeader::FromEntryPoint(existing_entry_point);
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100602
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100603 if (method_header->Contains(pc)) {
604 return method_header;
605 }
606 }
607
608 // Check whether the pc is in the JIT code cache.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100609 jit::Jit* jit = runtime->GetJit();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100610 if (jit != nullptr) {
611 jit::JitCodeCache* code_cache = jit->GetCodeCache();
612 OatQuickMethodHeader* method_header = code_cache->LookupMethodHeader(pc, this);
613 if (method_header != nullptr) {
614 DCHECK(method_header->Contains(pc));
615 return method_header;
616 } else {
Nicolas Geoffray2a524bd2016-03-01 12:18:47 +0000617 DCHECK(!code_cache->ContainsPc(reinterpret_cast<const void*>(pc)))
David Sehr709b0702016-10-13 09:12:37 -0700618 << PrettyMethod()
Nicolas Geoffray2a524bd2016-03-01 12:18:47 +0000619 << ", pc=" << std::hex << pc
620 << ", entry_point=" << std::hex << reinterpret_cast<uintptr_t>(existing_entry_point)
621 << ", copy=" << std::boolalpha << IsCopied()
622 << ", proxy=" << std::boolalpha << IsProxyMethod();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100623 }
624 }
625
626 // The code has to be in an oat file.
627 bool found;
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100628 OatFile::OatMethod oat_method =
629 FindOatMethodFor(this, class_linker->GetImagePointerSize(), &found);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100630 if (!found) {
Vladimir Marko2196c652017-11-30 16:16:07 +0000631 if (IsNative()) {
632 // We are running the GenericJNI stub. The entrypoint may point
633 // to different entrypoints or to a JIT-compiled JNI stub.
634 DCHECK(class_linker->IsQuickGenericJniStub(existing_entry_point) ||
635 class_linker->IsQuickResolutionStub(existing_entry_point) ||
636 existing_entry_point == GetQuickInstrumentationEntryPoint() ||
637 (jit != nullptr && jit->GetCodeCache()->ContainsPc(existing_entry_point)));
Nicolas Geoffray49e43962015-10-28 16:16:16 +0000638 return nullptr;
639 }
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100640 // Only for unit tests.
641 // TODO(ngeoffray): Update these tests to pass the right pc?
642 return OatQuickMethodHeader::FromEntryPoint(existing_entry_point);
643 }
644 const void* oat_entry_point = oat_method.GetQuickCode();
645 if (oat_entry_point == nullptr || class_linker->IsQuickGenericJniStub(oat_entry_point)) {
David Sehr709b0702016-10-13 09:12:37 -0700646 DCHECK(IsNative()) << PrettyMethod();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100647 return nullptr;
648 }
649
650 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromEntryPoint(oat_entry_point);
651 if (pc == 0) {
652 // This is a downcall, it can only happen for a native method.
653 DCHECK(IsNative());
654 return method_header;
655 }
656
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100657 DCHECK(method_header->Contains(pc))
David Sehr709b0702016-10-13 09:12:37 -0700658 << PrettyMethod()
Roland Levillain0b671c02016-08-19 12:02:34 +0100659 << " " << std::hex << pc << " " << oat_entry_point
Mingyao Yang063fc772016-08-02 11:02:54 -0700660 << " " << (uintptr_t)(method_header->GetCode() + method_header->GetCodeSize());
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100661 return method_header;
662}
663
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100664const void* ArtMethod::GetOatMethodQuickCode(PointerSize pointer_size) {
665 bool found;
666 OatFile::OatMethod oat_method = FindOatMethodFor(this, pointer_size, &found);
667 if (found) {
668 return oat_method.GetQuickCode();
669 }
670 return nullptr;
671}
672
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000673bool ArtMethod::HasAnyCompiledCode() {
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100674 if (IsNative() || !IsInvokable() || IsProxyMethod()) {
675 return false;
676 }
677
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000678 // Check whether the JIT has compiled it.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100679 Runtime* runtime = Runtime::Current();
680 jit::Jit* jit = runtime->GetJit();
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000681 if (jit != nullptr && jit->GetCodeCache()->ContainsMethod(this)) {
682 return true;
683 }
684
685 // Check whether we have AOT code.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100686 return GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize()) != nullptr;
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000687}
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000688
Andreas Gampe542451c2016-07-26 09:02:02 -0700689void ArtMethod::CopyFrom(ArtMethod* src, PointerSize image_pointer_size) {
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000690 memcpy(reinterpret_cast<void*>(this), reinterpret_cast<const void*>(src),
691 Size(image_pointer_size));
692 declaring_class_ = GcRoot<mirror::Class>(const_cast<ArtMethod*>(src)->GetDeclaringClass());
693
694 // If the entry point of the method we are copying from is from JIT code, we just
Vladimir Marko2196c652017-11-30 16:16:07 +0000695 // put the entry point of the new method to interpreter or GenericJNI. We could set
696 // the entry point to the JIT code, but this would require taking the JIT code cache
697 // lock to notify it, which we do not want at this level.
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000698 Runtime* runtime = Runtime::Current();
Calin Juravleffc87072016-04-20 14:22:09 +0100699 if (runtime->UseJitCompilation()) {
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000700 if (runtime->GetJit()->GetCodeCache()->ContainsPc(GetEntryPointFromQuickCompiledCode())) {
Vladimir Marko2196c652017-11-30 16:16:07 +0000701 SetEntryPointFromQuickCompiledCodePtrSize(
702 src->IsNative() ? GetQuickGenericJniStub() : GetQuickToInterpreterBridge(),
703 image_pointer_size);
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000704 }
705 }
706 // Clear the profiling info for the same reasons as the JIT code.
707 if (!src->IsNative()) {
708 SetProfilingInfoPtrSize(nullptr, image_pointer_size);
709 }
710 // Clear hotness to let the JIT properly decide when to compile this method.
711 hotness_count_ = 0;
712}
713
Andreas Gampe542451c2016-07-26 09:02:02 -0700714bool ArtMethod::IsImagePointerSize(PointerSize pointer_size) {
Andreas Gampe479b1de2016-07-19 18:27:17 -0700715 // Hijack this function to get access to PtrSizedFieldsOffset.
716 //
717 // Ensure that PrtSizedFieldsOffset is correct. We rely here on usually having both 32-bit and
718 // 64-bit builds.
719 static_assert(std::is_standard_layout<ArtMethod>::value, "ArtMethod is not standard layout.");
Andreas Gampe542451c2016-07-26 09:02:02 -0700720 static_assert(
721 (sizeof(void*) != 4) ||
722 (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k32)),
723 "Unexpected 32-bit class layout.");
724 static_assert(
725 (sizeof(void*) != 8) ||
726 (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k64)),
727 "Unexpected 64-bit class layout.");
Andreas Gampe479b1de2016-07-19 18:27:17 -0700728
Andreas Gampe75f08852016-07-19 08:06:07 -0700729 Runtime* runtime = Runtime::Current();
730 if (runtime == nullptr) {
731 return true;
732 }
733 return runtime->GetClassLinker()->GetImagePointerSize() == pointer_size;
734}
735
David Sehr709b0702016-10-13 09:12:37 -0700736std::string ArtMethod::PrettyMethod(ArtMethod* m, bool with_signature) {
737 if (m == nullptr) {
738 return "null";
739 }
740 return m->PrettyMethod(with_signature);
741}
742
743std::string ArtMethod::PrettyMethod(bool with_signature) {
Vladimir Markob8a55f82017-09-21 16:21:43 +0100744 if (UNLIKELY(IsRuntimeMethod())) {
745 std::string result = GetDeclaringClassDescriptor();
746 result += '.';
747 result += GetName();
748 // Do not add "<no signature>" even if `with_signature` is true.
749 return result;
David Sehr709b0702016-10-13 09:12:37 -0700750 }
Vladimir Markob8a55f82017-09-21 16:21:43 +0100751 ArtMethod* m =
752 GetInterfaceMethodIfProxy(Runtime::Current()->GetClassLinker()->GetImagePointerSize());
753 return m->GetDexFile()->PrettyMethod(m->GetDexMethodIndex(), with_signature);
David Sehr709b0702016-10-13 09:12:37 -0700754}
755
756std::string ArtMethod::JniShortName() {
Alex Light888a59e2017-01-25 11:41:41 -0800757 return GetJniShortName(GetDeclaringClassDescriptor(), GetName());
David Sehr709b0702016-10-13 09:12:37 -0700758}
759
760std::string ArtMethod::JniLongName() {
761 std::string long_name;
762 long_name += JniShortName();
763 long_name += "__";
764
765 std::string signature(GetSignature().ToString());
766 signature.erase(0, 1);
767 signature.erase(signature.begin() + signature.find(')'), signature.end());
768
769 long_name += MangleForJni(signature);
770
771 return long_name;
772}
773
Andreas Gampec6ea7d02017-02-01 16:46:28 -0800774// AssertSharedHeld doesn't work in GetAccessFlags, so use a NO_THREAD_SAFETY_ANALYSIS helper.
775// TODO: Figure out why ASSERT_SHARED_CAPABILITY doesn't work.
776template <ReadBarrierOption kReadBarrierOption>
777ALWAYS_INLINE static inline void DoGetAccessFlagsHelper(ArtMethod* method)
778 NO_THREAD_SAFETY_ANALYSIS {
779 CHECK(method->IsRuntimeMethod() ||
780 method->GetDeclaringClass<kReadBarrierOption>()->IsIdxLoaded() ||
781 method->GetDeclaringClass<kReadBarrierOption>()->IsErroneous());
782}
783
784template <ReadBarrierOption kReadBarrierOption> void ArtMethod::GetAccessFlagsDCheck() {
785 if (kCheckDeclaringClassState) {
786 Thread* self = Thread::Current();
787 if (!Locks::mutator_lock_->IsSharedHeld(self)) {
788 if (self->IsThreadSuspensionAllowable()) {
789 ScopedObjectAccess soa(self);
790 CHECK(IsRuntimeMethod() ||
791 GetDeclaringClass<kReadBarrierOption>()->IsIdxLoaded() ||
792 GetDeclaringClass<kReadBarrierOption>()->IsErroneous());
793 }
794 } else {
795 // We cannot use SOA in this case. We might be holding the lock, but may not be in the
796 // runnable state (e.g., during GC).
797 Locks::mutator_lock_->AssertSharedHeld(self);
798 DoGetAccessFlagsHelper<kReadBarrierOption>(this);
799 }
800 }
801}
802template void ArtMethod::GetAccessFlagsDCheck<ReadBarrierOption::kWithReadBarrier>();
803template void ArtMethod::GetAccessFlagsDCheck<ReadBarrierOption::kWithoutReadBarrier>();
804
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800805} // namespace art