blob: cd38e16cf72ea258f5ab92eab2d5a2211e321d39 [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
Ian Rogerse63db272014-07-15 15:36:11 -070019#include "arch/context.h"
Ian Rogers62f05122014-03-21 11:21:29 -070020#include "art_field-inl.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070021#include "art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080022#include "base/stringpiece.h"
Hiroshi Yamauchi00370822015-08-18 14:47:25 -070023#include "class_linker-inl.h"
Andreas Gampe2a5c4682015-08-14 08:22:54 -070024#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070025#include "dex_file-inl.h"
Ian Rogersc449aa82013-07-29 14:35:46 -070026#include "dex_instruction.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070027#include "entrypoints/runtime_asm_entrypoints.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070028#include "gc/accounting/card_table-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080029#include "interpreter/interpreter.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080030#include "jit/jit.h"
31#include "jit/jit_code_cache.h"
Nicolas Geoffray5550ca82015-08-21 18:38:30 +010032#include "jit/profiling_info.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080033#include "jni_internal.h"
Ian Rogers1809a722013-08-09 22:05:32 -070034#include "mapping_table.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070035#include "mirror/abstract_method.h"
36#include "mirror/class-inl.h"
37#include "mirror/object_array-inl.h"
38#include "mirror/object-inl.h"
39#include "mirror/string.h"
Nicolas Geoffray9523a3e2015-07-17 11:51:28 +000040#include "oat_file-inl.h"
Ian Rogers62f05122014-03-21 11:21:29 -070041#include "scoped_thread_state_change.h"
Ian Rogers62f05122014-03-21 11:21:29 -070042#include "well_known_classes.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043
44namespace art {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080045
Ian Rogers0177e532014-02-11 16:30:46 -080046extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
47 const char*);
Ian Rogers936b37f2014-02-14 00:52:24 -080048extern "C" void art_quick_invoke_static_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
49 const char*);
Jeff Hao5d917302013-02-27 17:57:33 -080050
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070051ArtMethod* ArtMethod::FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa,
52 jobject jlr_method) {
Mathieu Chartierfc58af42015-04-16 18:00:39 -070053 auto* abstract_method = soa.Decode<mirror::AbstractMethod*>(jlr_method);
54 DCHECK(abstract_method != nullptr);
55 return abstract_method->GetArtMethod();
Ian Rogers62f05122014-03-21 11:21:29 -070056}
57
Ian Rogers6b14d552014-10-28 21:50:58 -070058mirror::String* ArtMethod::GetNameAsString(Thread* self) {
Mathieu Chartiere401d142015-04-22 13:56:20 -070059 CHECK(!IsProxyMethod());
Ian Rogers6b14d552014-10-28 21:50:58 -070060 StackHandleScope<1> hs(self);
Mathieu Chartiere401d142015-04-22 13:56:20 -070061 Handle<mirror::DexCache> dex_cache(hs.NewHandle(GetDexCache()));
62 auto* dex_file = dex_cache->GetDexFile();
63 uint32_t dex_method_idx = GetDexMethodIndex();
64 const DexFile::MethodId& method_id = dex_file->GetMethodId(dex_method_idx);
Ian Rogers6b14d552014-10-28 21:50:58 -070065 return Runtime::Current()->GetClassLinker()->ResolveString(*dex_file, method_id.name_idx_,
66 dex_cache);
67}
68
Alex Light9139e002015-10-09 15:59:48 -070069void ArtMethod::ThrowInvocationTimeError() {
70 DCHECK(!IsInvokable());
71 // NOTE: IsDefaultConflicting must be first since the actual method might or might not be abstract
72 // due to the way we select it.
73 if (IsDefaultConflicting()) {
74 ThrowIncompatibleClassChangeErrorForMethodConflict(this);
75 } else {
76 DCHECK(IsAbstract());
77 ThrowAbstractMethodError(this);
78 }
79}
80
Ian Rogersef7d42f2014-01-06 12:55:46 -080081InvokeType ArtMethod::GetInvokeType() {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080082 // TODO: kSuper?
83 if (GetDeclaringClass()->IsInterface()) {
84 return kInterface;
85 } else if (IsStatic()) {
86 return kStatic;
87 } else if (IsDirect()) {
88 return kDirect;
89 } else {
90 return kVirtual;
91 }
92}
93
Brian Carlstromea46f952013-07-30 01:26:50 -070094size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) {
Ian Rogers6b604a12014-09-25 15:35:37 -070095 CHECK_LE(1U, shorty.length());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080096 uint32_t num_registers = 0;
Ian Rogers6b604a12014-09-25 15:35:37 -070097 for (size_t i = 1; i < shorty.length(); ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080098 char ch = shorty[i];
99 if (ch == 'D' || ch == 'J') {
100 num_registers += 2;
101 } else {
102 num_registers += 1;
103 }
104 }
105 return num_registers;
106}
107
Alex Light6c8467f2015-11-20 15:03:26 -0800108bool ArtMethod::HasSameNameAndSignature(ArtMethod* other) {
Ian Rogersf2247512014-12-02 16:17:08 -0800109 ScopedAssertNoThreadSuspension ants(Thread::Current(), "HasSameNameAndSignature");
Alex Light6c8467f2015-11-20 15:03:26 -0800110 const DexFile* dex_file = GetDexFile();
111 const DexFile::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex());
112 if (GetDexCache() == other->GetDexCache()) {
113 const DexFile::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex());
Ian Rogersf2247512014-12-02 16:17:08 -0800114 return mid.name_idx_ == mid2.name_idx_ && mid.proto_idx_ == mid2.proto_idx_;
115 }
Alex Light6c8467f2015-11-20 15:03:26 -0800116 const DexFile* dex_file2 = other->GetDexFile();
117 const DexFile::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex());
Ian Rogersf2247512014-12-02 16:17:08 -0800118 if (!DexFileStringEquals(dex_file, mid.name_idx_, dex_file2, mid2.name_idx_)) {
119 return false; // Name mismatch.
120 }
121 return dex_file->GetMethodSignature(mid) == dex_file2->GetMethodSignature(mid2);
122}
123
Mathieu Chartiere401d142015-04-22 13:56:20 -0700124ArtMethod* ArtMethod::FindOverriddenMethod(size_t pointer_size) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800125 if (IsStatic()) {
Ian Rogersf2247512014-12-02 16:17:08 -0800126 return nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800127 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700128 mirror::Class* declaring_class = GetDeclaringClass();
129 mirror::Class* super_class = declaring_class->GetSuperClass();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800130 uint16_t method_index = GetMethodIndex();
Ian Rogersf2247512014-12-02 16:17:08 -0800131 ArtMethod* result = nullptr;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800132 // Did this method override a super class method? If so load the result from the super class'
133 // vtable
Mingyao Yang2cdbad72014-07-16 10:44:41 -0700134 if (super_class->HasVTable() && method_index < super_class->GetVTableLength()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700135 result = super_class->GetVTableEntry(method_index, pointer_size);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800136 } else {
137 // Method didn't override superclass method so search interfaces
138 if (IsProxyMethod()) {
Vladimir Marko05792b92015-08-03 11:56:49 +0100139 result = mirror::DexCache::GetElementPtrSize(GetDexCacheResolvedMethods(pointer_size),
140 GetDexMethodIndex(),
141 pointer_size);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800142 CHECK_EQ(result,
143 Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
144 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700145 mirror::IfTable* iftable = GetDeclaringClass()->GetIfTable();
Ian Rogersf2247512014-12-02 16:17:08 -0800146 for (size_t i = 0; i < iftable->Count() && result == nullptr; i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700147 mirror::Class* interface = iftable->GetInterface(i);
Alex Light51a64d52015-12-17 13:55:59 -0800148 for (ArtMethod& interface_method : interface->GetVirtualMethods(pointer_size)) {
149 if (HasSameNameAndSignature(interface_method.GetInterfaceMethodIfProxy(pointer_size))) {
150 result = &interface_method;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800151 break;
152 }
153 }
154 }
155 }
156 }
Alex Light6c8467f2015-11-20 15:03:26 -0800157 DCHECK(result == nullptr ||
Alex Light51a64d52015-12-17 13:55:59 -0800158 GetInterfaceMethodIfProxy(pointer_size)->HasSameNameAndSignature(
159 result->GetInterfaceMethodIfProxy(pointer_size)));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800160 return result;
161}
162
Ian Rogerse0a02da2014-12-02 14:10:53 -0800163uint32_t ArtMethod::FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile,
164 uint32_t name_and_signature_idx) {
165 const DexFile* dexfile = GetDexFile();
166 const uint32_t dex_method_idx = GetDexMethodIndex();
167 const DexFile::MethodId& mid = dexfile->GetMethodId(dex_method_idx);
168 const DexFile::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx);
169 DCHECK_STREQ(dexfile->GetMethodName(mid), other_dexfile.GetMethodName(name_and_sig_mid));
170 DCHECK_EQ(dexfile->GetMethodSignature(mid), other_dexfile.GetMethodSignature(name_and_sig_mid));
171 if (dexfile == &other_dexfile) {
172 return dex_method_idx;
173 }
174 const char* mid_declaring_class_descriptor = dexfile->StringByTypeIdx(mid.class_idx_);
Mathieu Chartier9507fa22015-10-29 15:08:57 -0700175 const DexFile::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor);
176 if (other_type_id != nullptr) {
177 const DexFile::MethodId* other_mid = other_dexfile.FindMethodId(
178 *other_type_id, other_dexfile.GetStringId(name_and_sig_mid.name_idx_),
179 other_dexfile.GetProtoId(name_and_sig_mid.proto_idx_));
180 if (other_mid != nullptr) {
181 return other_dexfile.GetIndexForMethodId(*other_mid);
Ian Rogerse0a02da2014-12-02 14:10:53 -0800182 }
183 }
184 return DexFile::kDexNoIndex;
185}
186
Mathieu Chartiere401d142015-04-22 13:56:20 -0700187uint32_t ArtMethod::FindCatchBlock(Handle<mirror::Class> exception_type,
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700188 uint32_t dex_pc, bool* has_no_move_exception) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700189 const DexFile::CodeItem* code_item = GetCodeItem();
Jeff Haoaa961912014-04-22 13:54:32 -0700190 // Set aside the exception while we resolve its type.
191 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700192 StackHandleScope<1> hs(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000193 Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException()));
Jeff Haoaa961912014-04-22 13:54:32 -0700194 self->ClearException();
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700195 // Default to handler not found.
196 uint32_t found_dex_pc = DexFile::kDexNoIndex;
197 // Iterate over the catch handlers associated with dex_pc.
Vladimir Marko05792b92015-08-03 11:56:49 +0100198 size_t pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800199 for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
200 uint16_t iter_type_idx = it.GetHandlerTypeIndex();
201 // Catch all case
202 if (iter_type_idx == DexFile::kDexNoIndex16) {
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700203 found_dex_pc = it.GetHandlerAddress();
204 break;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800205 }
206 // Does this catch exception type apply?
Vladimir Marko05792b92015-08-03 11:56:49 +0100207 mirror::Class* iter_exception_type = GetClassFromTypeIndex(iter_type_idx,
208 true /* resolve */,
209 pointer_size);
Ian Rogers822266b2014-05-29 16:55:06 -0700210 if (UNLIKELY(iter_exception_type == nullptr)) {
211 // Now have a NoClassDefFoundError as exception. Ignore in case the exception class was
212 // removed by a pro-guard like tool.
Andreas Gampe72b3e432014-05-13 21:42:05 -0700213 // Note: this is not RI behavior. RI would have failed when loading the class.
Ian Rogers822266b2014-05-29 16:55:06 -0700214 self->ClearException();
215 // Delete any long jump context as this routine is called during a stack walk which will
216 // release its in use context at the end.
217 delete self->GetLongJumpContext();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800218 LOG(WARNING) << "Unresolved exception class when finding catch block: "
Mathieu Chartiere401d142015-04-22 13:56:20 -0700219 << DescriptorToDot(GetTypeDescriptorFromTypeIdx(iter_type_idx));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700220 } else if (iter_exception_type->IsAssignableFrom(exception_type.Get())) {
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700221 found_dex_pc = it.GetHandlerAddress();
222 break;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800223 }
224 }
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700225 if (found_dex_pc != DexFile::kDexNoIndex) {
226 const Instruction* first_catch_instr =
Jeff Haoaa961912014-04-22 13:54:32 -0700227 Instruction::At(&code_item->insns_[found_dex_pc]);
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700228 *has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION);
229 }
Jeff Haoaa961912014-04-22 13:54:32 -0700230 // Put the exception back.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700231 if (exception.Get() != nullptr) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000232 self->SetException(exception.Get());
Jeff Haoaa961912014-04-22 13:54:32 -0700233 }
Ian Rogers9e8f45e2013-07-31 10:58:53 -0700234 return found_dex_pc;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800235}
236
Brian Carlstromea46f952013-07-30 01:26:50 -0700237void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
Ian Rogers0177e532014-02-11 16:30:46 -0800238 const char* shorty) {
Dave Allison648d7112014-07-25 16:15:27 -0700239 if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) {
240 ThrowStackOverflowError(self);
241 return;
242 }
243
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800244 if (kIsDebugBuild) {
245 self->AssertThreadSuspensionIsAllowable();
246 CHECK_EQ(kRunnable, self->GetState());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700247 CHECK_STREQ(GetInterfaceMethodIfProxy(sizeof(void*))->GetShorty(), shorty);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800248 }
249
250 // Push a transition back into managed code onto the linked list in thread.
251 ManagedStack fragment;
252 self->PushManagedStackFragment(&fragment);
253
Ian Rogers62d6c772013-02-27 08:32:07 -0800254 Runtime* runtime = Runtime::Current();
Jeff Hao74180ca2013-03-27 15:29:11 -0700255 // Call the invoke stub, passing everything as arguments.
Daniel Mihalyieb076692014-08-22 17:33:31 +0200256 // If the runtime is not yet started or it is required by the debugger, then perform the
257 // Invocation by the interpreter.
258 if (UNLIKELY(!runtime->IsStarted() || Dbg::IsForcedInterpreterNeededForCalling(self, this))) {
Ian Rogers5d27faf2014-05-02 17:17:18 -0700259 if (IsStatic()) {
260 art::interpreter::EnterInterpreterFromInvoke(self, this, nullptr, args, result);
261 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700262 mirror::Object* receiver =
263 reinterpret_cast<StackReference<mirror::Object>*>(&args[0])->AsMirrorPtr();
Ian Rogers5d27faf2014-05-02 17:17:18 -0700264 art::interpreter::EnterInterpreterFromInvoke(self, this, receiver, args + 1, result);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800265 }
266 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700267 DCHECK_EQ(runtime->GetClassLinker()->GetImagePointerSize(), sizeof(void*));
268
269 constexpr bool kLogInvocationStartAndReturn = false;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800270 bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr;
Elliott Hughes956af0f2014-12-11 14:34:28 -0800271 if (LIKELY(have_quick_code)) {
Jeff Hao790ad902013-05-22 15:02:08 -0700272 if (kLogInvocationStartAndReturn) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700273 LOG(INFO) << StringPrintf(
274 "Invoking '%s' quick code=%p static=%d", PrettyMethod(this).c_str(),
275 GetEntryPointFromQuickCompiledCode(), static_cast<int>(IsStatic() ? 1 : 0));
Jeff Hao790ad902013-05-22 15:02:08 -0700276 }
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700277
Elliott Hughes956af0f2014-12-11 14:34:28 -0800278 // Ensure that we won't be accidentally calling quick compiled code when -Xint.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800279 if (kIsDebugBuild && runtime->GetInstrumentation()->IsForcedInterpretOnly()) {
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100280 CHECK(!runtime->UseJit());
281 const void* oat_quick_code = runtime->GetClassLinker()->GetOatMethodQuickCodeFor(this);
282 CHECK(oat_quick_code == nullptr || oat_quick_code != GetEntryPointFromQuickCompiledCode())
Hiroshi Yamauchi9bdec882014-08-15 17:11:12 -0700283 << "Don't call compiled code when -Xint " << PrettyMethod(this);
284 }
285
Elliott Hughes956af0f2014-12-11 14:34:28 -0800286 if (!IsStatic()) {
Ian Rogers0177e532014-02-11 16:30:46 -0800287 (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800288 } else {
Elliott Hughes956af0f2014-12-11 14:34:28 -0800289 (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800290 }
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000291 if (UNLIKELY(self->GetException() == Thread::GetDeoptimizationException())) {
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200292 // Unusual case where we were running generated code and an
Jeff Hao790ad902013-05-22 15:02:08 -0700293 // exception was thrown to force the activations to be removed from the
294 // stack. Continue execution in the interpreter.
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000295 self->DeoptimizeWithDeoptimizationException(result);
Jeff Hao790ad902013-05-22 15:02:08 -0700296 }
297 if (kLogInvocationStartAndReturn) {
Elliott Hughes956af0f2014-12-11 14:34:28 -0800298 LOG(INFO) << StringPrintf("Returned '%s' quick code=%p", PrettyMethod(this).c_str(),
299 GetEntryPointFromQuickCompiledCode());
Jeff Hao5d917302013-02-27 17:57:33 -0800300 }
301 } else {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800302 LOG(INFO) << "Not invoking '" << PrettyMethod(this) << "' code=null";
Ian Rogersf2247512014-12-02 16:17:08 -0800303 if (result != nullptr) {
Jeff Hao5d917302013-02-27 17:57:33 -0800304 result->SetJ(0);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800305 }
306 }
307 }
308
309 // Pop transition.
310 self->PopManagedStackFragment(fragment);
311}
312
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700313void ArtMethod::RegisterNative(const void* native_method, bool is_fast) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800314 CHECK(IsNative()) << PrettyMethod(this);
Ian Rogers1eb512d2013-10-18 15:42:20 -0700315 CHECK(!IsFastNative()) << PrettyMethod(this);
Ian Rogersf2247512014-12-02 16:17:08 -0800316 CHECK(native_method != nullptr) << PrettyMethod(this);
Ian Rogers987560f2014-04-22 11:42:59 -0700317 if (is_fast) {
318 SetAccessFlags(GetAccessFlags() | kAccFastNative);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800319 }
Mathieu Chartier2d721012014-11-10 11:08:06 -0800320 SetEntryPointFromJni(native_method);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800321}
322
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700323void ArtMethod::UnregisterNative() {
Ian Rogers1eb512d2013-10-18 15:42:20 -0700324 CHECK(IsNative() && !IsFastNative()) << PrettyMethod(this);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800325 // restore stub to lookup native pointer via dlsym
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700326 RegisterNative(GetJniDlsymLookupStub(), false);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800327}
328
Alex Light9139e002015-10-09 15:59:48 -0700329bool ArtMethod::IsOverridableByDefaultMethod() {
330 return GetDeclaringClass()->IsInterface();
331}
332
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700333bool ArtMethod::EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params) {
334 auto* dex_cache = GetDexCache();
335 auto* dex_file = dex_cache->GetDexFile();
336 const auto& method_id = dex_file->GetMethodId(GetDexMethodIndex());
337 const auto& proto_id = dex_file->GetMethodPrototype(method_id);
338 const DexFile::TypeList* proto_params = dex_file->GetProtoParameters(proto_id);
339 auto count = proto_params != nullptr ? proto_params->Size() : 0u;
340 auto param_len = params.Get() != nullptr ? params->GetLength() : 0u;
341 if (param_len != count) {
342 return false;
343 }
344 auto* cl = Runtime::Current()->GetClassLinker();
345 for (size_t i = 0; i < count; ++i) {
346 auto type_idx = proto_params->GetTypeItem(i).type_idx_;
347 auto* type = cl->ResolveType(type_idx, this);
348 if (type == nullptr) {
349 Thread::Current()->AssertPendingException();
350 return false;
351 }
352 if (type != params->GetWithoutChecks(i)) {
353 return false;
354 }
355 }
356 return true;
357}
358
Nicolas Geoffray6bc43742015-10-12 18:11:10 +0100359const uint8_t* ArtMethod::GetQuickenedInfo() {
360 bool found = false;
361 OatFile::OatMethod oat_method =
362 Runtime::Current()->GetClassLinker()->FindOatMethodFor(this, &found);
363 if (!found || (oat_method.GetQuickCode() != nullptr)) {
364 return nullptr;
365 }
366 return oat_method.GetVmapTable();
367}
368
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100369const OatQuickMethodHeader* ArtMethod::GetOatQuickMethodHeader(uintptr_t pc) {
Nicolas Geoffray5a23d2e2015-11-03 18:58:57 +0000370 // Our callers should make sure they don't pass the instrumentation exit pc,
371 // as this method does not look at the side instrumentation stack.
372 DCHECK_NE(pc, reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()));
373
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000374 if (IsRuntimeMethod()) {
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100375 return nullptr;
376 }
377
378 Runtime* runtime = Runtime::Current();
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100379 const void* existing_entry_point = GetEntryPointFromQuickCompiledCode();
380 DCHECK(existing_entry_point != nullptr);
381 ClassLinker* class_linker = runtime->GetClassLinker();
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100382
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100383 if (class_linker->IsQuickGenericJniStub(existing_entry_point)) {
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100384 // The generic JNI does not have any method header.
385 return nullptr;
386 }
387
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000388 if (existing_entry_point == GetQuickProxyInvokeHandler()) {
389 DCHECK(IsProxyMethod() && !IsConstructor());
390 // The proxy entry point does not have any method header.
391 return nullptr;
392 }
393
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100394 // Check whether the current entry point contains this pc.
395 if (!class_linker->IsQuickResolutionStub(existing_entry_point) &&
396 !class_linker->IsQuickToInterpreterBridge(existing_entry_point)) {
397 OatQuickMethodHeader* method_header =
398 OatQuickMethodHeader::FromEntryPoint(existing_entry_point);
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100399
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100400 if (method_header->Contains(pc)) {
401 return method_header;
402 }
403 }
404
405 // Check whether the pc is in the JIT code cache.
406 jit::Jit* jit = Runtime::Current()->GetJit();
407 if (jit != nullptr) {
408 jit::JitCodeCache* code_cache = jit->GetCodeCache();
409 OatQuickMethodHeader* method_header = code_cache->LookupMethodHeader(pc, this);
410 if (method_header != nullptr) {
411 DCHECK(method_header->Contains(pc));
412 return method_header;
413 } else {
414 DCHECK(!code_cache->ContainsPc(reinterpret_cast<const void*>(pc))) << std::hex << pc;
415 }
416 }
417
418 // The code has to be in an oat file.
419 bool found;
420 OatFile::OatMethod oat_method = class_linker->FindOatMethodFor(this, &found);
421 if (!found) {
Nicolas Geoffray49e43962015-10-28 16:16:16 +0000422 if (class_linker->IsQuickResolutionStub(existing_entry_point)) {
423 // We are running the generic jni stub, but the entry point of the method has not
424 // been updated yet.
Nicolas Geoffray703c2822015-10-30 12:23:16 +0000425 DCHECK_EQ(pc, 0u) << "Should be a downcall";
426 DCHECK(IsNative());
427 return nullptr;
428 }
429 if (existing_entry_point == GetQuickInstrumentationEntryPoint()) {
430 // We are running the generic jni stub, but the method is being instrumented.
431 DCHECK_EQ(pc, 0u) << "Should be a downcall";
Nicolas Geoffray49e43962015-10-28 16:16:16 +0000432 DCHECK(IsNative());
433 return nullptr;
434 }
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100435 // Only for unit tests.
436 // TODO(ngeoffray): Update these tests to pass the right pc?
437 return OatQuickMethodHeader::FromEntryPoint(existing_entry_point);
438 }
439 const void* oat_entry_point = oat_method.GetQuickCode();
440 if (oat_entry_point == nullptr || class_linker->IsQuickGenericJniStub(oat_entry_point)) {
Nicolas Geoffray5a23d2e2015-11-03 18:58:57 +0000441 DCHECK(IsNative()) << PrettyMethod(this);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100442 return nullptr;
443 }
444
445 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromEntryPoint(oat_entry_point);
446 if (pc == 0) {
447 // This is a downcall, it can only happen for a native method.
448 DCHECK(IsNative());
449 return method_header;
450 }
451
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100452 DCHECK(method_header->Contains(pc))
453 << PrettyMethod(this)
454 << std::hex << pc << " " << oat_entry_point
455 << " " << (uintptr_t)(method_header->code_ + method_header->code_size_);
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100456 return method_header;
457}
458
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000459bool ArtMethod::HasAnyCompiledCode() {
460 // Check whether the JIT has compiled it.
461 jit::Jit* jit = Runtime::Current()->GetJit();
462 if (jit != nullptr && jit->GetCodeCache()->ContainsMethod(this)) {
463 return true;
464 }
465
466 // Check whether we have AOT code.
467 return Runtime::Current()->GetClassLinker()->GetOatMethodQuickCodeFor(this) != nullptr;
468}
Nicolas Geoffray22cf3d32015-11-02 11:57:11 +0000469
470void ArtMethod::CopyFrom(ArtMethod* src, size_t image_pointer_size) {
471 memcpy(reinterpret_cast<void*>(this), reinterpret_cast<const void*>(src),
472 Size(image_pointer_size));
473 declaring_class_ = GcRoot<mirror::Class>(const_cast<ArtMethod*>(src)->GetDeclaringClass());
474
475 // If the entry point of the method we are copying from is from JIT code, we just
476 // put the entry point of the new method to interpreter. We could set the entry point
477 // to the JIT code, but this would require taking the JIT code cache lock to notify
478 // it, which we do not want at this level.
479 Runtime* runtime = Runtime::Current();
480 if (runtime->GetJit() != nullptr) {
481 if (runtime->GetJit()->GetCodeCache()->ContainsPc(GetEntryPointFromQuickCompiledCode())) {
482 SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(), image_pointer_size);
483 }
484 }
485 // Clear the profiling info for the same reasons as the JIT code.
486 if (!src->IsNative()) {
487 SetProfilingInfoPtrSize(nullptr, image_pointer_size);
488 }
489 // Clear hotness to let the JIT properly decide when to compile this method.
490 hotness_count_ = 0;
491}
492
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800493} // namespace art