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 "instrumentation.h" 18 19 #include <sstream> 20 21 #include "arch/context.h" 22 #include "art_method-inl.h" 23 #include "atomic.h" 24 #include "class_linker.h" 25 #include "debugger.h" 26 #include "dex_file-inl.h" 27 #include "entrypoints/quick/quick_entrypoints.h" 28 #include "entrypoints/quick/quick_alloc_entrypoints.h" 29 #include "entrypoints/runtime_asm_entrypoints.h" 30 #include "gc_root-inl.h" 31 #include "interpreter/interpreter.h" 32 #include "jit/jit.h" 33 #include "jit/jit_code_cache.h" 34 #include "mirror/class-inl.h" 35 #include "mirror/dex_cache.h" 36 #include "mirror/object_array-inl.h" 37 #include "mirror/object-inl.h" 38 #include "nth_caller_visitor.h" 39 #include "oat_quick_method_header.h" 40 #include "thread.h" 41 #include "thread_list.h" 42 43 namespace art { 44 namespace instrumentation { 45 46 constexpr bool kVerboseInstrumentation = false; 47 48 // Instrumentation works on non-inlined frames by updating returned PCs 49 // of compiled frames. 50 static constexpr StackVisitor::StackWalkKind kInstrumentationStackWalk = 51 StackVisitor::StackWalkKind::kSkipInlinedFrames; 52 53 class InstallStubsClassVisitor : public ClassVisitor { 54 public: 55 explicit InstallStubsClassVisitor(Instrumentation* instrumentation) 56 : instrumentation_(instrumentation) {} 57 58 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES(Locks::mutator_lock_) { 59 instrumentation_->InstallStubsForClass(klass.Ptr()); 60 return true; // we visit all classes. 61 } 62 63 private: 64 Instrumentation* const instrumentation_; 65 }; 66 67 68 Instrumentation::Instrumentation() 69 : instrumentation_stubs_installed_(false), 70 entry_exit_stubs_installed_(false), 71 interpreter_stubs_installed_(false), 72 interpret_only_(false), 73 forced_interpret_only_(false), 74 have_method_entry_listeners_(false), 75 have_method_exit_listeners_(false), 76 have_method_unwind_listeners_(false), 77 have_dex_pc_listeners_(false), 78 have_field_read_listeners_(false), 79 have_field_write_listeners_(false), 80 have_exception_caught_listeners_(false), 81 have_branch_listeners_(false), 82 have_invoke_virtual_or_interface_listeners_(false), 83 deoptimized_methods_lock_("deoptimized methods lock", kDeoptimizedMethodsLock), 84 deoptimization_enabled_(false), 85 interpreter_handler_table_(kMainHandlerTable), 86 quick_alloc_entry_points_instrumentation_counter_(0), 87 alloc_entrypoints_instrumented_(false) { 88 } 89 90 void Instrumentation::InstallStubsForClass(mirror::Class* klass) { 91 if (!klass->IsResolved()) { 92 // We need the class to be resolved to install/uninstall stubs. Otherwise its methods 93 // could not be initialized or linked with regards to class inheritance. 94 } else if (klass->IsErroneousResolved()) { 95 // We can't execute code in a erroneous class: do nothing. 96 } else { 97 for (ArtMethod& method : klass->GetMethods(kRuntimePointerSize)) { 98 InstallStubsForMethod(&method); 99 } 100 } 101 } 102 103 static void UpdateEntrypoints(ArtMethod* method, const void* quick_code) 104 REQUIRES_SHARED(Locks::mutator_lock_) { 105 method->SetEntryPointFromQuickCompiledCode(quick_code); 106 } 107 108 bool Instrumentation::NeedDebugVersionFor(ArtMethod* method) const REQUIRES_SHARED(Locks::mutator_lock_) { 109 return Dbg::IsDebuggerActive() && 110 Runtime::Current()->IsJavaDebuggable() && 111 !method->IsNative() && 112 !method->IsProxyMethod(); 113 } 114 115 void Instrumentation::InstallStubsForMethod(ArtMethod* method) { 116 if (!method->IsInvokable() || method->IsProxyMethod()) { 117 // Do not change stubs for these methods. 118 return; 119 } 120 // Don't stub Proxy.<init>. Note that the Proxy class itself is not a proxy class. 121 if (method->IsConstructor() && 122 method->GetDeclaringClass()->DescriptorEquals("Ljava/lang/reflect/Proxy;")) { 123 return; 124 } 125 const void* new_quick_code; 126 bool uninstall = !entry_exit_stubs_installed_ && !interpreter_stubs_installed_; 127 Runtime* const runtime = Runtime::Current(); 128 ClassLinker* const class_linker = runtime->GetClassLinker(); 129 bool is_class_initialized = method->GetDeclaringClass()->IsInitialized(); 130 if (uninstall) { 131 if ((forced_interpret_only_ || IsDeoptimized(method)) && !method->IsNative()) { 132 new_quick_code = GetQuickToInterpreterBridge(); 133 } else if (is_class_initialized || !method->IsStatic() || method->IsConstructor()) { 134 if (NeedDebugVersionFor(method)) { 135 new_quick_code = GetQuickToInterpreterBridge(); 136 } else { 137 new_quick_code = class_linker->GetQuickOatCodeFor(method); 138 } 139 } else { 140 new_quick_code = GetQuickResolutionStub(); 141 } 142 } else { // !uninstall 143 if ((interpreter_stubs_installed_ || forced_interpret_only_ || IsDeoptimized(method)) && 144 !method->IsNative()) { 145 new_quick_code = GetQuickToInterpreterBridge(); 146 } else { 147 // Do not overwrite resolution trampoline. When the trampoline initializes the method's 148 // class, all its static methods code will be set to the instrumentation entry point. 149 // For more details, see ClassLinker::FixupStaticTrampolines. 150 if (is_class_initialized || !method->IsStatic() || method->IsConstructor()) { 151 if (NeedDebugVersionFor(method)) { 152 // Oat code should not be used. Don't install instrumentation stub and 153 // use interpreter for instrumentation. 154 new_quick_code = GetQuickToInterpreterBridge(); 155 } else if (entry_exit_stubs_installed_) { 156 new_quick_code = GetQuickInstrumentationEntryPoint(); 157 } else { 158 new_quick_code = class_linker->GetQuickOatCodeFor(method); 159 } 160 } else { 161 new_quick_code = GetQuickResolutionStub(); 162 } 163 } 164 } 165 UpdateEntrypoints(method, new_quick_code); 166 } 167 168 // Places the instrumentation exit pc as the return PC for every quick frame. This also allows 169 // deoptimization of quick frames to interpreter frames. 170 // Since we may already have done this previously, we need to push new instrumentation frame before 171 // existing instrumentation frames. 172 static void InstrumentationInstallStack(Thread* thread, void* arg) 173 REQUIRES_SHARED(Locks::mutator_lock_) { 174 struct InstallStackVisitor FINAL : public StackVisitor { 175 InstallStackVisitor(Thread* thread_in, Context* context, uintptr_t instrumentation_exit_pc) 176 : StackVisitor(thread_in, context, kInstrumentationStackWalk), 177 instrumentation_stack_(thread_in->GetInstrumentationStack()), 178 instrumentation_exit_pc_(instrumentation_exit_pc), 179 reached_existing_instrumentation_frames_(false), instrumentation_stack_depth_(0), 180 last_return_pc_(0) { 181 } 182 183 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { 184 ArtMethod* m = GetMethod(); 185 if (m == nullptr) { 186 if (kVerboseInstrumentation) { 187 LOG(INFO) << " Skipping upcall. Frame " << GetFrameId(); 188 } 189 last_return_pc_ = 0; 190 return true; // Ignore upcalls. 191 } 192 if (GetCurrentQuickFrame() == nullptr) { 193 bool interpreter_frame = true; 194 InstrumentationStackFrame instrumentation_frame(GetThisObject(), m, 0, GetFrameId(), 195 interpreter_frame); 196 if (kVerboseInstrumentation) { 197 LOG(INFO) << "Pushing shadow frame " << instrumentation_frame.Dump(); 198 } 199 shadow_stack_.push_back(instrumentation_frame); 200 return true; // Continue. 201 } 202 uintptr_t return_pc = GetReturnPc(); 203 if (m->IsRuntimeMethod()) { 204 if (return_pc == instrumentation_exit_pc_) { 205 if (kVerboseInstrumentation) { 206 LOG(INFO) << " Handling quick to interpreter transition. Frame " << GetFrameId(); 207 } 208 CHECK_LT(instrumentation_stack_depth_, instrumentation_stack_->size()); 209 const InstrumentationStackFrame& frame = 210 instrumentation_stack_->at(instrumentation_stack_depth_); 211 CHECK(frame.interpreter_entry_); 212 // This is an interpreter frame so method enter event must have been reported. However we 213 // need to push a DEX pc into the dex_pcs_ list to match size of instrumentation stack. 214 // Since we won't report method entry here, we can safely push any DEX pc. 215 dex_pcs_.push_back(0); 216 last_return_pc_ = frame.return_pc_; 217 ++instrumentation_stack_depth_; 218 return true; 219 } else { 220 if (kVerboseInstrumentation) { 221 LOG(INFO) << " Skipping runtime method. Frame " << GetFrameId(); 222 } 223 last_return_pc_ = GetReturnPc(); 224 return true; // Ignore unresolved methods since they will be instrumented after resolution. 225 } 226 } 227 if (kVerboseInstrumentation) { 228 LOG(INFO) << " Installing exit stub in " << DescribeLocation(); 229 } 230 if (return_pc == instrumentation_exit_pc_) { 231 // We've reached a frame which has already been installed with instrumentation exit stub. 232 // We should have already installed instrumentation on previous frames. 233 reached_existing_instrumentation_frames_ = true; 234 235 CHECK_LT(instrumentation_stack_depth_, instrumentation_stack_->size()); 236 const InstrumentationStackFrame& frame = 237 instrumentation_stack_->at(instrumentation_stack_depth_); 238 CHECK_EQ(m, frame.method_) << "Expected " << ArtMethod::PrettyMethod(m) 239 << ", Found " << ArtMethod::PrettyMethod(frame.method_); 240 return_pc = frame.return_pc_; 241 if (kVerboseInstrumentation) { 242 LOG(INFO) << "Ignoring already instrumented " << frame.Dump(); 243 } 244 } else { 245 CHECK_NE(return_pc, 0U); 246 CHECK(!reached_existing_instrumentation_frames_); 247 InstrumentationStackFrame instrumentation_frame(GetThisObject(), m, return_pc, GetFrameId(), 248 false); 249 if (kVerboseInstrumentation) { 250 LOG(INFO) << "Pushing frame " << instrumentation_frame.Dump(); 251 } 252 253 // Insert frame at the right position so we do not corrupt the instrumentation stack. 254 // Instrumentation stack frames are in descending frame id order. 255 auto it = instrumentation_stack_->begin(); 256 for (auto end = instrumentation_stack_->end(); it != end; ++it) { 257 const InstrumentationStackFrame& current = *it; 258 if (instrumentation_frame.frame_id_ >= current.frame_id_) { 259 break; 260 } 261 } 262 instrumentation_stack_->insert(it, instrumentation_frame); 263 SetReturnPc(instrumentation_exit_pc_); 264 } 265 dex_pcs_.push_back((GetCurrentOatQuickMethodHeader() == nullptr) 266 ? DexFile::kDexNoIndex 267 : GetCurrentOatQuickMethodHeader()->ToDexPc(m, last_return_pc_)); 268 last_return_pc_ = return_pc; 269 ++instrumentation_stack_depth_; 270 return true; // Continue. 271 } 272 std::deque<InstrumentationStackFrame>* const instrumentation_stack_; 273 std::vector<InstrumentationStackFrame> shadow_stack_; 274 std::vector<uint32_t> dex_pcs_; 275 const uintptr_t instrumentation_exit_pc_; 276 bool reached_existing_instrumentation_frames_; 277 size_t instrumentation_stack_depth_; 278 uintptr_t last_return_pc_; 279 }; 280 if (kVerboseInstrumentation) { 281 std::string thread_name; 282 thread->GetThreadName(thread_name); 283 LOG(INFO) << "Installing exit stubs in " << thread_name; 284 } 285 286 Instrumentation* instrumentation = reinterpret_cast<Instrumentation*>(arg); 287 std::unique_ptr<Context> context(Context::Create()); 288 uintptr_t instrumentation_exit_pc = reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()); 289 InstallStackVisitor visitor(thread, context.get(), instrumentation_exit_pc); 290 visitor.WalkStack(true); 291 CHECK_EQ(visitor.dex_pcs_.size(), thread->GetInstrumentationStack()->size()); 292 293 if (instrumentation->ShouldNotifyMethodEnterExitEvents()) { 294 // Create method enter events for all methods currently on the thread's stack. We only do this 295 // if no debugger is attached to prevent from posting events twice. 296 auto ssi = visitor.shadow_stack_.rbegin(); 297 for (auto isi = thread->GetInstrumentationStack()->rbegin(), 298 end = thread->GetInstrumentationStack()->rend(); isi != end; ++isi) { 299 while (ssi != visitor.shadow_stack_.rend() && (*ssi).frame_id_ < (*isi).frame_id_) { 300 instrumentation->MethodEnterEvent(thread, (*ssi).this_object_, (*ssi).method_, 0); 301 ++ssi; 302 } 303 uint32_t dex_pc = visitor.dex_pcs_.back(); 304 visitor.dex_pcs_.pop_back(); 305 if (!isi->interpreter_entry_) { 306 instrumentation->MethodEnterEvent(thread, (*isi).this_object_, (*isi).method_, dex_pc); 307 } 308 } 309 } 310 thread->VerifyStack(); 311 } 312 313 void Instrumentation::InstrumentThreadStack(Thread* thread) { 314 instrumentation_stubs_installed_ = true; 315 InstrumentationInstallStack(thread, this); 316 } 317 318 // Removes the instrumentation exit pc as the return PC for every quick frame. 319 static void InstrumentationRestoreStack(Thread* thread, void* arg) 320 REQUIRES(Locks::mutator_lock_) { 321 Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); 322 323 struct RestoreStackVisitor FINAL : public StackVisitor { 324 RestoreStackVisitor(Thread* thread_in, uintptr_t instrumentation_exit_pc, 325 Instrumentation* instrumentation) 326 : StackVisitor(thread_in, nullptr, kInstrumentationStackWalk), 327 thread_(thread_in), 328 instrumentation_exit_pc_(instrumentation_exit_pc), 329 instrumentation_(instrumentation), 330 instrumentation_stack_(thread_in->GetInstrumentationStack()), 331 frames_removed_(0) {} 332 333 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { 334 if (instrumentation_stack_->size() == 0) { 335 return false; // Stop. 336 } 337 ArtMethod* m = GetMethod(); 338 if (GetCurrentQuickFrame() == nullptr) { 339 if (kVerboseInstrumentation) { 340 LOG(INFO) << " Ignoring a shadow frame. Frame " << GetFrameId() 341 << " Method=" << ArtMethod::PrettyMethod(m); 342 } 343 return true; // Ignore shadow frames. 344 } 345 if (m == nullptr) { 346 if (kVerboseInstrumentation) { 347 LOG(INFO) << " Skipping upcall. Frame " << GetFrameId(); 348 } 349 return true; // Ignore upcalls. 350 } 351 bool removed_stub = false; 352 // TODO: make this search more efficient? 353 const size_t frameId = GetFrameId(); 354 for (const InstrumentationStackFrame& instrumentation_frame : *instrumentation_stack_) { 355 if (instrumentation_frame.frame_id_ == frameId) { 356 if (kVerboseInstrumentation) { 357 LOG(INFO) << " Removing exit stub in " << DescribeLocation(); 358 } 359 if (instrumentation_frame.interpreter_entry_) { 360 CHECK(m == Runtime::Current()->GetCalleeSaveMethod(Runtime::kSaveRefsAndArgs)); 361 } else { 362 CHECK(m == instrumentation_frame.method_) << ArtMethod::PrettyMethod(m); 363 } 364 SetReturnPc(instrumentation_frame.return_pc_); 365 if (instrumentation_->ShouldNotifyMethodEnterExitEvents()) { 366 // Create the method exit events. As the methods didn't really exit the result is 0. 367 // We only do this if no debugger is attached to prevent from posting events twice. 368 instrumentation_->MethodExitEvent(thread_, instrumentation_frame.this_object_, m, 369 GetDexPc(), JValue()); 370 } 371 frames_removed_++; 372 removed_stub = true; 373 break; 374 } 375 } 376 if (!removed_stub) { 377 if (kVerboseInstrumentation) { 378 LOG(INFO) << " No exit stub in " << DescribeLocation(); 379 } 380 } 381 return true; // Continue. 382 } 383 Thread* const thread_; 384 const uintptr_t instrumentation_exit_pc_; 385 Instrumentation* const instrumentation_; 386 std::deque<instrumentation::InstrumentationStackFrame>* const instrumentation_stack_; 387 size_t frames_removed_; 388 }; 389 if (kVerboseInstrumentation) { 390 std::string thread_name; 391 thread->GetThreadName(thread_name); 392 LOG(INFO) << "Removing exit stubs in " << thread_name; 393 } 394 std::deque<instrumentation::InstrumentationStackFrame>* stack = thread->GetInstrumentationStack(); 395 if (stack->size() > 0) { 396 Instrumentation* instrumentation = reinterpret_cast<Instrumentation*>(arg); 397 uintptr_t instrumentation_exit_pc = 398 reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()); 399 RestoreStackVisitor visitor(thread, instrumentation_exit_pc, instrumentation); 400 visitor.WalkStack(true); 401 CHECK_EQ(visitor.frames_removed_, stack->size()); 402 while (stack->size() > 0) { 403 stack->pop_front(); 404 } 405 } 406 } 407 408 static bool HasEvent(Instrumentation::InstrumentationEvent expected, uint32_t events) { 409 return (events & expected) != 0; 410 } 411 412 static void PotentiallyAddListenerTo(Instrumentation::InstrumentationEvent event, 413 uint32_t events, 414 std::list<InstrumentationListener*>& list, 415 InstrumentationListener* listener, 416 bool* has_listener) 417 REQUIRES(Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::classlinker_classes_lock_) { 418 Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); 419 if (!HasEvent(event, events)) { 420 return; 421 } 422 // If there is a free slot in the list, we insert the listener in that slot. 423 // Otherwise we add it to the end of the list. 424 auto it = std::find(list.begin(), list.end(), nullptr); 425 if (it != list.end()) { 426 *it = listener; 427 } else { 428 list.push_back(listener); 429 } 430 *has_listener = true; 431 } 432 433 void Instrumentation::AddListener(InstrumentationListener* listener, uint32_t events) { 434 Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); 435 PotentiallyAddListenerTo(kMethodEntered, 436 events, 437 method_entry_listeners_, 438 listener, 439 &have_method_entry_listeners_); 440 PotentiallyAddListenerTo(kMethodExited, 441 events, 442 method_exit_listeners_, 443 listener, 444 &have_method_exit_listeners_); 445 PotentiallyAddListenerTo(kMethodUnwind, 446 events, 447 method_unwind_listeners_, 448 listener, 449 &have_method_unwind_listeners_); 450 PotentiallyAddListenerTo(kBranch, 451 events, 452 branch_listeners_, 453 listener, 454 &have_branch_listeners_); 455 PotentiallyAddListenerTo(kInvokeVirtualOrInterface, 456 events, 457 invoke_virtual_or_interface_listeners_, 458 listener, 459 &have_invoke_virtual_or_interface_listeners_); 460 PotentiallyAddListenerTo(kDexPcMoved, 461 events, 462 dex_pc_listeners_, 463 listener, 464 &have_dex_pc_listeners_); 465 PotentiallyAddListenerTo(kFieldRead, 466 events, 467 field_read_listeners_, 468 listener, 469 &have_field_read_listeners_); 470 PotentiallyAddListenerTo(kFieldWritten, 471 events, 472 field_write_listeners_, 473 listener, 474 &have_field_write_listeners_); 475 PotentiallyAddListenerTo(kExceptionCaught, 476 events, 477 exception_caught_listeners_, 478 listener, 479 &have_exception_caught_listeners_); 480 UpdateInterpreterHandlerTable(); 481 } 482 483 static void PotentiallyRemoveListenerFrom(Instrumentation::InstrumentationEvent event, 484 uint32_t events, 485 std::list<InstrumentationListener*>& list, 486 InstrumentationListener* listener, 487 bool* has_listener) 488 REQUIRES(Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::classlinker_classes_lock_) { 489 Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); 490 if (!HasEvent(event, events)) { 491 return; 492 } 493 auto it = std::find(list.begin(), list.end(), listener); 494 if (it != list.end()) { 495 // Just update the entry, do not remove from the list. Removing entries in the list 496 // is unsafe when mutators are iterating over it. 497 *it = nullptr; 498 } 499 500 // Check if the list contains any non-null listener, and update 'has_listener'. 501 for (InstrumentationListener* l : list) { 502 if (l != nullptr) { 503 *has_listener = true; 504 return; 505 } 506 } 507 *has_listener = false; 508 } 509 510 void Instrumentation::RemoveListener(InstrumentationListener* listener, uint32_t events) { 511 Locks::mutator_lock_->AssertExclusiveHeld(Thread::Current()); 512 PotentiallyRemoveListenerFrom(kMethodEntered, 513 events, 514 method_entry_listeners_, 515 listener, 516 &have_method_entry_listeners_); 517 PotentiallyRemoveListenerFrom(kMethodExited, 518 events, 519 method_exit_listeners_, 520 listener, 521 &have_method_exit_listeners_); 522 PotentiallyRemoveListenerFrom(kMethodUnwind, 523 events, 524 method_unwind_listeners_, 525 listener, 526 &have_method_unwind_listeners_); 527 PotentiallyRemoveListenerFrom(kBranch, 528 events, 529 branch_listeners_, 530 listener, 531 &have_branch_listeners_); 532 PotentiallyRemoveListenerFrom(kInvokeVirtualOrInterface, 533 events, 534 invoke_virtual_or_interface_listeners_, 535 listener, 536 &have_invoke_virtual_or_interface_listeners_); 537 PotentiallyRemoveListenerFrom(kDexPcMoved, 538 events, 539 dex_pc_listeners_, 540 listener, 541 &have_dex_pc_listeners_); 542 PotentiallyRemoveListenerFrom(kFieldRead, 543 events, 544 field_read_listeners_, 545 listener, 546 &have_field_read_listeners_); 547 PotentiallyRemoveListenerFrom(kFieldWritten, 548 events, 549 field_write_listeners_, 550 listener, 551 &have_field_write_listeners_); 552 PotentiallyRemoveListenerFrom(kExceptionCaught, 553 events, 554 exception_caught_listeners_, 555 listener, 556 &have_exception_caught_listeners_); 557 UpdateInterpreterHandlerTable(); 558 } 559 560 Instrumentation::InstrumentationLevel Instrumentation::GetCurrentInstrumentationLevel() const { 561 if (interpreter_stubs_installed_) { 562 return InstrumentationLevel::kInstrumentWithInterpreter; 563 } else if (entry_exit_stubs_installed_) { 564 return InstrumentationLevel::kInstrumentWithInstrumentationStubs; 565 } else { 566 return InstrumentationLevel::kInstrumentNothing; 567 } 568 } 569 570 bool Instrumentation::RequiresInstrumentationInstallation(InstrumentationLevel new_level) const { 571 // We need to reinstall instrumentation if we go to a different level. 572 return GetCurrentInstrumentationLevel() != new_level; 573 } 574 575 void Instrumentation::ConfigureStubs(const char* key, InstrumentationLevel desired_level) { 576 // Store the instrumentation level for this key or remove it. 577 if (desired_level == InstrumentationLevel::kInstrumentNothing) { 578 // The client no longer needs instrumentation. 579 requested_instrumentation_levels_.erase(key); 580 } else { 581 // The client needs instrumentation. 582 requested_instrumentation_levels_.Overwrite(key, desired_level); 583 } 584 585 // Look for the highest required instrumentation level. 586 InstrumentationLevel requested_level = InstrumentationLevel::kInstrumentNothing; 587 for (const auto& v : requested_instrumentation_levels_) { 588 requested_level = std::max(requested_level, v.second); 589 } 590 591 interpret_only_ = (requested_level == InstrumentationLevel::kInstrumentWithInterpreter) || 592 forced_interpret_only_; 593 594 if (!RequiresInstrumentationInstallation(requested_level)) { 595 // We're already set. 596 return; 597 } 598 Thread* const self = Thread::Current(); 599 Runtime* runtime = Runtime::Current(); 600 Locks::mutator_lock_->AssertExclusiveHeld(self); 601 Locks::thread_list_lock_->AssertNotHeld(self); 602 if (requested_level > InstrumentationLevel::kInstrumentNothing) { 603 if (requested_level == InstrumentationLevel::kInstrumentWithInterpreter) { 604 interpreter_stubs_installed_ = true; 605 entry_exit_stubs_installed_ = true; 606 } else { 607 CHECK_EQ(requested_level, InstrumentationLevel::kInstrumentWithInstrumentationStubs); 608 entry_exit_stubs_installed_ = true; 609 interpreter_stubs_installed_ = false; 610 } 611 InstallStubsClassVisitor visitor(this); 612 runtime->GetClassLinker()->VisitClasses(&visitor); 613 instrumentation_stubs_installed_ = true; 614 MutexLock mu(self, *Locks::thread_list_lock_); 615 runtime->GetThreadList()->ForEach(InstrumentationInstallStack, this); 616 } else { 617 interpreter_stubs_installed_ = false; 618 entry_exit_stubs_installed_ = false; 619 InstallStubsClassVisitor visitor(this); 620 runtime->GetClassLinker()->VisitClasses(&visitor); 621 // Restore stack only if there is no method currently deoptimized. 622 bool empty; 623 { 624 ReaderMutexLock mu(self, deoptimized_methods_lock_); 625 empty = IsDeoptimizedMethodsEmpty(); // Avoid lock violation. 626 } 627 if (empty) { 628 MutexLock mu(self, *Locks::thread_list_lock_); 629 Runtime::Current()->GetThreadList()->ForEach(InstrumentationRestoreStack, this); 630 // Only do this after restoring, as walking the stack when restoring will see 631 // the instrumentation exit pc. 632 instrumentation_stubs_installed_ = false; 633 } 634 } 635 } 636 637 static void ResetQuickAllocEntryPointsForThread(Thread* thread, void* arg ATTRIBUTE_UNUSED) { 638 thread->ResetQuickAllocEntryPointsForThread(kUseReadBarrier && thread->GetIsGcMarking()); 639 } 640 641 void Instrumentation::SetEntrypointsInstrumented(bool instrumented) { 642 Thread* self = Thread::Current(); 643 Runtime* runtime = Runtime::Current(); 644 Locks::mutator_lock_->AssertNotHeld(self); 645 Locks::instrument_entrypoints_lock_->AssertHeld(self); 646 if (runtime->IsStarted()) { 647 ScopedSuspendAll ssa(__FUNCTION__); 648 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 649 SetQuickAllocEntryPointsInstrumented(instrumented); 650 ResetQuickAllocEntryPoints(); 651 alloc_entrypoints_instrumented_ = instrumented; 652 } else { 653 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 654 SetQuickAllocEntryPointsInstrumented(instrumented); 655 656 // Note: ResetQuickAllocEntryPoints only works when the runtime is started. Manually run the 657 // update for just this thread. 658 // Note: self may be null. One of those paths is setting instrumentation in the Heap 659 // constructor for gcstress mode. 660 if (self != nullptr) { 661 ResetQuickAllocEntryPointsForThread(self, nullptr); 662 } 663 664 alloc_entrypoints_instrumented_ = instrumented; 665 } 666 } 667 668 void Instrumentation::InstrumentQuickAllocEntryPoints() { 669 MutexLock mu(Thread::Current(), *Locks::instrument_entrypoints_lock_); 670 InstrumentQuickAllocEntryPointsLocked(); 671 } 672 673 void Instrumentation::UninstrumentQuickAllocEntryPoints() { 674 MutexLock mu(Thread::Current(), *Locks::instrument_entrypoints_lock_); 675 UninstrumentQuickAllocEntryPointsLocked(); 676 } 677 678 void Instrumentation::InstrumentQuickAllocEntryPointsLocked() { 679 Locks::instrument_entrypoints_lock_->AssertHeld(Thread::Current()); 680 if (quick_alloc_entry_points_instrumentation_counter_ == 0) { 681 SetEntrypointsInstrumented(true); 682 } 683 ++quick_alloc_entry_points_instrumentation_counter_; 684 } 685 686 void Instrumentation::UninstrumentQuickAllocEntryPointsLocked() { 687 Locks::instrument_entrypoints_lock_->AssertHeld(Thread::Current()); 688 CHECK_GT(quick_alloc_entry_points_instrumentation_counter_, 0U); 689 --quick_alloc_entry_points_instrumentation_counter_; 690 if (quick_alloc_entry_points_instrumentation_counter_ == 0) { 691 SetEntrypointsInstrumented(false); 692 } 693 } 694 695 void Instrumentation::ResetQuickAllocEntryPoints() { 696 Runtime* runtime = Runtime::Current(); 697 if (runtime->IsStarted()) { 698 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_); 699 runtime->GetThreadList()->ForEach(ResetQuickAllocEntryPointsForThread, nullptr); 700 } 701 } 702 703 void Instrumentation::UpdateMethodsCodeImpl(ArtMethod* method, const void* quick_code) { 704 const void* new_quick_code; 705 if (LIKELY(!instrumentation_stubs_installed_)) { 706 new_quick_code = quick_code; 707 } else { 708 if ((interpreter_stubs_installed_ || IsDeoptimized(method)) && !method->IsNative()) { 709 new_quick_code = GetQuickToInterpreterBridge(); 710 } else { 711 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 712 if (class_linker->IsQuickResolutionStub(quick_code) || 713 class_linker->IsQuickToInterpreterBridge(quick_code)) { 714 new_quick_code = quick_code; 715 } else if (entry_exit_stubs_installed_) { 716 new_quick_code = GetQuickInstrumentationEntryPoint(); 717 } else { 718 new_quick_code = quick_code; 719 } 720 } 721 } 722 UpdateEntrypoints(method, new_quick_code); 723 } 724 725 void Instrumentation::UpdateMethodsCode(ArtMethod* method, const void* quick_code) { 726 DCHECK(method->GetDeclaringClass()->IsResolved()); 727 UpdateMethodsCodeImpl(method, quick_code); 728 } 729 730 void Instrumentation::UpdateMethodsCodeForJavaDebuggable(ArtMethod* method, 731 const void* quick_code) { 732 // When the runtime is set to Java debuggable, we may update the entry points of 733 // all methods of a class to the interpreter bridge. A method's declaring class 734 // might not be in resolved state yet in that case, so we bypass the DCHECK in 735 // UpdateMethodsCode. 736 UpdateMethodsCodeImpl(method, quick_code); 737 } 738 739 bool Instrumentation::AddDeoptimizedMethod(ArtMethod* method) { 740 if (IsDeoptimizedMethod(method)) { 741 // Already in the map. Return. 742 return false; 743 } 744 // Not found. Add it. 745 deoptimized_methods_.insert(method); 746 return true; 747 } 748 749 bool Instrumentation::IsDeoptimizedMethod(ArtMethod* method) { 750 return deoptimized_methods_.find(method) != deoptimized_methods_.end(); 751 } 752 753 ArtMethod* Instrumentation::BeginDeoptimizedMethod() { 754 if (deoptimized_methods_.empty()) { 755 // Empty. 756 return nullptr; 757 } 758 return *deoptimized_methods_.begin(); 759 } 760 761 bool Instrumentation::RemoveDeoptimizedMethod(ArtMethod* method) { 762 auto it = deoptimized_methods_.find(method); 763 if (it == deoptimized_methods_.end()) { 764 return false; 765 } 766 deoptimized_methods_.erase(it); 767 return true; 768 } 769 770 bool Instrumentation::IsDeoptimizedMethodsEmpty() const { 771 return deoptimized_methods_.empty(); 772 } 773 774 void Instrumentation::Deoptimize(ArtMethod* method) { 775 CHECK(!method->IsNative()); 776 CHECK(!method->IsProxyMethod()); 777 CHECK(method->IsInvokable()); 778 779 Thread* self = Thread::Current(); 780 { 781 WriterMutexLock mu(self, deoptimized_methods_lock_); 782 bool has_not_been_deoptimized = AddDeoptimizedMethod(method); 783 CHECK(has_not_been_deoptimized) << "Method " << ArtMethod::PrettyMethod(method) 784 << " is already deoptimized"; 785 } 786 if (!interpreter_stubs_installed_) { 787 UpdateEntrypoints(method, GetQuickInstrumentationEntryPoint()); 788 789 // Install instrumentation exit stub and instrumentation frames. We may already have installed 790 // these previously so it will only cover the newly created frames. 791 instrumentation_stubs_installed_ = true; 792 MutexLock mu(self, *Locks::thread_list_lock_); 793 Runtime::Current()->GetThreadList()->ForEach(InstrumentationInstallStack, this); 794 } 795 } 796 797 void Instrumentation::Undeoptimize(ArtMethod* method) { 798 CHECK(!method->IsNative()); 799 CHECK(!method->IsProxyMethod()); 800 CHECK(method->IsInvokable()); 801 802 Thread* self = Thread::Current(); 803 bool empty; 804 { 805 WriterMutexLock mu(self, deoptimized_methods_lock_); 806 bool found_and_erased = RemoveDeoptimizedMethod(method); 807 CHECK(found_and_erased) << "Method " << ArtMethod::PrettyMethod(method) 808 << " is not deoptimized"; 809 empty = IsDeoptimizedMethodsEmpty(); 810 } 811 812 // Restore code and possibly stack only if we did not deoptimize everything. 813 if (!interpreter_stubs_installed_) { 814 // Restore its code or resolution trampoline. 815 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 816 if (method->IsStatic() && !method->IsConstructor() && 817 !method->GetDeclaringClass()->IsInitialized()) { 818 UpdateEntrypoints(method, GetQuickResolutionStub()); 819 } else { 820 const void* quick_code = NeedDebugVersionFor(method) 821 ? GetQuickToInterpreterBridge() 822 : class_linker->GetQuickOatCodeFor(method); 823 UpdateEntrypoints(method, quick_code); 824 } 825 826 // If there is no deoptimized method left, we can restore the stack of each thread. 827 if (empty) { 828 MutexLock mu(self, *Locks::thread_list_lock_); 829 Runtime::Current()->GetThreadList()->ForEach(InstrumentationRestoreStack, this); 830 instrumentation_stubs_installed_ = false; 831 } 832 } 833 } 834 835 bool Instrumentation::IsDeoptimized(ArtMethod* method) { 836 DCHECK(method != nullptr); 837 ReaderMutexLock mu(Thread::Current(), deoptimized_methods_lock_); 838 return IsDeoptimizedMethod(method); 839 } 840 841 void Instrumentation::EnableDeoptimization() { 842 ReaderMutexLock mu(Thread::Current(), deoptimized_methods_lock_); 843 CHECK(IsDeoptimizedMethodsEmpty()); 844 CHECK_EQ(deoptimization_enabled_, false); 845 deoptimization_enabled_ = true; 846 } 847 848 void Instrumentation::DisableDeoptimization(const char* key) { 849 CHECK_EQ(deoptimization_enabled_, true); 850 // If we deoptimized everything, undo it. 851 InstrumentationLevel level = GetCurrentInstrumentationLevel(); 852 if (level == InstrumentationLevel::kInstrumentWithInterpreter) { 853 UndeoptimizeEverything(key); 854 } 855 // Undeoptimized selected methods. 856 while (true) { 857 ArtMethod* method; 858 { 859 ReaderMutexLock mu(Thread::Current(), deoptimized_methods_lock_); 860 if (IsDeoptimizedMethodsEmpty()) { 861 break; 862 } 863 method = BeginDeoptimizedMethod(); 864 CHECK(method != nullptr); 865 } 866 Undeoptimize(method); 867 } 868 deoptimization_enabled_ = false; 869 } 870 871 // Indicates if instrumentation should notify method enter/exit events to the listeners. 872 bool Instrumentation::ShouldNotifyMethodEnterExitEvents() const { 873 if (!HasMethodEntryListeners() && !HasMethodExitListeners()) { 874 return false; 875 } 876 return !deoptimization_enabled_ && !interpreter_stubs_installed_; 877 } 878 879 void Instrumentation::DeoptimizeEverything(const char* key) { 880 CHECK(deoptimization_enabled_); 881 ConfigureStubs(key, InstrumentationLevel::kInstrumentWithInterpreter); 882 } 883 884 void Instrumentation::UndeoptimizeEverything(const char* key) { 885 CHECK(interpreter_stubs_installed_); 886 CHECK(deoptimization_enabled_); 887 ConfigureStubs(key, InstrumentationLevel::kInstrumentNothing); 888 } 889 890 void Instrumentation::EnableMethodTracing(const char* key, bool needs_interpreter) { 891 InstrumentationLevel level; 892 if (needs_interpreter) { 893 level = InstrumentationLevel::kInstrumentWithInterpreter; 894 } else { 895 level = InstrumentationLevel::kInstrumentWithInstrumentationStubs; 896 } 897 ConfigureStubs(key, level); 898 } 899 900 void Instrumentation::DisableMethodTracing(const char* key) { 901 ConfigureStubs(key, InstrumentationLevel::kInstrumentNothing); 902 } 903 904 const void* Instrumentation::GetQuickCodeFor(ArtMethod* method, PointerSize pointer_size) const { 905 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 906 if (LIKELY(!instrumentation_stubs_installed_)) { 907 const void* code = method->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size); 908 DCHECK(code != nullptr); 909 if (LIKELY(!class_linker->IsQuickResolutionStub(code) && 910 !class_linker->IsQuickToInterpreterBridge(code)) && 911 !class_linker->IsQuickResolutionStub(code) && 912 !class_linker->IsQuickToInterpreterBridge(code)) { 913 return code; 914 } 915 } 916 return class_linker->GetQuickOatCodeFor(method); 917 } 918 919 void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_object, 920 ArtMethod* method, 921 uint32_t dex_pc) const { 922 if (HasMethodEntryListeners()) { 923 for (InstrumentationListener* listener : method_entry_listeners_) { 924 if (listener != nullptr) { 925 listener->MethodEntered(thread, this_object, method, dex_pc); 926 } 927 } 928 } 929 } 930 931 void Instrumentation::MethodExitEventImpl(Thread* thread, mirror::Object* this_object, 932 ArtMethod* method, 933 uint32_t dex_pc, const JValue& return_value) const { 934 if (HasMethodExitListeners()) { 935 for (InstrumentationListener* listener : method_exit_listeners_) { 936 if (listener != nullptr) { 937 listener->MethodExited(thread, this_object, method, dex_pc, return_value); 938 } 939 } 940 } 941 } 942 943 void Instrumentation::MethodUnwindEvent(Thread* thread, mirror::Object* this_object, 944 ArtMethod* method, 945 uint32_t dex_pc) const { 946 if (HasMethodUnwindListeners()) { 947 for (InstrumentationListener* listener : method_unwind_listeners_) { 948 if (listener != nullptr) { 949 listener->MethodUnwind(thread, this_object, method, dex_pc); 950 } 951 } 952 } 953 } 954 955 void Instrumentation::DexPcMovedEventImpl(Thread* thread, mirror::Object* this_object, 956 ArtMethod* method, 957 uint32_t dex_pc) const { 958 for (InstrumentationListener* listener : dex_pc_listeners_) { 959 if (listener != nullptr) { 960 listener->DexPcMoved(thread, this_object, method, dex_pc); 961 } 962 } 963 } 964 965 void Instrumentation::BranchImpl(Thread* thread, 966 ArtMethod* method, 967 uint32_t dex_pc, 968 int32_t offset) const { 969 for (InstrumentationListener* listener : branch_listeners_) { 970 if (listener != nullptr) { 971 listener->Branch(thread, method, dex_pc, offset); 972 } 973 } 974 } 975 976 void Instrumentation::InvokeVirtualOrInterfaceImpl(Thread* thread, 977 mirror::Object* this_object, 978 ArtMethod* caller, 979 uint32_t dex_pc, 980 ArtMethod* callee) const { 981 // We cannot have thread suspension since that would cause the this_object parameter to 982 // potentially become a dangling pointer. An alternative could be to put it in a handle instead. 983 ScopedAssertNoThreadSuspension ants(__FUNCTION__); 984 for (InstrumentationListener* listener : invoke_virtual_or_interface_listeners_) { 985 if (listener != nullptr) { 986 listener->InvokeVirtualOrInterface(thread, this_object, caller, dex_pc, callee); 987 } 988 } 989 } 990 991 void Instrumentation::FieldReadEventImpl(Thread* thread, mirror::Object* this_object, 992 ArtMethod* method, uint32_t dex_pc, 993 ArtField* field) const { 994 for (InstrumentationListener* listener : field_read_listeners_) { 995 if (listener != nullptr) { 996 listener->FieldRead(thread, this_object, method, dex_pc, field); 997 } 998 } 999 } 1000 1001 void Instrumentation::FieldWriteEventImpl(Thread* thread, mirror::Object* this_object, 1002 ArtMethod* method, uint32_t dex_pc, 1003 ArtField* field, const JValue& field_value) const { 1004 for (InstrumentationListener* listener : field_write_listeners_) { 1005 if (listener != nullptr) { 1006 listener->FieldWritten(thread, this_object, method, dex_pc, field, field_value); 1007 } 1008 } 1009 } 1010 1011 void Instrumentation::ExceptionCaughtEvent(Thread* thread, 1012 mirror::Throwable* exception_object) const { 1013 Thread* self = Thread::Current(); 1014 StackHandleScope<1> hs(self); 1015 Handle<mirror::Throwable> h_exception(hs.NewHandle(exception_object)); 1016 if (HasExceptionCaughtListeners()) { 1017 DCHECK_EQ(thread->GetException(), h_exception.Get()); 1018 thread->ClearException(); 1019 for (InstrumentationListener* listener : exception_caught_listeners_) { 1020 if (listener != nullptr) { 1021 listener->ExceptionCaught(thread, h_exception.Get()); 1022 } 1023 } 1024 thread->SetException(h_exception.Get()); 1025 } 1026 } 1027 1028 // Computes a frame ID by ignoring inlined frames. 1029 size_t Instrumentation::ComputeFrameId(Thread* self, 1030 size_t frame_depth, 1031 size_t inlined_frames_before_frame) { 1032 CHECK_GE(frame_depth, inlined_frames_before_frame); 1033 size_t no_inline_depth = frame_depth - inlined_frames_before_frame; 1034 return StackVisitor::ComputeNumFrames(self, kInstrumentationStackWalk) - no_inline_depth; 1035 } 1036 1037 static void CheckStackDepth(Thread* self, const InstrumentationStackFrame& instrumentation_frame, 1038 int delta) 1039 REQUIRES_SHARED(Locks::mutator_lock_) { 1040 size_t frame_id = StackVisitor::ComputeNumFrames(self, kInstrumentationStackWalk) + delta; 1041 if (frame_id != instrumentation_frame.frame_id_) { 1042 LOG(ERROR) << "Expected frame_id=" << frame_id << " but found " 1043 << instrumentation_frame.frame_id_; 1044 StackVisitor::DescribeStack(self); 1045 CHECK_EQ(frame_id, instrumentation_frame.frame_id_); 1046 } 1047 } 1048 1049 void Instrumentation::PushInstrumentationStackFrame(Thread* self, mirror::Object* this_object, 1050 ArtMethod* method, 1051 uintptr_t lr, bool interpreter_entry) { 1052 // We have a callee-save frame meaning this value is guaranteed to never be 0. 1053 size_t frame_id = StackVisitor::ComputeNumFrames(self, kInstrumentationStackWalk); 1054 std::deque<instrumentation::InstrumentationStackFrame>* stack = self->GetInstrumentationStack(); 1055 if (kVerboseInstrumentation) { 1056 LOG(INFO) << "Entering " << ArtMethod::PrettyMethod(method) << " from PC " 1057 << reinterpret_cast<void*>(lr); 1058 } 1059 instrumentation::InstrumentationStackFrame instrumentation_frame(this_object, method, lr, 1060 frame_id, interpreter_entry); 1061 stack->push_front(instrumentation_frame); 1062 1063 if (!interpreter_entry) { 1064 MethodEnterEvent(self, this_object, method, 0); 1065 } 1066 } 1067 1068 TwoWordReturn Instrumentation::PopInstrumentationStackFrame(Thread* self, uintptr_t* return_pc, 1069 uint64_t gpr_result, 1070 uint64_t fpr_result) { 1071 // Do the pop. 1072 std::deque<instrumentation::InstrumentationStackFrame>* stack = self->GetInstrumentationStack(); 1073 CHECK_GT(stack->size(), 0U); 1074 InstrumentationStackFrame instrumentation_frame = stack->front(); 1075 stack->pop_front(); 1076 1077 // Set return PC and check the sanity of the stack. 1078 *return_pc = instrumentation_frame.return_pc_; 1079 CheckStackDepth(self, instrumentation_frame, 0); 1080 self->VerifyStack(); 1081 1082 ArtMethod* method = instrumentation_frame.method_; 1083 uint32_t length; 1084 const PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 1085 char return_shorty = method->GetInterfaceMethodIfProxy(pointer_size)->GetShorty(&length)[0]; 1086 JValue return_value; 1087 if (return_shorty == 'V') { 1088 return_value.SetJ(0); 1089 } else if (return_shorty == 'F' || return_shorty == 'D') { 1090 return_value.SetJ(fpr_result); 1091 } else { 1092 return_value.SetJ(gpr_result); 1093 } 1094 // TODO: improve the dex pc information here, requires knowledge of current PC as opposed to 1095 // return_pc. 1096 uint32_t dex_pc = DexFile::kDexNoIndex; 1097 mirror::Object* this_object = instrumentation_frame.this_object_; 1098 if (!instrumentation_frame.interpreter_entry_) { 1099 MethodExitEvent(self, this_object, instrumentation_frame.method_, dex_pc, return_value); 1100 } 1101 1102 // Deoptimize if the caller needs to continue execution in the interpreter. Do nothing if we get 1103 // back to an upcall. 1104 NthCallerVisitor visitor(self, 1, true); 1105 visitor.WalkStack(true); 1106 bool deoptimize = (visitor.caller != nullptr) && 1107 (interpreter_stubs_installed_ || IsDeoptimized(visitor.caller) || 1108 Dbg::IsForcedInterpreterNeededForUpcall(self, visitor.caller)); 1109 if (deoptimize && Runtime::Current()->IsAsyncDeoptimizeable(*return_pc)) { 1110 if (kVerboseInstrumentation) { 1111 LOG(INFO) << "Deoptimizing " 1112 << visitor.caller->PrettyMethod() 1113 << " by returning from " 1114 << method->PrettyMethod() 1115 << " with result " 1116 << std::hex << return_value.GetJ() << std::dec 1117 << " in " 1118 << *self; 1119 } 1120 self->PushDeoptimizationContext(return_value, 1121 return_shorty == 'L', 1122 false /* from_code */, 1123 nullptr /* no pending exception */); 1124 return GetTwoWordSuccessValue(*return_pc, 1125 reinterpret_cast<uintptr_t>(GetQuickDeoptimizationEntryPoint())); 1126 } else { 1127 if (deoptimize && !Runtime::Current()->IsAsyncDeoptimizeable(*return_pc)) { 1128 LOG(WARNING) << "Got a deoptimization request on un-deoptimizable " << method->PrettyMethod() 1129 << " at PC " << reinterpret_cast<void*>(*return_pc); 1130 } 1131 if (kVerboseInstrumentation) { 1132 LOG(INFO) << "Returning from " << method->PrettyMethod() 1133 << " to PC " << reinterpret_cast<void*>(*return_pc); 1134 } 1135 return GetTwoWordSuccessValue(0, *return_pc); 1136 } 1137 } 1138 1139 uintptr_t Instrumentation::PopMethodForUnwind(Thread* self, bool is_deoptimization) const { 1140 // Do the pop. 1141 std::deque<instrumentation::InstrumentationStackFrame>* stack = self->GetInstrumentationStack(); 1142 CHECK_GT(stack->size(), 0U); 1143 InstrumentationStackFrame instrumentation_frame = stack->front(); 1144 // TODO: bring back CheckStackDepth(self, instrumentation_frame, 2); 1145 stack->pop_front(); 1146 1147 ArtMethod* method = instrumentation_frame.method_; 1148 if (is_deoptimization) { 1149 if (kVerboseInstrumentation) { 1150 LOG(INFO) << "Popping for deoptimization " << ArtMethod::PrettyMethod(method); 1151 } 1152 } else { 1153 if (kVerboseInstrumentation) { 1154 LOG(INFO) << "Popping for unwind " << ArtMethod::PrettyMethod(method); 1155 } 1156 1157 // Notify listeners of method unwind. 1158 // TODO: improve the dex pc information here, requires knowledge of current PC as opposed to 1159 // return_pc. 1160 uint32_t dex_pc = DexFile::kDexNoIndex; 1161 MethodUnwindEvent(self, instrumentation_frame.this_object_, method, dex_pc); 1162 } 1163 return instrumentation_frame.return_pc_; 1164 } 1165 1166 std::string InstrumentationStackFrame::Dump() const { 1167 std::ostringstream os; 1168 os << "Frame " << frame_id_ << " " << ArtMethod::PrettyMethod(method_) << ":" 1169 << reinterpret_cast<void*>(return_pc_) << " this=" << reinterpret_cast<void*>(this_object_); 1170 return os.str(); 1171 } 1172 1173 } // namespace instrumentation 1174 } // namespace art 1175
