blob: 631f5e7250fb9c8a8e435cd182862ead6f99bf61 [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"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070028#include "dex_file-inl.h"
David Sehr9323e6e2016-09-13 08:58:35 -070029#include "dex_file_annotations.h"
Ian Rogersc449aa82013-07-29 14:35:46 -070030#include "dex_instruction.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070031#include "entrypoints/runtime_asm_entrypoints.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070032#include "gc/accounting/card_table-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080033#include "interpreter/interpreter.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080034#include "jit/jit.h"
35#include "jit/jit_code_cache.h"
Nicolas Geoffray5550ca82015-08-21 18:38:30 +010036#include "jit/profiling_info.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080037#include "jni_internal.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070038#include "mirror/class-inl.h"
Alex Lighta01de592016-11-15 10:43:06 -080039#include "mirror/class_ext.h"
Neil Fuller0e844392016-09-08 13:43:31 +010040#include "mirror/executable.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070041#include "mirror/object-inl.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070042#include "mirror/object_array-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070043#include "mirror/string.h"
Nicolas Geoffray9523a3e2015-07-17 11:51:28 +000044#include "oat_file-inl.h"
Alex Lightd78ddec2017-04-18 15:20:38 -070045#include "runtime_callbacks.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070046#include "scoped_thread_state_change-inl.h"
Nicolas Geoffrayb02ba932017-07-13 15:53:54 +010047#include "vdex_file.h"
Ian Rogers62f05122014-03-21 11:21:29 -070048#include "well_known_classes.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080049
50namespace art {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080051
Andreas Gampe46ee31b2016-12-14 10:11:49 -080052using android::base::StringPrintf;
53
Ian Rogers0177e532014-02-11 16:30:46 -080054extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
55 const char*);
Ian Rogers936b37f2014-02-14 00:52:24 -080056extern "C" void art_quick_invoke_static_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
57 const char*);
Jeff Hao5d917302013-02-27 17:57:33 -080058
Andreas Gampeaea05c12017-05-19 08:45:02 -070059DEFINE_RUNTIME_DEBUG_FLAG(ArtMethod, kCheckDeclaringClassState);
60
Andreas Gampec6ea7d02017-02-01 16:46:28 -080061// Enforce that we he have the right index for runtime methods.
62static_assert(ArtMethod::kRuntimeMethodDexMethodIndex == DexFile::kDexNoIndex,
63 "Wrong runtime-method dex method index");
64
Alex Light97e78032017-06-27 17:51:55 -070065ArtMethod* ArtMethod::GetCanonicalMethod(PointerSize pointer_size) {
66 if (LIKELY(!IsDefault())) {
67 return this;
68 } else {
69 mirror::Class* declaring_class = GetDeclaringClass();
Vladimir Markoba118822017-06-12 15:41:56 +010070 DCHECK(declaring_class->IsInterface());
71 ArtMethod* ret = declaring_class->FindInterfaceMethod(declaring_class->GetDexCache(),
72 GetDexMethodIndex(),
73 pointer_size);
Alex Light97e78032017-06-27 17:51:55 -070074 DCHECK(ret != nullptr);
75 return ret;
76 }
77}
78
Alex Light4ba388a2017-01-27 10:26:49 -080079ArtMethod* ArtMethod::GetNonObsoleteMethod() {
80 DCHECK_EQ(kRuntimePointerSize, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
81 if (LIKELY(!IsObsolete())) {
82 return this;
83 } else if (IsDirect()) {
84 return &GetDeclaringClass()->GetDirectMethodsSlice(kRuntimePointerSize)[GetMethodIndex()];
85 } else {
86 return GetDeclaringClass()->GetVTableEntry(GetMethodIndex(), kRuntimePointerSize);
87 }
88}
89
Mingyao Yange8fcd012017-01-20 10:43:30 -080090ArtMethod* ArtMethod::GetSingleImplementation(PointerSize pointer_size) {
Mingyao Yang063fc772016-08-02 11:02:54 -070091 if (!IsAbstract()) {
92 // A non-abstract's single implementation is itself.
93 return this;
94 }
Mingyao Yange8fcd012017-01-20 10:43:30 -080095 return reinterpret_cast<ArtMethod*>(GetDataPtrSize(pointer_size));
Mingyao Yang063fc772016-08-02 11:02:54 -070096}
97
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070098ArtMethod* ArtMethod::FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa,
99 jobject jlr_method) {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700100 ObjPtr<mirror::Executable> executable = soa.Decode<mirror::Executable>(jlr_method);
Neil Fuller0e844392016-09-08 13:43:31 +0100101 DCHECK(executable != nullptr);
102 return executable->GetArtMethod();
Ian Rogers62f05122014-03-21 11:21:29 -0700103}
104
Alex Lighta01de592016-11-15 10:43:06 -0800105mirror::DexCache* ArtMethod::GetObsoleteDexCache() {
106 DCHECK(!Runtime::Current()->IsAotCompiler()) << PrettyMethod();
107 DCHECK(IsObsolete());
108 ObjPtr<mirror::ClassExt> ext(GetDeclaringClass()->GetExtData());
109 CHECK(!ext.IsNull());
110 ObjPtr<mirror::PointerArray> obsolete_methods(ext->GetObsoleteMethods());
111 CHECK(!obsolete_methods.IsNull());
112 DCHECK(ext->GetObsoleteDexCaches() != nullptr);
113 int32_t len = obsolete_methods->GetLength();
114 DCHECK_EQ(len, ext->GetObsoleteDexCaches()->GetLength());
Alex Light0b772572016-12-02 17:27:31 -0800115 // Using kRuntimePointerSize (instead of using the image's pointer size) is fine since images
116 // should never have obsolete methods in them so they should always be the same.
Alex Lighta01de592016-11-15 10:43:06 -0800117 PointerSize pointer_size = kRuntimePointerSize;
118 DCHECK_EQ(kRuntimePointerSize, Runtime::Current()->GetClassLinker()->GetImagePointerSize());
119 for (int32_t i = 0; i < len; i++) {
120 if (this == obsolete_methods->GetElementPtrSize<ArtMethod*>(i, pointer_size)) {
121 return ext->GetObsoleteDexCaches()->Get(i);
122 }
123 }
124 LOG(FATAL) << "This method does not appear in the obsolete map of its class!";
125 UNREACHABLE();
126}
127
Alex Lightf2f1c9d2017-03-15 15:35:46 +0000128uint16_t ArtMethod::FindObsoleteDexClassDefIndex() {
129 DCHECK(!Runtime::Current()->IsAotCompiler()) << PrettyMethod();
130 DCHECK(IsObsolete());
131 const DexFile* dex_file = GetDexFile();
132 const dex::TypeIndex declaring_class_type = dex_file->GetMethodId(GetDexMethodIndex()).class_idx_;
133 const DexFile::ClassDef* class_def = dex_file->FindClassDef(declaring_class_type);
134 CHECK(class_def != nullptr);
135 return dex_file->GetIndexForClassDef(*class_def);
136}
137
Ian Rogers6b14d552014-10-28 21:50:58 -0700138mirror::String* ArtMethod::GetNameAsString(Thread* self) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700139 CHECK(!IsProxyMethod());
Ian Rogers6b14d552014-10-28 21:50:58 -0700140 StackHandleScope<1> hs(self);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700141 Handle<mirror::DexCache> dex_cache(hs.NewHandle(GetDexCache()));
142 auto* dex_file = dex_cache->GetDexFile();
143 uint32_t dex_method_idx = GetDexMethodIndex();
144 const DexFile::MethodId& method_id = dex_file->GetMethodId(dex_method_idx);
Ian Rogers6b14d552014-10-28 21:50:58 -0700145 return Runtime::Current()->GetClassLinker()->ResolveString(*dex_file, method_id.name_idx_,
146 dex_cache);
147}
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;
169 } else {
170 return kVirtual;
171 }
172}
173
Brian Carlstromea46f952013-07-30 01:26:50 -0700174size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) {
Ian Rogers6b604a12014-09-25 15:35:37 -0700175 CHECK_LE(1U, shorty.length());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800176 uint32_t num_registers = 0;
Ian Rogers6b604a12014-09-25 15:35:37 -0700177 for (size_t i = 1; i < shorty.length(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800178 char ch = shorty[i];
179 if (ch == 'D' || ch == 'J') {
180 num_registers += 2;
181 } else {
182 num_registers += 1;
183 }
184 }
185 return num_registers;
186}
187
Alex Light6c8467f2015-11-20 15:03:26 -0800188bool ArtMethod::HasSameNameAndSignature(ArtMethod* other) {
Mathieu Chartier268764d2016-09-13 12:09:38 -0700189 ScopedAssertNoThreadSuspension ants("HasSameNameAndSignature");
Alex Light6c8467f2015-11-20 15:03:26 -0800190 const DexFile* dex_file = GetDexFile();
191 const DexFile::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex());
192 if (GetDexCache() == other->GetDexCache()) {
193 const DexFile::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex());
Ian Rogersf2247512014-12-02 16:17:08 -0800194 return mid.name_idx_ == mid2.name_idx_ && mid.proto_idx_ == mid2.proto_idx_;
195 }
Alex Light6c8467f2015-11-20 15:03:26 -0800196 const DexFile* dex_file2 = other->GetDexFile();
197 const DexFile::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex());
Ian Rogersf2247512014-12-02 16:17:08 -0800198 if (!DexFileStringEquals(dex_file, mid.name_idx_, dex_file2, mid2.name_idx_)) {
199 return false; // Name mismatch.
200 }
201 return dex_file->GetMethodSignature(mid) == dex_file2->GetMethodSignature(mid2);
202}
203
Andreas Gampe542451c2016-07-26 09:02:02 -0700204ArtMethod* ArtMethod::FindOverriddenMethod(PointerSize pointer_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800205 if (IsStatic()) {
Ian Rogersf2247512014-12-02 16:17:08 -0800206 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800207 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700208 mirror::Class* declaring_class = GetDeclaringClass();
209 mirror::Class* super_class = declaring_class->GetSuperClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800210 uint16_t method_index = GetMethodIndex();
Ian Rogersf2247512014-12-02 16:17:08 -0800211 ArtMethod* result = nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800212 // Did this method override a super class method? If so load the result from the super class'
213 // vtable
Mingyao Yang2cdbad72014-07-16 10:44:41 -0700214 if (super_class->HasVTable() && method_index < super_class->GetVTableLength()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700215 result = super_class->GetVTableEntry(method_index, pointer_size);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800216 } else {
217 // Method didn't override superclass method so search interfaces
218 if (IsProxyMethod()) {
Vladimir Marko07bfbac2017-07-06 14:55:02 +0100219 result = GetInterfaceMethodIfProxy(pointer_size);
220 DCHECK(result != nullptr);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800221 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700222 mirror::IfTable* iftable = GetDeclaringClass()->GetIfTable();
Ian Rogersf2247512014-12-02 16:17:08 -0800223 for (size_t i = 0; i < iftable->Count() && result == nullptr; i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700224 mirror::Class* interface = iftable->GetInterface(i);
Alex Light51a64d52015-12-17 13:55:59 -0800225 for (ArtMethod& interface_method : interface->GetVirtualMethods(pointer_size)) {
226 if (HasSameNameAndSignature(interface_method.GetInterfaceMethodIfProxy(pointer_size))) {
227 result = &interface_method;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800228 break;
229 }
230 }
231 }
232 }
233 }
Alex Light6c8467f2015-11-20 15:03:26 -0800234 DCHECK(result == nullptr ||
Alex Light51a64d52015-12-17 13:55:59 -0800235 GetInterfaceMethodIfProxy(pointer_size)->HasSameNameAndSignature(
236 result->GetInterfaceMethodIfProxy(pointer_size)));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800237 return result;
238}
239
Ian Rogerse0a02da2014-12-02 14:10:53 -0800240uint32_t ArtMethod::FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile,
241 uint32_t name_and_signature_idx) {
242 const DexFile* dexfile = GetDexFile();
243 const uint32_t dex_method_idx = GetDexMethodIndex();
244 const DexFile::MethodId& mid = dexfile->GetMethodId(dex_method_idx);
245 const DexFile::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx);
246 DCHECK_STREQ(dexfile->GetMethodName(mid), other_dexfile.GetMethodName(name_and_sig_mid));
247 DCHECK_EQ(dexfile->GetMethodSignature(mid), other_dexfile.GetMethodSignature(name_and_sig_mid));
248 if (dexfile == &other_dexfile) {
249 return dex_method_idx;
250 }
251 const char* mid_declaring_class_descriptor = dexfile->StringByTypeIdx(mid.class_idx_);
Mathieu Chartier9507fa22015-10-29 15:08:57 -0700252 const DexFile::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor);
253 if (other_type_id != nullptr) {
254 const DexFile::MethodId* other_mid = other_dexfile.FindMethodId(
255 *other_type_id, other_dexfile.GetStringId(name_and_sig_mid.name_idx_),
256 other_dexfile.GetProtoId(name_and_sig_mid.proto_idx_));
257 if (other_mid != nullptr) {
258 return other_dexfile.GetIndexForMethodId(*other_mid);
Ian Rogerse0a02da2014-12-02 14:10:53 -0800259 }
260 }
261 return DexFile::kDexNoIndex;
262}
263
Mathieu Chartiere401d142015-04-22 13:56:20 -0700264uint32_t ArtMethod::FindCatchBlock(Handle<mirror::Class> exception_type,
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700265 uint32_t dex_pc, bool* has_no_move_exception) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700266 const DexFile::CodeItem* code_item = GetCodeItem();
Jeff Haoaa961912014-04-22 13:54:32 -0700267 // Set aside the exception while we resolve its type.
268 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700269 StackHandleScope<1> hs(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000270 Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException()));
Jeff Haoaa961912014-04-22 13:54:32 -0700271 self->ClearException();
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700272 // Default to handler not found.
273 uint32_t found_dex_pc = DexFile::kDexNoIndex;
274 // Iterate over the catch handlers associated with dex_pc.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800275 for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
Andreas Gampea5b09a62016-11-17 15:21:22 -0800276 dex::TypeIndex iter_type_idx = it.GetHandlerTypeIndex();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800277 // Catch all case
Andreas Gampea5b09a62016-11-17 15:21:22 -0800278 if (!iter_type_idx.IsValid()) {
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700279 found_dex_pc = it.GetHandlerAddress();
280 break;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800281 }
282 // Does this catch exception type apply?
Vladimir Marko942fd312017-01-16 20:52:19 +0000283 mirror::Class* iter_exception_type = GetClassFromTypeIndex(iter_type_idx, true /* resolve */);
Ian Rogers822266b2014-05-29 16:55:06 -0700284 if (UNLIKELY(iter_exception_type == nullptr)) {
285 // Now have a NoClassDefFoundError as exception. Ignore in case the exception class was
286 // removed by a pro-guard like tool.
Andreas Gampe72b3e432014-05-13 21:42:05 -0700287 // Note: this is not RI behavior. RI would have failed when loading the class.
Ian Rogers822266b2014-05-29 16:55:06 -0700288 self->ClearException();
289 // Delete any long jump context as this routine is called during a stack walk which will
290 // release its in use context at the end.
291 delete self->GetLongJumpContext();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800292 LOG(WARNING) << "Unresolved exception class when finding catch block: "
Mathieu Chartiere401d142015-04-22 13:56:20 -0700293 << DescriptorToDot(GetTypeDescriptorFromTypeIdx(iter_type_idx));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700294 } else if (iter_exception_type->IsAssignableFrom(exception_type.Get())) {
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700295 found_dex_pc = it.GetHandlerAddress();
296 break;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800297 }
298 }
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700299 if (found_dex_pc != DexFile::kDexNoIndex) {
300 const Instruction* first_catch_instr =
Jeff Haoaa961912014-04-22 13:54:32 -0700301 Instruction::At(&code_item->insns_[found_dex_pc]);
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700302 *has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION);
303 }
Jeff Haoaa961912014-04-22 13:54:32 -0700304 // Put the exception back.
Andreas Gampefa4333d2017-02-14 11:10:34 -0800305 if (exception != nullptr) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000306 self->SetException(exception.Get());
Jeff Haoaa961912014-04-22 13:54:32 -0700307 }
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700308 return found_dex_pc;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800309}
310
Brian Carlstromea46f952013-07-30 01:26:50 -0700311void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
Ian Rogers0177e532014-02-11 16:30:46 -0800312 const char* shorty) {
Dave Allison648d7112014-07-25 16:15:27 -0700313 if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) {
314 ThrowStackOverflowError(self);
315 return;
316 }
317
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800318 if (kIsDebugBuild) {
319 self->AssertThreadSuspensionIsAllowable();
320 CHECK_EQ(kRunnable, self->GetState());
Andreas Gampe542451c2016-07-26 09:02:02 -0700321 CHECK_STREQ(GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(), shorty);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800322 }
323
324 // Push a transition back into managed code onto the linked list in thread.
325 ManagedStack fragment;
326 self->PushManagedStackFragment(&fragment);
327
Ian Rogers62d6c772013-02-27 08:32:07 -0800328 Runtime* runtime = Runtime::Current();
Jeff Hao74180ca2013-03-27 15:29:11 -0700329 // Call the invoke stub, passing everything as arguments.
Daniel Mihalyieb076692014-08-22 17:33:31 +0200330 // If the runtime is not yet started or it is required by the debugger, then perform the
Aart Bik01223202016-05-05 15:10:42 -0700331 // Invocation by the interpreter, explicitly forcing interpretation over JIT to prevent
332 // cycling around the various JIT/Interpreter methods that handle method invocation.
Daniel Mihalyieb076692014-08-22 17:33:31 +0200333 if (UNLIKELY(!runtime->IsStarted() || Dbg::IsForcedInterpreterNeededForCalling(self, this))) {
Ian Rogers5d27faf2014-05-02 17:17:18 -0700334 if (IsStatic()) {
Aart Bik01223202016-05-05 15:10:42 -0700335 art::interpreter::EnterInterpreterFromInvoke(
336 self, this, nullptr, args, result, /*stay_in_interpreter*/ true);
Ian Rogers5d27faf2014-05-02 17:17:18 -0700337 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700338 mirror::Object* receiver =
339 reinterpret_cast<StackReference<mirror::Object>*>(&args[0])->AsMirrorPtr();
Aart Bik01223202016-05-05 15:10:42 -0700340 art::interpreter::EnterInterpreterFromInvoke(
341 self, this, receiver, args + 1, result, /*stay_in_interpreter*/ true);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800342 }
343 } else {
Andreas Gampe542451c2016-07-26 09:02:02 -0700344 DCHECK_EQ(runtime->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700345
346 constexpr bool kLogInvocationStartAndReturn = false;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800347 bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr;
Elliott Hughes956af0f2014-12-11 14:34:28 -0800348 if (LIKELY(have_quick_code)) {
Jeff Hao790ad902013-05-22 15:02:08 -0700349 if (kLogInvocationStartAndReturn) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700350 LOG(INFO) << StringPrintf(
David Sehr709b0702016-10-13 09:12:37 -0700351 "Invoking '%s' quick code=%p static=%d", PrettyMethod().c_str(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700352 GetEntryPointFromQuickCompiledCode(), static_cast<int>(IsStatic() ? 1 : 0));
Jeff Hao790ad902013-05-22 15:02:08 -0700353 }
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700354
Elliott Hughes956af0f2014-12-11 14:34:28 -0800355 // Ensure that we won't be accidentally calling quick compiled code when -Xint.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800356 if (kIsDebugBuild && runtime->GetInstrumentation()->IsForcedInterpretOnly()) {
Calin Juravleffc87072016-04-20 14:22:09 +0100357 CHECK(!runtime->UseJitCompilation());
Alex Lightdb01a092017-04-03 15:39:55 -0700358 const void* oat_quick_code =
359 (IsNative() || !IsInvokable() || IsProxyMethod() || IsObsolete())
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100360 ? nullptr
361 : GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize());
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100362 CHECK(oat_quick_code == nullptr || oat_quick_code != GetEntryPointFromQuickCompiledCode())
David Sehr709b0702016-10-13 09:12:37 -0700363 << "Don't call compiled code when -Xint " << PrettyMethod();
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700364 }
365
Elliott Hughes956af0f2014-12-11 14:34:28 -0800366 if (!IsStatic()) {
Ian Rogers0177e532014-02-11 16:30:46 -0800367 (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800368 } else {
Elliott Hughes956af0f2014-12-11 14:34:28 -0800369 (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800370 }
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000371 if (UNLIKELY(self->GetException() == Thread::GetDeoptimizationException())) {
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200372 // Unusual case where we were running generated code and an
Jeff Hao790ad902013-05-22 15:02:08 -0700373 // exception was thrown to force the activations to be removed from the
374 // stack. Continue execution in the interpreter.
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000375 self->DeoptimizeWithDeoptimizationException(result);
Jeff Hao790ad902013-05-22 15:02:08 -0700376 }
377 if (kLogInvocationStartAndReturn) {
David Sehr709b0702016-10-13 09:12:37 -0700378 LOG(INFO) << StringPrintf("Returned '%s' quick code=%p", PrettyMethod().c_str(),
Elliott Hughes956af0f2014-12-11 14:34:28 -0800379 GetEntryPointFromQuickCompiledCode());
Jeff Hao5d917302013-02-27 17:57:33 -0800380 }
381 } else {
David Sehr709b0702016-10-13 09:12:37 -0700382 LOG(INFO) << "Not invoking '" << PrettyMethod() << "' code=null";
Ian Rogersf2247512014-12-02 16:17:08 -0800383 if (result != nullptr) {
Jeff Hao5d917302013-02-27 17:57:33 -0800384 result->SetJ(0);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800385 }
386 }
387 }
388
389 // Pop transition.
390 self->PopManagedStackFragment(fragment);
391}
392
Alex Lightd78ddec2017-04-18 15:20:38 -0700393const void* ArtMethod::RegisterNative(const void* native_method, bool is_fast) {
David Sehr709b0702016-10-13 09:12:37 -0700394 CHECK(IsNative()) << PrettyMethod();
395 CHECK(!IsFastNative()) << PrettyMethod();
396 CHECK(native_method != nullptr) << PrettyMethod();
Ian Rogers987560f2014-04-22 11:42:59 -0700397 if (is_fast) {
Mingyao Yang063fc772016-08-02 11:02:54 -0700398 AddAccessFlags(kAccFastNative);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800399 }
Alex Lightd78ddec2017-04-18 15:20:38 -0700400 void* new_native_method = nullptr;
401 Runtime::Current()->GetRuntimeCallbacks()->RegisterNativeMethod(this,
402 native_method,
403 /*out*/&new_native_method);
404 SetEntryPointFromJni(new_native_method);
405 return new_native_method;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800406}
407
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700408void ArtMethod::UnregisterNative() {
David Sehr709b0702016-10-13 09:12:37 -0700409 CHECK(IsNative() && !IsFastNative()) << PrettyMethod();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800410 // restore stub to lookup native pointer via dlsym
Alex Lightd78ddec2017-04-18 15:20:38 -0700411 SetEntryPointFromJni(GetJniDlsymLookupStub());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800412}
413
Alex Light9139e002015-10-09 15:59:48 -0700414bool ArtMethod::IsOverridableByDefaultMethod() {
415 return GetDeclaringClass()->IsInterface();
416}
417
Igor Murashkin9d4b6da2016-07-29 09:51:58 -0700418bool ArtMethod::IsAnnotatedWithFastNative() {
Igor Murashkin367f3dd2016-09-01 17:00:24 -0700419 return IsAnnotatedWith(WellKnownClasses::dalvik_annotation_optimization_FastNative,
Roland Levillain35e42f02017-06-26 18:14:39 +0100420 DexFile::kDexVisibilityBuild,
421 /* lookup_in_resolved_boot_classes */ true);
Igor Murashkin367f3dd2016-09-01 17:00:24 -0700422}
423
424bool ArtMethod::IsAnnotatedWithCriticalNative() {
425 return IsAnnotatedWith(WellKnownClasses::dalvik_annotation_optimization_CriticalNative,
Roland Levillain35e42f02017-06-26 18:14:39 +0100426 DexFile::kDexVisibilityBuild,
427 /* lookup_in_resolved_boot_classes */ true);
Igor Murashkin367f3dd2016-09-01 17:00:24 -0700428}
429
Roland Levillain35e42f02017-06-26 18:14:39 +0100430bool ArtMethod::IsAnnotatedWith(jclass klass,
431 uint32_t visibility,
432 bool lookup_in_resolved_boot_classes) {
Igor Murashkin9d4b6da2016-07-29 09:51:58 -0700433 Thread* self = Thread::Current();
434 ScopedObjectAccess soa(self);
435 StackHandleScope<1> shs(self);
436
Mathieu Chartier0795f232016-09-27 18:43:30 -0700437 ObjPtr<mirror::Class> annotation = soa.Decode<mirror::Class>(klass);
Igor Murashkin367f3dd2016-09-01 17:00:24 -0700438 DCHECK(annotation->IsAnnotation());
439 Handle<mirror::Class> annotation_handle(shs.NewHandle(annotation));
Igor Murashkin9d4b6da2016-07-29 09:51:58 -0700440
Roland Levillain35e42f02017-06-26 18:14:39 +0100441 return annotations::IsMethodAnnotationPresent(
442 this, annotation_handle, visibility, lookup_in_resolved_boot_classes);
Igor Murashkin9d4b6da2016-07-29 09:51:58 -0700443}
444
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100445static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file,
446 uint16_t class_def_idx,
447 uint32_t method_idx) {
448 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
449 const uint8_t* class_data = dex_file.GetClassData(class_def);
450 CHECK(class_data != nullptr);
451 ClassDataItemIterator it(dex_file, class_data);
Mathieu Chartiere17cf242017-06-19 11:05:51 -0700452 it.SkipAllFields();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100453 // Process methods
454 size_t class_def_method_index = 0;
455 while (it.HasNextDirectMethod()) {
456 if (it.GetMemberIndex() == method_idx) {
457 return class_def_method_index;
458 }
459 class_def_method_index++;
460 it.Next();
461 }
462 while (it.HasNextVirtualMethod()) {
463 if (it.GetMemberIndex() == method_idx) {
464 return class_def_method_index;
465 }
466 class_def_method_index++;
467 it.Next();
468 }
469 DCHECK(!it.HasNext());
470 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
471 UNREACHABLE();
472}
473
Alex Lighteee0bd42017-02-14 15:31:45 +0000474// We use the method's DexFile and declaring class name to find the OatMethod for an obsolete
475// method. This is extremely slow but we need it if we want to be able to have obsolete native
476// methods since we need this to find the size of its stack frames.
477//
478// NB We could (potentially) do this differently and rely on the way the transformation is applied
479// in order to use the entrypoint to find this information. However, for debugging reasons (most
480// notably making sure that new invokes of obsolete methods fail) we choose to instead get the data
481// directly from the dex file.
482static const OatFile::OatMethod FindOatMethodFromDexFileFor(ArtMethod* method, bool* found)
483 REQUIRES_SHARED(Locks::mutator_lock_) {
484 DCHECK(method->IsObsolete() && method->IsNative());
485 const DexFile* dex_file = method->GetDexFile();
486
487 // recreate the class_def_index from the descriptor.
488 std::string descriptor_storage;
489 const DexFile::TypeId* declaring_class_type_id =
490 dex_file->FindTypeId(method->GetDeclaringClass()->GetDescriptor(&descriptor_storage));
491 CHECK(declaring_class_type_id != nullptr);
492 dex::TypeIndex declaring_class_type_index = dex_file->GetIndexForTypeId(*declaring_class_type_id);
493 const DexFile::ClassDef* declaring_class_type_def =
494 dex_file->FindClassDef(declaring_class_type_index);
495 CHECK(declaring_class_type_def != nullptr);
496 uint16_t declaring_class_def_index = dex_file->GetIndexForClassDef(*declaring_class_type_def);
497
498 size_t oat_method_index = GetOatMethodIndexFromMethodIndex(*dex_file,
499 declaring_class_def_index,
500 method->GetDexMethodIndex());
501
502 OatFile::OatClass oat_class = OatFile::FindOatClass(*dex_file,
503 declaring_class_def_index,
504 found);
505 if (!(*found)) {
506 return OatFile::OatMethod::Invalid();
507 }
508 return oat_class.GetOatMethod(oat_method_index);
509}
510
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100511static const OatFile::OatMethod FindOatMethodFor(ArtMethod* method,
512 PointerSize pointer_size,
513 bool* found)
514 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Lighteee0bd42017-02-14 15:31:45 +0000515 if (UNLIKELY(method->IsObsolete())) {
516 // We shouldn't be calling this with obsolete methods except for native obsolete methods for
517 // which we need to use the oat method to figure out how large the quick frame is.
518 DCHECK(method->IsNative()) << "We should only be finding the OatMethod of obsolete methods in "
519 << "order to allow stack walking. Other obsolete methods should "
520 << "never need to access this information.";
521 DCHECK_EQ(pointer_size, kRuntimePointerSize) << "Obsolete method in compiler!";
522 return FindOatMethodFromDexFileFor(method, found);
523 }
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100524 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
525 // method for direct methods (or virtual methods made direct).
526 mirror::Class* declaring_class = method->GetDeclaringClass();
527 size_t oat_method_index;
528 if (method->IsStatic() || method->IsDirect()) {
529 // Simple case where the oat method index was stashed at load time.
530 oat_method_index = method->GetMethodIndex();
531 } else {
532 // Compute the oat_method_index by search for its position in the declared virtual methods.
533 oat_method_index = declaring_class->NumDirectMethods();
534 bool found_virtual = false;
535 for (ArtMethod& art_method : declaring_class->GetVirtualMethods(pointer_size)) {
536 // Check method index instead of identity in case of duplicate method definitions.
537 if (method->GetDexMethodIndex() == art_method.GetDexMethodIndex()) {
538 found_virtual = true;
539 break;
540 }
541 oat_method_index++;
542 }
543 CHECK(found_virtual) << "Didn't find oat method index for virtual method: "
David Sehr709b0702016-10-13 09:12:37 -0700544 << method->PrettyMethod();
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100545 }
546 DCHECK_EQ(oat_method_index,
547 GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
548 method->GetDeclaringClass()->GetDexClassDefIndex(),
549 method->GetDexMethodIndex()));
550 OatFile::OatClass oat_class = OatFile::FindOatClass(*declaring_class->GetDexCache()->GetDexFile(),
551 declaring_class->GetDexClassDefIndex(),
552 found);
553 if (!(*found)) {
554 return OatFile::OatMethod::Invalid();
555 }
556 return oat_class.GetOatMethod(oat_method_index);
557}
558
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700559bool ArtMethod::EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params) {
560 auto* dex_cache = GetDexCache();
561 auto* dex_file = dex_cache->GetDexFile();
562 const auto& method_id = dex_file->GetMethodId(GetDexMethodIndex());
563 const auto& proto_id = dex_file->GetMethodPrototype(method_id);
564 const DexFile::TypeList* proto_params = dex_file->GetProtoParameters(proto_id);
565 auto count = proto_params != nullptr ? proto_params->Size() : 0u;
Andreas Gampefa4333d2017-02-14 11:10:34 -0800566 auto param_len = params != nullptr ? params->GetLength() : 0u;
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700567 if (param_len != count) {
568 return false;
569 }
570 auto* cl = Runtime::Current()->GetClassLinker();
571 for (size_t i = 0; i < count; ++i) {
572 auto type_idx = proto_params->GetTypeItem(i).type_idx_;
573 auto* type = cl->ResolveType(type_idx, this);
574 if (type == nullptr) {
575 Thread::Current()->AssertPendingException();
576 return false;
577 }
578 if (type != params->GetWithoutChecks(i)) {
579 return false;
580 }
581 }
582 return true;
583}
584
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100585const uint8_t* ArtMethod::GetQuickenedInfo(PointerSize pointer_size) {
Nicolas Geoffray4acefd32016-10-24 13:14:58 +0100586 if (kIsVdexEnabled) {
Nicolas Geoffrayb02ba932017-07-13 15:53:54 +0100587 const DexFile& dex_file = GetDeclaringClass()->GetDexFile();
588 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
589 if (oat_dex_file == nullptr || (oat_dex_file->GetOatFile() == nullptr)) {
Nicolas Geoffray4acefd32016-10-24 13:14:58 +0100590 return nullptr;
591 }
Nicolas Geoffrayb02ba932017-07-13 15:53:54 +0100592 return oat_dex_file->GetOatFile()->GetVdexFile()->GetQuickenedInfoOf(
593 dex_file, GetCodeItemOffset());
Nicolas Geoffray4acefd32016-10-24 13:14:58 +0100594 } else {
Nicolas Geoffrayb02ba932017-07-13 15:53:54 +0100595 bool found = false;
596 OatFile::OatMethod oat_method = FindOatMethodFor(this, pointer_size, &found);
597 if (!found || (oat_method.GetQuickCode() != nullptr)) {
598 return nullptr;
599 }
Nicolas Geoffray4acefd32016-10-24 13:14:58 +0100600 return oat_method.GetVmapTable();
601 }
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100602}
603
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100604const OatQuickMethodHeader* ArtMethod::GetOatQuickMethodHeader(uintptr_t pc) {
Nicolas Geoffray5a23d2e2015-11-03 18:58:57 +0000605 // Our callers should make sure they don't pass the instrumentation exit pc,
606 // as this method does not look at the side instrumentation stack.
607 DCHECK_NE(pc, reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()));
608
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000609 if (IsRuntimeMethod()) {
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100610 return nullptr;
611 }
612
613 Runtime* runtime = Runtime::Current();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100614 const void* existing_entry_point = GetEntryPointFromQuickCompiledCode();
David Sehr709b0702016-10-13 09:12:37 -0700615 CHECK(existing_entry_point != nullptr) << PrettyMethod() << "@" << this;
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100616 ClassLinker* class_linker = runtime->GetClassLinker();
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100617
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100618 if (class_linker->IsQuickGenericJniStub(existing_entry_point)) {
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100619 // The generic JNI does not have any method header.
620 return nullptr;
621 }
622
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000623 if (existing_entry_point == GetQuickProxyInvokeHandler()) {
624 DCHECK(IsProxyMethod() && !IsConstructor());
625 // The proxy entry point does not have any method header.
626 return nullptr;
627 }
628
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100629 // Check whether the current entry point contains this pc.
630 if (!class_linker->IsQuickResolutionStub(existing_entry_point) &&
631 !class_linker->IsQuickToInterpreterBridge(existing_entry_point)) {
632 OatQuickMethodHeader* method_header =
633 OatQuickMethodHeader::FromEntryPoint(existing_entry_point);
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100634
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100635 if (method_header->Contains(pc)) {
636 return method_header;
637 }
638 }
639
640 // Check whether the pc is in the JIT code cache.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100641 jit::Jit* jit = runtime->GetJit();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100642 if (jit != nullptr) {
643 jit::JitCodeCache* code_cache = jit->GetCodeCache();
644 OatQuickMethodHeader* method_header = code_cache->LookupMethodHeader(pc, this);
645 if (method_header != nullptr) {
646 DCHECK(method_header->Contains(pc));
647 return method_header;
648 } else {
Nicolas Geoffray2a524bd2016-03-01 12:18:47 +0000649 DCHECK(!code_cache->ContainsPc(reinterpret_cast<const void*>(pc)))
David Sehr709b0702016-10-13 09:12:37 -0700650 << PrettyMethod()
Nicolas Geoffray2a524bd2016-03-01 12:18:47 +0000651 << ", pc=" << std::hex << pc
652 << ", entry_point=" << std::hex << reinterpret_cast<uintptr_t>(existing_entry_point)
653 << ", copy=" << std::boolalpha << IsCopied()
654 << ", proxy=" << std::boolalpha << IsProxyMethod();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100655 }
656 }
657
658 // The code has to be in an oat file.
659 bool found;
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100660 OatFile::OatMethod oat_method =
661 FindOatMethodFor(this, class_linker->GetImagePointerSize(), &found);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100662 if (!found) {
Nicolas Geoffray49e43962015-10-28 16:16:16 +0000663 if (class_linker->IsQuickResolutionStub(existing_entry_point)) {
664 // We are running the generic jni stub, but the entry point of the method has not
665 // been updated yet.
Nicolas Geoffray703c2822015-10-30 12:23:16 +0000666 DCHECK_EQ(pc, 0u) << "Should be a downcall";
667 DCHECK(IsNative());
668 return nullptr;
669 }
670 if (existing_entry_point == GetQuickInstrumentationEntryPoint()) {
671 // We are running the generic jni stub, but the method is being instrumented.
Alex Lightb7edcda2017-04-27 13:20:31 -0700672 // NB We would normally expect the pc to be zero but we can have non-zero pc's if
673 // instrumentation is installed or removed during the call which is using the generic jni
674 // trampoline.
Nicolas Geoffray49e43962015-10-28 16:16:16 +0000675 DCHECK(IsNative());
676 return nullptr;
677 }
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100678 // Only for unit tests.
679 // TODO(ngeoffray): Update these tests to pass the right pc?
680 return OatQuickMethodHeader::FromEntryPoint(existing_entry_point);
681 }
682 const void* oat_entry_point = oat_method.GetQuickCode();
683 if (oat_entry_point == nullptr || class_linker->IsQuickGenericJniStub(oat_entry_point)) {
David Sehr709b0702016-10-13 09:12:37 -0700684 DCHECK(IsNative()) << PrettyMethod();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100685 return nullptr;
686 }
687
688 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromEntryPoint(oat_entry_point);
689 if (pc == 0) {
690 // This is a downcall, it can only happen for a native method.
691 DCHECK(IsNative());
692 return method_header;
693 }
694
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100695 DCHECK(method_header->Contains(pc))
David Sehr709b0702016-10-13 09:12:37 -0700696 << PrettyMethod()
Roland Levillain0b671c02016-08-19 12:02:34 +0100697 << " " << std::hex << pc << " " << oat_entry_point
Mingyao Yang063fc772016-08-02 11:02:54 -0700698 << " " << (uintptr_t)(method_header->GetCode() + method_header->GetCodeSize());
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100699 return method_header;
700}
701
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100702const void* ArtMethod::GetOatMethodQuickCode(PointerSize pointer_size) {
703 bool found;
704 OatFile::OatMethod oat_method = FindOatMethodFor(this, pointer_size, &found);
705 if (found) {
706 return oat_method.GetQuickCode();
707 }
708 return nullptr;
709}
710
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000711bool ArtMethod::HasAnyCompiledCode() {
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100712 if (IsNative() || !IsInvokable() || IsProxyMethod()) {
713 return false;
714 }
715
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000716 // Check whether the JIT has compiled it.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100717 Runtime* runtime = Runtime::Current();
718 jit::Jit* jit = runtime->GetJit();
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000719 if (jit != nullptr && jit->GetCodeCache()->ContainsMethod(this)) {
720 return true;
721 }
722
723 // Check whether we have AOT code.
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100724 return GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize()) != nullptr;
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000725}
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000726
Andreas Gampe542451c2016-07-26 09:02:02 -0700727void ArtMethod::CopyFrom(ArtMethod* src, PointerSize image_pointer_size) {
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000728 memcpy(reinterpret_cast<void*>(this), reinterpret_cast<const void*>(src),
729 Size(image_pointer_size));
730 declaring_class_ = GcRoot<mirror::Class>(const_cast<ArtMethod*>(src)->GetDeclaringClass());
731
732 // If the entry point of the method we are copying from is from JIT code, we just
733 // put the entry point of the new method to interpreter. We could set the entry point
734 // to the JIT code, but this would require taking the JIT code cache lock to notify
735 // it, which we do not want at this level.
736 Runtime* runtime = Runtime::Current();
Calin Juravleffc87072016-04-20 14:22:09 +0100737 if (runtime->UseJitCompilation()) {
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000738 if (runtime->GetJit()->GetCodeCache()->ContainsPc(GetEntryPointFromQuickCompiledCode())) {
739 SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(), image_pointer_size);
740 }
741 }
742 // Clear the profiling info for the same reasons as the JIT code.
743 if (!src->IsNative()) {
744 SetProfilingInfoPtrSize(nullptr, image_pointer_size);
745 }
746 // Clear hotness to let the JIT properly decide when to compile this method.
747 hotness_count_ = 0;
748}
749
Andreas Gampe542451c2016-07-26 09:02:02 -0700750bool ArtMethod::IsImagePointerSize(PointerSize pointer_size) {
Andreas Gampe479b1de2016-07-19 18:27:17 -0700751 // Hijack this function to get access to PtrSizedFieldsOffset.
752 //
753 // Ensure that PrtSizedFieldsOffset is correct. We rely here on usually having both 32-bit and
754 // 64-bit builds.
755 static_assert(std::is_standard_layout<ArtMethod>::value, "ArtMethod is not standard layout.");
Andreas Gampe542451c2016-07-26 09:02:02 -0700756 static_assert(
757 (sizeof(void*) != 4) ||
758 (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k32)),
759 "Unexpected 32-bit class layout.");
760 static_assert(
761 (sizeof(void*) != 8) ||
762 (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k64)),
763 "Unexpected 64-bit class layout.");
Andreas Gampe479b1de2016-07-19 18:27:17 -0700764
Andreas Gampe75f08852016-07-19 08:06:07 -0700765 Runtime* runtime = Runtime::Current();
766 if (runtime == nullptr) {
767 return true;
768 }
769 return runtime->GetClassLinker()->GetImagePointerSize() == pointer_size;
770}
771
David Sehr709b0702016-10-13 09:12:37 -0700772std::string ArtMethod::PrettyMethod(ArtMethod* m, bool with_signature) {
773 if (m == nullptr) {
774 return "null";
775 }
776 return m->PrettyMethod(with_signature);
777}
778
779std::string ArtMethod::PrettyMethod(bool with_signature) {
780 ArtMethod* m = this;
781 if (!m->IsRuntimeMethod()) {
782 m = m->GetInterfaceMethodIfProxy(Runtime::Current()->GetClassLinker()->GetImagePointerSize());
783 }
784 std::string result(PrettyDescriptor(m->GetDeclaringClassDescriptor()));
785 result += '.';
786 result += m->GetName();
787 if (UNLIKELY(m->IsFastNative())) {
788 result += "!";
789 }
790 if (with_signature) {
791 const Signature signature = m->GetSignature();
792 std::string sig_as_string(signature.ToString());
793 if (signature == Signature::NoSignature()) {
794 return result + sig_as_string;
795 }
796 result = PrettyReturnType(sig_as_string.c_str()) + " " + result +
797 PrettyArguments(sig_as_string.c_str());
798 }
799 return result;
800}
801
802std::string ArtMethod::JniShortName() {
Alex Light888a59e2017-01-25 11:41:41 -0800803 return GetJniShortName(GetDeclaringClassDescriptor(), GetName());
David Sehr709b0702016-10-13 09:12:37 -0700804}
805
806std::string ArtMethod::JniLongName() {
807 std::string long_name;
808 long_name += JniShortName();
809 long_name += "__";
810
811 std::string signature(GetSignature().ToString());
812 signature.erase(0, 1);
813 signature.erase(signature.begin() + signature.find(')'), signature.end());
814
815 long_name += MangleForJni(signature);
816
817 return long_name;
818}
819
Andreas Gampec6ea7d02017-02-01 16:46:28 -0800820// AssertSharedHeld doesn't work in GetAccessFlags, so use a NO_THREAD_SAFETY_ANALYSIS helper.
821// TODO: Figure out why ASSERT_SHARED_CAPABILITY doesn't work.
822template <ReadBarrierOption kReadBarrierOption>
823ALWAYS_INLINE static inline void DoGetAccessFlagsHelper(ArtMethod* method)
824 NO_THREAD_SAFETY_ANALYSIS {
825 CHECK(method->IsRuntimeMethod() ||
826 method->GetDeclaringClass<kReadBarrierOption>()->IsIdxLoaded() ||
827 method->GetDeclaringClass<kReadBarrierOption>()->IsErroneous());
828}
829
830template <ReadBarrierOption kReadBarrierOption> void ArtMethod::GetAccessFlagsDCheck() {
831 if (kCheckDeclaringClassState) {
832 Thread* self = Thread::Current();
833 if (!Locks::mutator_lock_->IsSharedHeld(self)) {
834 if (self->IsThreadSuspensionAllowable()) {
835 ScopedObjectAccess soa(self);
836 CHECK(IsRuntimeMethod() ||
837 GetDeclaringClass<kReadBarrierOption>()->IsIdxLoaded() ||
838 GetDeclaringClass<kReadBarrierOption>()->IsErroneous());
839 }
840 } else {
841 // We cannot use SOA in this case. We might be holding the lock, but may not be in the
842 // runnable state (e.g., during GC).
843 Locks::mutator_lock_->AssertSharedHeld(self);
844 DoGetAccessFlagsHelper<kReadBarrierOption>(this);
845 }
846 }
847}
848template void ArtMethod::GetAccessFlagsDCheck<ReadBarrierOption::kWithReadBarrier>();
849template void ArtMethod::GetAccessFlagsDCheck<ReadBarrierOption::kWithoutReadBarrier>();
850
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800851} // namespace art