1 /* 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 17 #include "art_method.h" 18 19 #include <cstddef> 20 21 #include "android-base/stringprintf.h" 22 23 #include "arch/context.h" 24 #include "art_method-inl.h" 25 #include "class_linker-inl.h" 26 #include "class_root.h" 27 #include "debugger.h" 28 #include "dex/class_accessor-inl.h" 29 #include "dex/descriptors_names.h" 30 #include "dex/dex_file-inl.h" 31 #include "dex/dex_file_exception_helpers.h" 32 #include "dex/dex_instruction.h" 33 #include "dex/signature-inl.h" 34 #include "entrypoints/runtime_asm_entrypoints.h" 35 #include "gc/accounting/card_table-inl.h" 36 #include "hidden_api.h" 37 #include "interpreter/interpreter.h" 38 #include "jit/jit.h" 39 #include "jit/jit_code_cache.h" 40 #include "jit/profiling_info.h" 41 #include "jni/jni_internal.h" 42 #include "mirror/class-inl.h" 43 #include "mirror/class_ext-inl.h" 44 #include "mirror/executable.h" 45 #include "mirror/object-inl.h" 46 #include "mirror/object_array-inl.h" 47 #include "mirror/string.h" 48 #include "oat_file-inl.h" 49 #include "quicken_info.h" 50 #include "runtime_callbacks.h" 51 #include "scoped_thread_state_change-inl.h" 52 #include "vdex_file.h" 53 54 namespace art { 55 56 using android::base::StringPrintf; 57 58 extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, 59 const char*); 60 extern "C" void art_quick_invoke_static_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, 61 const char*); 62 63 // Enforce that we he have the right index for runtime methods. 64 static_assert(ArtMethod::kRuntimeMethodDexMethodIndex == dex::kDexNoIndex, 65 "Wrong runtime-method dex method index"); 66 67 ArtMethod* ArtMethod::GetCanonicalMethod(PointerSize pointer_size) { 68 if (LIKELY(!IsDefault())) { 69 return this; 70 } else { 71 ObjPtr<mirror::Class> declaring_class = GetDeclaringClass(); 72 DCHECK(declaring_class->IsInterface()); 73 ArtMethod* ret = declaring_class->FindInterfaceMethod(GetDexCache(), 74 GetDexMethodIndex(), 75 pointer_size); 76 DCHECK(ret != nullptr); 77 return ret; 78 } 79 } 80 81 ArtMethod* ArtMethod::GetNonObsoleteMethod() { 82 if (LIKELY(!IsObsolete())) { 83 return this; 84 } 85 DCHECK_EQ(kRuntimePointerSize, Runtime::Current()->GetClassLinker()->GetImagePointerSize()); 86 if (IsDirect()) { 87 return &GetDeclaringClass()->GetDirectMethodsSlice(kRuntimePointerSize)[GetMethodIndex()]; 88 } else { 89 return GetDeclaringClass()->GetVTableEntry(GetMethodIndex(), kRuntimePointerSize); 90 } 91 } 92 93 ArtMethod* ArtMethod::GetSingleImplementation(PointerSize pointer_size) { 94 if (!IsAbstract()) { 95 // A non-abstract's single implementation is itself. 96 return this; 97 } 98 return reinterpret_cast<ArtMethod*>(GetDataPtrSize(pointer_size)); 99 } 100 101 ArtMethod* ArtMethod::FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa, 102 jobject jlr_method) { 103 ObjPtr<mirror::Executable> executable = soa.Decode<mirror::Executable>(jlr_method); 104 DCHECK(executable != nullptr); 105 return executable->GetArtMethod(); 106 } 107 108 ObjPtr<mirror::DexCache> ArtMethod::GetObsoleteDexCache() { 109 DCHECK(!Runtime::Current()->IsAotCompiler()) << PrettyMethod(); 110 DCHECK(IsObsolete()); 111 ObjPtr<mirror::ClassExt> ext(GetDeclaringClass()->GetExtData()); 112 CHECK(!ext.IsNull()); 113 ObjPtr<mirror::PointerArray> obsolete_methods(ext->GetObsoleteMethods()); 114 CHECK(!obsolete_methods.IsNull()); 115 DCHECK(ext->GetObsoleteDexCaches() != nullptr); 116 int32_t len = obsolete_methods->GetLength(); 117 DCHECK_EQ(len, ext->GetObsoleteDexCaches()->GetLength()); 118 // Using kRuntimePointerSize (instead of using the image's pointer size) is fine since images 119 // should never have obsolete methods in them so they should always be the same. 120 PointerSize pointer_size = kRuntimePointerSize; 121 DCHECK_EQ(kRuntimePointerSize, Runtime::Current()->GetClassLinker()->GetImagePointerSize()); 122 for (int32_t i = 0; i < len; i++) { 123 if (this == obsolete_methods->GetElementPtrSize<ArtMethod*>(i, pointer_size)) { 124 return ext->GetObsoleteDexCaches()->Get(i); 125 } 126 } 127 LOG(FATAL) << "This method does not appear in the obsolete map of its class!"; 128 UNREACHABLE(); 129 } 130 131 uint16_t ArtMethod::FindObsoleteDexClassDefIndex() { 132 DCHECK(!Runtime::Current()->IsAotCompiler()) << PrettyMethod(); 133 DCHECK(IsObsolete()); 134 const DexFile* dex_file = GetDexFile(); 135 const dex::TypeIndex declaring_class_type = dex_file->GetMethodId(GetDexMethodIndex()).class_idx_; 136 const dex::ClassDef* class_def = dex_file->FindClassDef(declaring_class_type); 137 CHECK(class_def != nullptr); 138 return dex_file->GetIndexForClassDef(*class_def); 139 } 140 141 void ArtMethod::ThrowInvocationTimeError() { 142 DCHECK(!IsInvokable()); 143 // NOTE: IsDefaultConflicting must be first since the actual method might or might not be abstract 144 // due to the way we select it. 145 if (IsDefaultConflicting()) { 146 ThrowIncompatibleClassChangeErrorForMethodConflict(this); 147 } else { 148 DCHECK(IsAbstract()); 149 ThrowAbstractMethodError(this); 150 } 151 } 152 153 InvokeType ArtMethod::GetInvokeType() { 154 // TODO: kSuper? 155 if (IsStatic()) { 156 return kStatic; 157 } else if (GetDeclaringClass()->IsInterface()) { 158 return kInterface; 159 } else if (IsDirect()) { 160 return kDirect; 161 } else if (IsPolymorphicSignature()) { 162 return kPolymorphic; 163 } else { 164 return kVirtual; 165 } 166 } 167 168 size_t ArtMethod::NumArgRegisters(const char* shorty) { 169 CHECK_NE(shorty[0], '\0'); 170 uint32_t num_registers = 0; 171 for (const char* s = shorty + 1; *s != '\0'; ++s) { 172 if (*s == 'D' || *s == 'J') { 173 num_registers += 2; 174 } else { 175 num_registers += 1; 176 } 177 } 178 return num_registers; 179 } 180 181 bool ArtMethod::HasSameNameAndSignature(ArtMethod* other) { 182 ScopedAssertNoThreadSuspension ants("HasSameNameAndSignature"); 183 const DexFile* dex_file = GetDexFile(); 184 const dex::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex()); 185 if (GetDexCache() == other->GetDexCache()) { 186 const dex::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex()); 187 return mid.name_idx_ == mid2.name_idx_ && mid.proto_idx_ == mid2.proto_idx_; 188 } 189 const DexFile* dex_file2 = other->GetDexFile(); 190 const dex::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex()); 191 if (!DexFile::StringEquals(dex_file, mid.name_idx_, dex_file2, mid2.name_idx_)) { 192 return false; // Name mismatch. 193 } 194 return dex_file->GetMethodSignature(mid) == dex_file2->GetMethodSignature(mid2); 195 } 196 197 ArtMethod* ArtMethod::FindOverriddenMethod(PointerSize pointer_size) { 198 if (IsStatic()) { 199 return nullptr; 200 } 201 ObjPtr<mirror::Class> declaring_class = GetDeclaringClass(); 202 ObjPtr<mirror::Class> super_class = declaring_class->GetSuperClass(); 203 uint16_t method_index = GetMethodIndex(); 204 ArtMethod* result = nullptr; 205 // Did this method override a super class method? If so load the result from the super class' 206 // vtable 207 if (super_class->HasVTable() && method_index < super_class->GetVTableLength()) { 208 result = super_class->GetVTableEntry(method_index, pointer_size); 209 } else { 210 // Method didn't override superclass method so search interfaces 211 if (IsProxyMethod()) { 212 result = GetInterfaceMethodIfProxy(pointer_size); 213 DCHECK(result != nullptr); 214 } else { 215 ObjPtr<mirror::IfTable> iftable = GetDeclaringClass()->GetIfTable(); 216 for (size_t i = 0; i < iftable->Count() && result == nullptr; i++) { 217 ObjPtr<mirror::Class> interface = iftable->GetInterface(i); 218 for (ArtMethod& interface_method : interface->GetVirtualMethods(pointer_size)) { 219 if (HasSameNameAndSignature(interface_method.GetInterfaceMethodIfProxy(pointer_size))) { 220 result = &interface_method; 221 break; 222 } 223 } 224 } 225 } 226 } 227 DCHECK(result == nullptr || 228 GetInterfaceMethodIfProxy(pointer_size)->HasSameNameAndSignature( 229 result->GetInterfaceMethodIfProxy(pointer_size))); 230 return result; 231 } 232 233 uint32_t ArtMethod::FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile, 234 uint32_t name_and_signature_idx) { 235 const DexFile* dexfile = GetDexFile(); 236 const uint32_t dex_method_idx = GetDexMethodIndex(); 237 const dex::MethodId& mid = dexfile->GetMethodId(dex_method_idx); 238 const dex::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx); 239 DCHECK_STREQ(dexfile->GetMethodName(mid), other_dexfile.GetMethodName(name_and_sig_mid)); 240 DCHECK_EQ(dexfile->GetMethodSignature(mid), other_dexfile.GetMethodSignature(name_and_sig_mid)); 241 if (dexfile == &other_dexfile) { 242 return dex_method_idx; 243 } 244 const char* mid_declaring_class_descriptor = dexfile->StringByTypeIdx(mid.class_idx_); 245 const dex::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor); 246 if (other_type_id != nullptr) { 247 const dex::MethodId* other_mid = other_dexfile.FindMethodId( 248 *other_type_id, other_dexfile.GetStringId(name_and_sig_mid.name_idx_), 249 other_dexfile.GetProtoId(name_and_sig_mid.proto_idx_)); 250 if (other_mid != nullptr) { 251 return other_dexfile.GetIndexForMethodId(*other_mid); 252 } 253 } 254 return dex::kDexNoIndex; 255 } 256 257 uint32_t ArtMethod::FindCatchBlock(Handle<mirror::Class> exception_type, 258 uint32_t dex_pc, bool* has_no_move_exception) { 259 // Set aside the exception while we resolve its type. 260 Thread* self = Thread::Current(); 261 StackHandleScope<1> hs(self); 262 Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException())); 263 self->ClearException(); 264 // Default to handler not found. 265 uint32_t found_dex_pc = dex::kDexNoIndex; 266 // Iterate over the catch handlers associated with dex_pc. 267 CodeItemDataAccessor accessor(DexInstructionData()); 268 for (CatchHandlerIterator it(accessor, dex_pc); it.HasNext(); it.Next()) { 269 dex::TypeIndex iter_type_idx = it.GetHandlerTypeIndex(); 270 // Catch all case 271 if (!iter_type_idx.IsValid()) { 272 found_dex_pc = it.GetHandlerAddress(); 273 break; 274 } 275 // Does this catch exception type apply? 276 ObjPtr<mirror::Class> iter_exception_type = ResolveClassFromTypeIndex(iter_type_idx); 277 if (UNLIKELY(iter_exception_type == nullptr)) { 278 // Now have a NoClassDefFoundError as exception. Ignore in case the exception class was 279 // removed by a pro-guard like tool. 280 // Note: this is not RI behavior. RI would have failed when loading the class. 281 self->ClearException(); 282 // Delete any long jump context as this routine is called during a stack walk which will 283 // release its in use context at the end. 284 delete self->GetLongJumpContext(); 285 LOG(WARNING) << "Unresolved exception class when finding catch block: " 286 << DescriptorToDot(GetTypeDescriptorFromTypeIdx(iter_type_idx)); 287 } else if (iter_exception_type->IsAssignableFrom(exception_type.Get())) { 288 found_dex_pc = it.GetHandlerAddress(); 289 break; 290 } 291 } 292 if (found_dex_pc != dex::kDexNoIndex) { 293 const Instruction& first_catch_instr = accessor.InstructionAt(found_dex_pc); 294 *has_no_move_exception = (first_catch_instr.Opcode() != Instruction::MOVE_EXCEPTION); 295 } 296 // Put the exception back. 297 if (exception != nullptr) { 298 self->SetException(exception.Get()); 299 } 300 return found_dex_pc; 301 } 302 303 void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, 304 const char* shorty) { 305 if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) { 306 ThrowStackOverflowError(self); 307 return; 308 } 309 310 if (kIsDebugBuild) { 311 self->AssertThreadSuspensionIsAllowable(); 312 CHECK_EQ(kRunnable, self->GetState()); 313 CHECK_STREQ(GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(), shorty); 314 } 315 316 // Push a transition back into managed code onto the linked list in thread. 317 ManagedStack fragment; 318 self->PushManagedStackFragment(&fragment); 319 320 Runtime* runtime = Runtime::Current(); 321 // Call the invoke stub, passing everything as arguments. 322 // If the runtime is not yet started or it is required by the debugger, then perform the 323 // Invocation by the interpreter, explicitly forcing interpretation over JIT to prevent 324 // cycling around the various JIT/Interpreter methods that handle method invocation. 325 if (UNLIKELY(!runtime->IsStarted() || 326 (self->IsForceInterpreter() && !IsNative() && !IsProxyMethod() && IsInvokable()) || 327 Dbg::IsForcedInterpreterNeededForCalling(self, this))) { 328 if (IsStatic()) { 329 art::interpreter::EnterInterpreterFromInvoke( 330 self, this, nullptr, args, result, /*stay_in_interpreter=*/ true); 331 } else { 332 mirror::Object* receiver = 333 reinterpret_cast<StackReference<mirror::Object>*>(&args[0])->AsMirrorPtr(); 334 art::interpreter::EnterInterpreterFromInvoke( 335 self, this, receiver, args + 1, result, /*stay_in_interpreter=*/ true); 336 } 337 } else { 338 DCHECK_EQ(runtime->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize); 339 340 constexpr bool kLogInvocationStartAndReturn = false; 341 bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr; 342 if (LIKELY(have_quick_code)) { 343 if (kLogInvocationStartAndReturn) { 344 LOG(INFO) << StringPrintf( 345 "Invoking '%s' quick code=%p static=%d", PrettyMethod().c_str(), 346 GetEntryPointFromQuickCompiledCode(), static_cast<int>(IsStatic() ? 1 : 0)); 347 } 348 349 // Ensure that we won't be accidentally calling quick compiled code when -Xint. 350 if (kIsDebugBuild && runtime->GetInstrumentation()->IsForcedInterpretOnly()) { 351 CHECK(!runtime->UseJitCompilation()); 352 const void* oat_quick_code = 353 (IsNative() || !IsInvokable() || IsProxyMethod() || IsObsolete()) 354 ? nullptr 355 : GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize()); 356 CHECK(oat_quick_code == nullptr || oat_quick_code != GetEntryPointFromQuickCompiledCode()) 357 << "Don't call compiled code when -Xint " << PrettyMethod(); 358 } 359 360 if (!IsStatic()) { 361 (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty); 362 } else { 363 (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty); 364 } 365 if (UNLIKELY(self->GetException() == Thread::GetDeoptimizationException())) { 366 // Unusual case where we were running generated code and an 367 // exception was thrown to force the activations to be removed from the 368 // stack. Continue execution in the interpreter. 369 self->DeoptimizeWithDeoptimizationException(result); 370 } 371 if (kLogInvocationStartAndReturn) { 372 LOG(INFO) << StringPrintf("Returned '%s' quick code=%p", PrettyMethod().c_str(), 373 GetEntryPointFromQuickCompiledCode()); 374 } 375 } else { 376 LOG(INFO) << "Not invoking '" << PrettyMethod() << "' code=null"; 377 if (result != nullptr) { 378 result->SetJ(0); 379 } 380 } 381 } 382 383 // Pop transition. 384 self->PopManagedStackFragment(fragment); 385 } 386 387 const void* ArtMethod::RegisterNative(const void* native_method) { 388 CHECK(IsNative()) << PrettyMethod(); 389 CHECK(native_method != nullptr) << PrettyMethod(); 390 void* new_native_method = nullptr; 391 Runtime::Current()->GetRuntimeCallbacks()->RegisterNativeMethod(this, 392 native_method, 393 /*out*/&new_native_method); 394 SetEntryPointFromJni(new_native_method); 395 return new_native_method; 396 } 397 398 void ArtMethod::UnregisterNative() { 399 CHECK(IsNative()) << PrettyMethod(); 400 // restore stub to lookup native pointer via dlsym 401 SetEntryPointFromJni(GetJniDlsymLookupStub()); 402 } 403 404 bool ArtMethod::IsOverridableByDefaultMethod() { 405 return GetDeclaringClass()->IsInterface(); 406 } 407 408 bool ArtMethod::IsPolymorphicSignature() { 409 // Methods with a polymorphic signature have constraints that they 410 // are native and varargs and belong to either MethodHandle or VarHandle. 411 if (!IsNative() || !IsVarargs()) { 412 return false; 413 } 414 ObjPtr<mirror::ObjectArray<mirror::Class>> class_roots = 415 Runtime::Current()->GetClassLinker()->GetClassRoots(); 416 ObjPtr<mirror::Class> cls = GetDeclaringClass(); 417 return (cls == GetClassRoot<mirror::MethodHandle>(class_roots) || 418 cls == GetClassRoot<mirror::VarHandle>(class_roots)); 419 } 420 421 static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, 422 uint16_t class_def_idx, 423 uint32_t method_idx) { 424 ClassAccessor accessor(dex_file, class_def_idx); 425 uint32_t class_def_method_index = 0u; 426 for (const ClassAccessor::Method& method : accessor.GetMethods()) { 427 if (method.GetIndex() == method_idx) { 428 return class_def_method_index; 429 } 430 class_def_method_index++; 431 } 432 LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation(); 433 UNREACHABLE(); 434 } 435 436 // We use the method's DexFile and declaring class name to find the OatMethod for an obsolete 437 // method. This is extremely slow but we need it if we want to be able to have obsolete native 438 // methods since we need this to find the size of its stack frames. 439 // 440 // NB We could (potentially) do this differently and rely on the way the transformation is applied 441 // in order to use the entrypoint to find this information. However, for debugging reasons (most 442 // notably making sure that new invokes of obsolete methods fail) we choose to instead get the data 443 // directly from the dex file. 444 static const OatFile::OatMethod FindOatMethodFromDexFileFor(ArtMethod* method, bool* found) 445 REQUIRES_SHARED(Locks::mutator_lock_) { 446 DCHECK(method->IsObsolete() && method->IsNative()); 447 const DexFile* dex_file = method->GetDexFile(); 448 449 // recreate the class_def_index from the descriptor. 450 std::string descriptor_storage; 451 const dex::TypeId* declaring_class_type_id = 452 dex_file->FindTypeId(method->GetDeclaringClass()->GetDescriptor(&descriptor_storage)); 453 CHECK(declaring_class_type_id != nullptr); 454 dex::TypeIndex declaring_class_type_index = dex_file->GetIndexForTypeId(*declaring_class_type_id); 455 const dex::ClassDef* declaring_class_type_def = 456 dex_file->FindClassDef(declaring_class_type_index); 457 CHECK(declaring_class_type_def != nullptr); 458 uint16_t declaring_class_def_index = dex_file->GetIndexForClassDef(*declaring_class_type_def); 459 460 size_t oat_method_index = GetOatMethodIndexFromMethodIndex(*dex_file, 461 declaring_class_def_index, 462 method->GetDexMethodIndex()); 463 464 OatFile::OatClass oat_class = OatFile::FindOatClass(*dex_file, 465 declaring_class_def_index, 466 found); 467 if (!(*found)) { 468 return OatFile::OatMethod::Invalid(); 469 } 470 return oat_class.GetOatMethod(oat_method_index); 471 } 472 473 static const OatFile::OatMethod FindOatMethodFor(ArtMethod* method, 474 PointerSize pointer_size, 475 bool* found) 476 REQUIRES_SHARED(Locks::mutator_lock_) { 477 if (UNLIKELY(method->IsObsolete())) { 478 // We shouldn't be calling this with obsolete methods except for native obsolete methods for 479 // which we need to use the oat method to figure out how large the quick frame is. 480 DCHECK(method->IsNative()) << "We should only be finding the OatMethod of obsolete methods in " 481 << "order to allow stack walking. Other obsolete methods should " 482 << "never need to access this information."; 483 DCHECK_EQ(pointer_size, kRuntimePointerSize) << "Obsolete method in compiler!"; 484 return FindOatMethodFromDexFileFor(method, found); 485 } 486 // Although we overwrite the trampoline of non-static methods, we may get here via the resolution 487 // method for direct methods (or virtual methods made direct). 488 ObjPtr<mirror::Class> declaring_class = method->GetDeclaringClass(); 489 size_t oat_method_index; 490 if (method->IsStatic() || method->IsDirect()) { 491 // Simple case where the oat method index was stashed at load time. 492 oat_method_index = method->GetMethodIndex(); 493 } else { 494 // Compute the oat_method_index by search for its position in the declared virtual methods. 495 oat_method_index = declaring_class->NumDirectMethods(); 496 bool found_virtual = false; 497 for (ArtMethod& art_method : declaring_class->GetVirtualMethods(pointer_size)) { 498 // Check method index instead of identity in case of duplicate method definitions. 499 if (method->GetDexMethodIndex() == art_method.GetDexMethodIndex()) { 500 found_virtual = true; 501 break; 502 } 503 oat_method_index++; 504 } 505 CHECK(found_virtual) << "Didn't find oat method index for virtual method: " 506 << method->PrettyMethod(); 507 } 508 DCHECK_EQ(oat_method_index, 509 GetOatMethodIndexFromMethodIndex(declaring_class->GetDexFile(), 510 method->GetDeclaringClass()->GetDexClassDefIndex(), 511 method->GetDexMethodIndex())); 512 OatFile::OatClass oat_class = OatFile::FindOatClass(declaring_class->GetDexFile(), 513 declaring_class->GetDexClassDefIndex(), 514 found); 515 if (!(*found)) { 516 return OatFile::OatMethod::Invalid(); 517 } 518 return oat_class.GetOatMethod(oat_method_index); 519 } 520 521 bool ArtMethod::EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params) { 522 const DexFile* dex_file = GetDexFile(); 523 const auto& method_id = dex_file->GetMethodId(GetDexMethodIndex()); 524 const auto& proto_id = dex_file->GetMethodPrototype(method_id); 525 const dex::TypeList* proto_params = dex_file->GetProtoParameters(proto_id); 526 auto count = proto_params != nullptr ? proto_params->Size() : 0u; 527 auto param_len = params != nullptr ? params->GetLength() : 0u; 528 if (param_len != count) { 529 return false; 530 } 531 auto* cl = Runtime::Current()->GetClassLinker(); 532 for (size_t i = 0; i < count; ++i) { 533 dex::TypeIndex type_idx = proto_params->GetTypeItem(i).type_idx_; 534 ObjPtr<mirror::Class> type = cl->ResolveType(type_idx, this); 535 if (type == nullptr) { 536 Thread::Current()->AssertPendingException(); 537 return false; 538 } 539 if (type != params->GetWithoutChecks(i)) { 540 return false; 541 } 542 } 543 return true; 544 } 545 546 ArrayRef<const uint8_t> ArtMethod::GetQuickenedInfo() { 547 const DexFile& dex_file = *GetDexFile(); 548 const OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 549 if (oat_dex_file == nullptr) { 550 return ArrayRef<const uint8_t>(); 551 } 552 return oat_dex_file->GetQuickenedInfoOf(dex_file, GetDexMethodIndex()); 553 } 554 555 uint16_t ArtMethod::GetIndexFromQuickening(uint32_t dex_pc) { 556 ArrayRef<const uint8_t> data = GetQuickenedInfo(); 557 if (data.empty()) { 558 return DexFile::kDexNoIndex16; 559 } 560 QuickenInfoTable table(data); 561 uint32_t quicken_index = 0; 562 for (const DexInstructionPcPair& pair : DexInstructions()) { 563 if (pair.DexPc() == dex_pc) { 564 return table.GetData(quicken_index); 565 } 566 if (QuickenInfoTable::NeedsIndexForInstruction(&pair.Inst())) { 567 ++quicken_index; 568 } 569 } 570 return DexFile::kDexNoIndex16; 571 } 572 573 const OatQuickMethodHeader* ArtMethod::GetOatQuickMethodHeader(uintptr_t pc) { 574 // Our callers should make sure they don't pass the instrumentation exit pc, 575 // as this method does not look at the side instrumentation stack. 576 DCHECK_NE(pc, reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc())); 577 578 if (IsRuntimeMethod()) { 579 return nullptr; 580 } 581 582 Runtime* runtime = Runtime::Current(); 583 const void* existing_entry_point = GetEntryPointFromQuickCompiledCode(); 584 CHECK(existing_entry_point != nullptr) << PrettyMethod() << "@" << this; 585 ClassLinker* class_linker = runtime->GetClassLinker(); 586 587 if (existing_entry_point == GetQuickProxyInvokeHandler()) { 588 DCHECK(IsProxyMethod() && !IsConstructor()); 589 // The proxy entry point does not have any method header. 590 return nullptr; 591 } 592 593 // Check whether the current entry point contains this pc. 594 if (!class_linker->IsQuickGenericJniStub(existing_entry_point) && 595 !class_linker->IsQuickResolutionStub(existing_entry_point) && 596 !class_linker->IsQuickToInterpreterBridge(existing_entry_point) && 597 existing_entry_point != GetQuickInstrumentationEntryPoint()) { 598 OatQuickMethodHeader* method_header = 599 OatQuickMethodHeader::FromEntryPoint(existing_entry_point); 600 601 if (method_header->Contains(pc)) { 602 return method_header; 603 } 604 } 605 606 // Check whether the pc is in the JIT code cache. 607 jit::Jit* jit = runtime->GetJit(); 608 if (jit != nullptr) { 609 jit::JitCodeCache* code_cache = jit->GetCodeCache(); 610 OatQuickMethodHeader* method_header = code_cache->LookupMethodHeader(pc, this); 611 if (method_header != nullptr) { 612 DCHECK(method_header->Contains(pc)); 613 return method_header; 614 } else { 615 DCHECK(!code_cache->ContainsPc(reinterpret_cast<const void*>(pc))) 616 << PrettyMethod() 617 << ", pc=" << std::hex << pc 618 << ", entry_point=" << std::hex << reinterpret_cast<uintptr_t>(existing_entry_point) 619 << ", copy=" << std::boolalpha << IsCopied() 620 << ", proxy=" << std::boolalpha << IsProxyMethod(); 621 } 622 } 623 624 // The code has to be in an oat file. 625 bool found; 626 OatFile::OatMethod oat_method = 627 FindOatMethodFor(this, class_linker->GetImagePointerSize(), &found); 628 if (!found) { 629 if (IsNative()) { 630 // We are running the GenericJNI stub. The entrypoint may point 631 // to different entrypoints or to a JIT-compiled JNI stub. 632 DCHECK(class_linker->IsQuickGenericJniStub(existing_entry_point) || 633 class_linker->IsQuickResolutionStub(existing_entry_point) || 634 existing_entry_point == GetQuickInstrumentationEntryPoint() || 635 (jit != nullptr && jit->GetCodeCache()->ContainsPc(existing_entry_point))); 636 return nullptr; 637 } 638 // Only for unit tests. 639 // TODO(ngeoffray): Update these tests to pass the right pc? 640 return OatQuickMethodHeader::FromEntryPoint(existing_entry_point); 641 } 642 const void* oat_entry_point = oat_method.GetQuickCode(); 643 if (oat_entry_point == nullptr || class_linker->IsQuickGenericJniStub(oat_entry_point)) { 644 DCHECK(IsNative()) << PrettyMethod(); 645 return nullptr; 646 } 647 648 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromEntryPoint(oat_entry_point); 649 if (pc == 0) { 650 // This is a downcall, it can only happen for a native method. 651 DCHECK(IsNative()); 652 return method_header; 653 } 654 655 DCHECK(method_header->Contains(pc)) 656 << PrettyMethod() 657 << " " << std::hex << pc << " " << oat_entry_point 658 << " " << (uintptr_t)(method_header->GetCode() + method_header->GetCodeSize()); 659 return method_header; 660 } 661 662 const void* ArtMethod::GetOatMethodQuickCode(PointerSize pointer_size) { 663 bool found; 664 OatFile::OatMethod oat_method = FindOatMethodFor(this, pointer_size, &found); 665 if (found) { 666 return oat_method.GetQuickCode(); 667 } 668 return nullptr; 669 } 670 671 bool ArtMethod::HasAnyCompiledCode() { 672 if (IsNative() || !IsInvokable() || IsProxyMethod()) { 673 return false; 674 } 675 676 // Check whether the JIT has compiled it. 677 Runtime* runtime = Runtime::Current(); 678 jit::Jit* jit = runtime->GetJit(); 679 if (jit != nullptr && jit->GetCodeCache()->ContainsMethod(this)) { 680 return true; 681 } 682 683 // Check whether we have AOT code. 684 return GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize()) != nullptr; 685 } 686 687 void ArtMethod::SetIntrinsic(uint32_t intrinsic) { 688 // Currently we only do intrinsics for static/final methods or methods of final 689 // classes. We don't set kHasSingleImplementation for those methods. 690 DCHECK(IsStatic() || IsFinal() || GetDeclaringClass()->IsFinal()) << 691 "Potential conflict with kAccSingleImplementation"; 692 static const int kAccFlagsShift = CTZ(kAccIntrinsicBits); 693 DCHECK_LE(intrinsic, kAccIntrinsicBits >> kAccFlagsShift); 694 uint32_t intrinsic_bits = intrinsic << kAccFlagsShift; 695 uint32_t new_value = (GetAccessFlags() & ~kAccIntrinsicBits) | kAccIntrinsic | intrinsic_bits; 696 if (kIsDebugBuild) { 697 uint32_t java_flags = (GetAccessFlags() & kAccJavaFlagsMask); 698 bool is_constructor = IsConstructor(); 699 bool is_synchronized = IsSynchronized(); 700 bool skip_access_checks = SkipAccessChecks(); 701 bool is_fast_native = IsFastNative(); 702 bool is_critical_native = IsCriticalNative(); 703 bool is_copied = IsCopied(); 704 bool is_miranda = IsMiranda(); 705 bool is_default = IsDefault(); 706 bool is_default_conflict = IsDefaultConflicting(); 707 bool is_compilable = IsCompilable(); 708 bool must_count_locks = MustCountLocks(); 709 // Recompute flags instead of getting them from the current access flags because 710 // access flags may have been changed to deduplicate warning messages (b/129063331). 711 uint32_t hiddenapi_flags = hiddenapi::CreateRuntimeFlags(this); 712 SetAccessFlags(new_value); 713 DCHECK_EQ(java_flags, (GetAccessFlags() & kAccJavaFlagsMask)); 714 DCHECK_EQ(is_constructor, IsConstructor()); 715 DCHECK_EQ(is_synchronized, IsSynchronized()); 716 DCHECK_EQ(skip_access_checks, SkipAccessChecks()); 717 DCHECK_EQ(is_fast_native, IsFastNative()); 718 DCHECK_EQ(is_critical_native, IsCriticalNative()); 719 DCHECK_EQ(is_copied, IsCopied()); 720 DCHECK_EQ(is_miranda, IsMiranda()); 721 DCHECK_EQ(is_default, IsDefault()); 722 DCHECK_EQ(is_default_conflict, IsDefaultConflicting()); 723 DCHECK_EQ(is_compilable, IsCompilable()); 724 DCHECK_EQ(must_count_locks, MustCountLocks()); 725 // Only DCHECK that we have preserved the hidden API access flags if the 726 // original method was not on the whitelist. This is because the core image 727 // does not have the access flags set (b/77733081). 728 if ((hiddenapi_flags & kAccHiddenapiBits) != kAccPublicApi) { 729 DCHECK_EQ(hiddenapi_flags, hiddenapi::GetRuntimeFlags(this)) << PrettyMethod(); 730 } 731 } else { 732 SetAccessFlags(new_value); 733 } 734 } 735 736 void ArtMethod::SetNotIntrinsic() { 737 if (!IsIntrinsic()) { 738 return; 739 } 740 741 // Read the existing hiddenapi flags. 742 uint32_t hiddenapi_runtime_flags = hiddenapi::GetRuntimeFlags(this); 743 744 // Clear intrinsic-related access flags. 745 ClearAccessFlags(kAccIntrinsic | kAccIntrinsicBits); 746 747 // Re-apply hidden API access flags now that the method is not an intrinsic. 748 SetAccessFlags(GetAccessFlags() | hiddenapi_runtime_flags); 749 DCHECK_EQ(hiddenapi_runtime_flags, hiddenapi::GetRuntimeFlags(this)); 750 } 751 752 void ArtMethod::CopyFrom(ArtMethod* src, PointerSize image_pointer_size) { 753 memcpy(reinterpret_cast<void*>(this), reinterpret_cast<const void*>(src), 754 Size(image_pointer_size)); 755 declaring_class_ = GcRoot<mirror::Class>(const_cast<ArtMethod*>(src)->GetDeclaringClass()); 756 757 // If the entry point of the method we are copying from is from JIT code, we just 758 // put the entry point of the new method to interpreter or GenericJNI. We could set 759 // the entry point to the JIT code, but this would require taking the JIT code cache 760 // lock to notify it, which we do not want at this level. 761 Runtime* runtime = Runtime::Current(); 762 if (runtime->UseJitCompilation()) { 763 if (runtime->GetJit()->GetCodeCache()->ContainsPc(GetEntryPointFromQuickCompiledCode())) { 764 SetEntryPointFromQuickCompiledCodePtrSize( 765 src->IsNative() ? GetQuickGenericJniStub() : GetQuickToInterpreterBridge(), 766 image_pointer_size); 767 } 768 } 769 // Clear the profiling info for the same reasons as the JIT code. 770 if (!src->IsNative()) { 771 SetProfilingInfoPtrSize(nullptr, image_pointer_size); 772 } 773 // Clear hotness to let the JIT properly decide when to compile this method. 774 hotness_count_ = 0; 775 } 776 777 bool ArtMethod::IsImagePointerSize(PointerSize pointer_size) { 778 // Hijack this function to get access to PtrSizedFieldsOffset. 779 // 780 // Ensure that PrtSizedFieldsOffset is correct. We rely here on usually having both 32-bit and 781 // 64-bit builds. 782 static_assert(std::is_standard_layout<ArtMethod>::value, "ArtMethod is not standard layout."); 783 static_assert( 784 (sizeof(void*) != 4) || 785 (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k32)), 786 "Unexpected 32-bit class layout."); 787 static_assert( 788 (sizeof(void*) != 8) || 789 (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k64)), 790 "Unexpected 64-bit class layout."); 791 792 Runtime* runtime = Runtime::Current(); 793 if (runtime == nullptr) { 794 return true; 795 } 796 return runtime->GetClassLinker()->GetImagePointerSize() == pointer_size; 797 } 798 799 std::string ArtMethod::PrettyMethod(ArtMethod* m, bool with_signature) { 800 if (m == nullptr) { 801 return "null"; 802 } 803 return m->PrettyMethod(with_signature); 804 } 805 806 std::string ArtMethod::PrettyMethod(bool with_signature) { 807 if (UNLIKELY(IsRuntimeMethod())) { 808 std::string result = GetDeclaringClassDescriptor(); 809 result += '.'; 810 result += GetName(); 811 // Do not add "<no signature>" even if `with_signature` is true. 812 return result; 813 } 814 ArtMethod* m = 815 GetInterfaceMethodIfProxy(Runtime::Current()->GetClassLinker()->GetImagePointerSize()); 816 std::string res(m->GetDexFile()->PrettyMethod(m->GetDexMethodIndex(), with_signature)); 817 if (with_signature && m->IsObsolete()) { 818 return "<OBSOLETE> " + res; 819 } else { 820 return res; 821 } 822 } 823 824 std::string ArtMethod::JniShortName() { 825 return GetJniShortName(GetDeclaringClassDescriptor(), GetName()); 826 } 827 828 std::string ArtMethod::JniLongName() { 829 std::string long_name; 830 long_name += JniShortName(); 831 long_name += "__"; 832 833 std::string signature(GetSignature().ToString()); 834 signature.erase(0, 1); 835 signature.erase(signature.begin() + signature.find(')'), signature.end()); 836 837 long_name += MangleForJni(signature); 838 839 return long_name; 840 } 841 842 const char* ArtMethod::GetRuntimeMethodName() { 843 Runtime* const runtime = Runtime::Current(); 844 if (this == runtime->GetResolutionMethod()) { 845 return "<runtime internal resolution method>"; 846 } else if (this == runtime->GetImtConflictMethod()) { 847 return "<runtime internal imt conflict method>"; 848 } else if (this == runtime->GetCalleeSaveMethod(CalleeSaveType::kSaveAllCalleeSaves)) { 849 return "<runtime internal callee-save all registers method>"; 850 } else if (this == runtime->GetCalleeSaveMethod(CalleeSaveType::kSaveRefsOnly)) { 851 return "<runtime internal callee-save reference registers method>"; 852 } else if (this == runtime->GetCalleeSaveMethod(CalleeSaveType::kSaveRefsAndArgs)) { 853 return "<runtime internal callee-save reference and argument registers method>"; 854 } else if (this == runtime->GetCalleeSaveMethod(CalleeSaveType::kSaveEverything)) { 855 return "<runtime internal save-every-register method>"; 856 } else if (this == runtime->GetCalleeSaveMethod(CalleeSaveType::kSaveEverythingForClinit)) { 857 return "<runtime internal save-every-register method for clinit>"; 858 } else if (this == runtime->GetCalleeSaveMethod(CalleeSaveType::kSaveEverythingForSuspendCheck)) { 859 return "<runtime internal save-every-register method for suspend check>"; 860 } else { 861 return "<unknown runtime internal method>"; 862 } 863 } 864 865 // AssertSharedHeld doesn't work in GetAccessFlags, so use a NO_THREAD_SAFETY_ANALYSIS helper. 866 // TODO: Figure out why ASSERT_SHARED_CAPABILITY doesn't work. 867 template <ReadBarrierOption kReadBarrierOption> 868 ALWAYS_INLINE static inline void DoGetAccessFlagsHelper(ArtMethod* method) 869 NO_THREAD_SAFETY_ANALYSIS { 870 CHECK(method->IsRuntimeMethod() || 871 method->GetDeclaringClass<kReadBarrierOption>()->IsIdxLoaded() || 872 method->GetDeclaringClass<kReadBarrierOption>()->IsErroneous()); 873 } 874 875 } // namespace art 876
