1 //===-- StopInfo.cpp --------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include <string> 11 12 #include "lldb/Breakpoint/Breakpoint.h" 13 #include "lldb/Breakpoint/BreakpointLocation.h" 14 #include "lldb/Breakpoint/StoppointCallbackContext.h" 15 #include "lldb/Breakpoint/Watchpoint.h" 16 #include "lldb/Core/Debugger.h" 17 #include "lldb/Core/ValueObject.h" 18 #include "lldb/Expression/UserExpression.h" 19 #include "lldb/Target/Process.h" 20 #include "lldb/Target/StopInfo.h" 21 #include "lldb/Target/Target.h" 22 #include "lldb/Target/Thread.h" 23 #include "lldb/Target/ThreadPlan.h" 24 #include "lldb/Target/UnixSignals.h" 25 #include "lldb/Utility/Log.h" 26 #include "lldb/Utility/StreamString.h" 27 28 using namespace lldb; 29 using namespace lldb_private; 30 31 StopInfo::StopInfo(Thread &thread, uint64_t value) 32 : m_thread_wp(thread.shared_from_this()), 33 m_stop_id(thread.GetProcess()->GetStopID()), 34 m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value), 35 m_description(), m_override_should_notify(eLazyBoolCalculate), 36 m_override_should_stop(eLazyBoolCalculate), m_extended_info() {} 37 38 bool StopInfo::IsValid() const { 39 ThreadSP thread_sp(m_thread_wp.lock()); 40 if (thread_sp) 41 return thread_sp->GetProcess()->GetStopID() == m_stop_id; 42 return false; 43 } 44 45 void StopInfo::MakeStopInfoValid() { 46 ThreadSP thread_sp(m_thread_wp.lock()); 47 if (thread_sp) { 48 m_stop_id = thread_sp->GetProcess()->GetStopID(); 49 m_resume_id = thread_sp->GetProcess()->GetResumeID(); 50 } 51 } 52 53 bool StopInfo::HasTargetRunSinceMe() { 54 ThreadSP thread_sp(m_thread_wp.lock()); 55 56 if (thread_sp) { 57 lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState(); 58 if (ret_type == eStateRunning) { 59 return true; 60 } else if (ret_type == eStateStopped) { 61 // This is a little tricky. We want to count "run and stopped again 62 // before you could ask this question as a "TRUE" answer to 63 // HasTargetRunSinceMe. But we don't want to include any running of the 64 // target done for expressions. So we track both resumes, and resumes 65 // caused by expressions, and check if there are any resumes 66 // NOT caused 67 // by expressions. 68 69 uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID(); 70 uint32_t last_user_expression_id = 71 thread_sp->GetProcess()->GetLastUserExpressionResumeID(); 72 if (curr_resume_id == m_resume_id) { 73 return false; 74 } else if (curr_resume_id > last_user_expression_id) { 75 return true; 76 } 77 } 78 } 79 return false; 80 } 81 82 //---------------------------------------------------------------------- 83 // StopInfoBreakpoint 84 //---------------------------------------------------------------------- 85 86 namespace lldb_private { 87 class StopInfoBreakpoint : public StopInfo { 88 public: 89 StopInfoBreakpoint(Thread &thread, break_id_t break_id) 90 : StopInfo(thread, break_id), m_should_stop(false), 91 m_should_stop_is_valid(false), m_should_perform_action(true), 92 m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID), 93 m_was_one_shot(false) { 94 StoreBPInfo(); 95 } 96 97 StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop) 98 : StopInfo(thread, break_id), m_should_stop(should_stop), 99 m_should_stop_is_valid(true), m_should_perform_action(true), 100 m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID), 101 m_was_one_shot(false) { 102 StoreBPInfo(); 103 } 104 105 ~StopInfoBreakpoint() override = default; 106 107 void StoreBPInfo() { 108 ThreadSP thread_sp(m_thread_wp.lock()); 109 if (thread_sp) { 110 BreakpointSiteSP bp_site_sp( 111 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value)); 112 if (bp_site_sp) { 113 if (bp_site_sp->GetNumberOfOwners() == 1) { 114 BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0); 115 if (bp_loc_sp) { 116 m_break_id = bp_loc_sp->GetBreakpoint().GetID(); 117 m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot(); 118 } 119 } 120 m_address = bp_site_sp->GetLoadAddress(); 121 } 122 } 123 } 124 125 bool IsValidForOperatingSystemThread(Thread &thread) override { 126 ProcessSP process_sp(thread.GetProcess()); 127 if (process_sp) { 128 BreakpointSiteSP bp_site_sp( 129 process_sp->GetBreakpointSiteList().FindByID(m_value)); 130 if (bp_site_sp) 131 return bp_site_sp->ValidForThisThread(&thread); 132 } 133 return false; 134 } 135 136 StopReason GetStopReason() const override { return eStopReasonBreakpoint; } 137 138 bool ShouldStopSynchronous(Event *event_ptr) override { 139 ThreadSP thread_sp(m_thread_wp.lock()); 140 if (thread_sp) { 141 if (!m_should_stop_is_valid) { 142 // Only check once if we should stop at a breakpoint 143 BreakpointSiteSP bp_site_sp( 144 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value)); 145 if (bp_site_sp) { 146 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0)); 147 StoppointCallbackContext context(event_ptr, exe_ctx, true); 148 bp_site_sp->BumpHitCounts(); 149 m_should_stop = bp_site_sp->ShouldStop(&context); 150 } else { 151 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 152 153 if (log) 154 log->Printf( 155 "Process::%s could not find breakpoint site id: %" PRId64 "...", 156 __FUNCTION__, m_value); 157 158 m_should_stop = true; 159 } 160 m_should_stop_is_valid = true; 161 } 162 return m_should_stop; 163 } 164 return false; 165 } 166 167 bool DoShouldNotify(Event *event_ptr) override { 168 ThreadSP thread_sp(m_thread_wp.lock()); 169 if (thread_sp) { 170 BreakpointSiteSP bp_site_sp( 171 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value)); 172 if (bp_site_sp) { 173 bool all_internal = true; 174 175 for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) { 176 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) { 177 all_internal = false; 178 break; 179 } 180 } 181 return !all_internal; 182 } 183 } 184 return true; 185 } 186 187 const char *GetDescription() override { 188 if (m_description.empty()) { 189 ThreadSP thread_sp(m_thread_wp.lock()); 190 if (thread_sp) { 191 BreakpointSiteSP bp_site_sp( 192 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value)); 193 if (bp_site_sp) { 194 StreamString strm; 195 // If we have just hit an internal breakpoint, and it has a kind 196 // description, print that instead of the full breakpoint printing: 197 if (bp_site_sp->IsInternal()) { 198 size_t num_owners = bp_site_sp->GetNumberOfOwners(); 199 for (size_t idx = 0; idx < num_owners; idx++) { 200 const char *kind = bp_site_sp->GetOwnerAtIndex(idx) 201 ->GetBreakpoint() 202 .GetBreakpointKind(); 203 if (kind != nullptr) { 204 m_description.assign(kind); 205 return kind; 206 } 207 } 208 } 209 210 strm.Printf("breakpoint "); 211 bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief); 212 m_description = strm.GetString(); 213 } else { 214 StreamString strm; 215 if (m_break_id != LLDB_INVALID_BREAK_ID) { 216 BreakpointSP break_sp = 217 thread_sp->GetProcess()->GetTarget().GetBreakpointByID( 218 m_break_id); 219 if (break_sp) { 220 if (break_sp->IsInternal()) { 221 const char *kind = break_sp->GetBreakpointKind(); 222 if (kind) 223 strm.Printf("internal %s breakpoint(%d).", kind, m_break_id); 224 else 225 strm.Printf("internal breakpoint(%d).", m_break_id); 226 } else { 227 strm.Printf("breakpoint %d.", m_break_id); 228 } 229 } else { 230 if (m_was_one_shot) 231 strm.Printf("one-shot breakpoint %d", m_break_id); 232 else 233 strm.Printf("breakpoint %d which has been deleted.", 234 m_break_id); 235 } 236 } else if (m_address == LLDB_INVALID_ADDRESS) 237 strm.Printf("breakpoint site %" PRIi64 238 " which has been deleted - unknown address", 239 m_value); 240 else 241 strm.Printf("breakpoint site %" PRIi64 242 " which has been deleted - was at 0x%" PRIx64, 243 m_value, m_address); 244 245 m_description = strm.GetString(); 246 } 247 } 248 } 249 return m_description.c_str(); 250 } 251 252 protected: 253 bool ShouldStop(Event *event_ptr) override { 254 // This just reports the work done by PerformAction or the synchronous 255 // stop. It should only ever get called after they have had a chance to 256 // run. 257 assert(m_should_stop_is_valid); 258 return m_should_stop; 259 } 260 261 void PerformAction(Event *event_ptr) override { 262 if (!m_should_perform_action) 263 return; 264 m_should_perform_action = false; 265 bool internal_breakpoint = true; 266 267 ThreadSP thread_sp(m_thread_wp.lock()); 268 269 if (thread_sp) { 270 Log *log = lldb_private::GetLogIfAnyCategoriesSet( 271 LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP); 272 273 if (!thread_sp->IsValid()) { 274 // This shouldn't ever happen, but just in case, don't do more harm. 275 if (log) { 276 log->Printf("PerformAction got called with an invalid thread."); 277 } 278 m_should_stop = true; 279 m_should_stop_is_valid = true; 280 return; 281 } 282 283 BreakpointSiteSP bp_site_sp( 284 thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value)); 285 std::unordered_set<break_id_t> precondition_breakpoints; 286 287 if (bp_site_sp) { 288 // Let's copy the owners list out of the site and store them in a local 289 // list. That way if one of the breakpoint actions changes the site, 290 // then we won't be operating on a bad list. 291 BreakpointLocationCollection site_locations; 292 size_t num_owners = bp_site_sp->CopyOwnersList(site_locations); 293 294 if (num_owners == 0) { 295 m_should_stop = true; 296 } else { 297 // We go through each location, and test first its precondition - 298 // this overrides everything. Note, we only do this once per 299 // breakpoint - not once per location... Then check the condition. 300 // If the condition says to stop, then we run the callback for that 301 // location. If that callback says to stop as well, then we set 302 // m_should_stop to true; we are going to stop. But we still want to 303 // give all the breakpoints whose conditions say we are going to stop 304 // a chance to run their callbacks. Of course if any callback 305 // restarts the target by putting "continue" in the callback, then 306 // we're going to restart, without running the rest of the callbacks. 307 // And in this case we will end up not stopping even if another 308 // location said we should stop. But that's better than not running 309 // all the callbacks. 310 311 m_should_stop = false; 312 313 // We don't select threads as we go through them testing breakpoint 314 // conditions and running commands. So we need to set the thread for 315 // expression evaluation here: 316 ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp); 317 318 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0)); 319 Process *process = exe_ctx.GetProcessPtr(); 320 if (process->GetModIDRef().IsLastResumeForUserExpression()) { 321 // If we are in the middle of evaluating an expression, don't run 322 // asynchronous breakpoint commands or expressions. That could 323 // lead to infinite recursion if the command or condition re-calls 324 // the function with this breakpoint. 325 // TODO: We can keep a list of the breakpoints we've seen while 326 // running expressions in the nested 327 // PerformAction calls that can arise when the action runs a 328 // function that hits another breakpoint, and only stop running 329 // commands when we see the same breakpoint hit a second time. 330 331 m_should_stop_is_valid = true; 332 333 // It is possible that the user has a breakpoint at the same site 334 // as the completed plan had (e.g. user has a breakpoint 335 // on a module entry point, and `ThreadPlanCallFunction` ends 336 // also there). We can't find an internal breakpoint in the loop 337 // later because it was already removed on the plan completion. 338 // So check if the plan was completed, and stop if so. 339 if (thread_sp->CompletedPlanOverridesBreakpoint()) { 340 m_should_stop = true; 341 thread_sp->ResetStopInfo(); 342 return; 343 } 344 345 if (log) 346 log->Printf("StopInfoBreakpoint::PerformAction - Hit a " 347 "breakpoint while running an expression," 348 " not running commands to avoid recursion."); 349 bool ignoring_breakpoints = 350 process->GetIgnoreBreakpointsInExpressions(); 351 if (ignoring_breakpoints) { 352 m_should_stop = false; 353 // Internal breakpoints will always stop. 354 for (size_t j = 0; j < num_owners; j++) { 355 lldb::BreakpointLocationSP bp_loc_sp = 356 bp_site_sp->GetOwnerAtIndex(j); 357 if (bp_loc_sp->GetBreakpoint().IsInternal()) { 358 m_should_stop = true; 359 break; 360 } 361 } 362 } else { 363 m_should_stop = true; 364 } 365 if (log) 366 log->Printf("StopInfoBreakpoint::PerformAction - in expression, " 367 "continuing: %s.", 368 m_should_stop ? "true" : "false"); 369 process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf( 370 "Warning: hit breakpoint while running function, skipping " 371 "commands and conditions to prevent recursion.\n"); 372 return; 373 } 374 375 StoppointCallbackContext context(event_ptr, exe_ctx, false); 376 377 // For safety's sake let's also grab an extra reference to the 378 // breakpoint owners of the locations we're going to examine, since 379 // the locations are going to have to get back to their breakpoints, 380 // and the locations don't keep their owners alive. I'm just 381 // sticking the BreakpointSP's in a vector since I'm only using it to 382 // locally increment their retain counts. 383 384 std::vector<lldb::BreakpointSP> location_owners; 385 386 for (size_t j = 0; j < num_owners; j++) { 387 BreakpointLocationSP loc(site_locations.GetByIndex(j)); 388 location_owners.push_back(loc->GetBreakpoint().shared_from_this()); 389 } 390 391 for (size_t j = 0; j < num_owners; j++) { 392 lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j); 393 StreamString loc_desc; 394 if (log) { 395 bp_loc_sp->GetDescription(&loc_desc, eDescriptionLevelBrief); 396 } 397 // If another action disabled this breakpoint or its location, then 398 // don't run the actions. 399 if (!bp_loc_sp->IsEnabled() || 400 !bp_loc_sp->GetBreakpoint().IsEnabled()) 401 continue; 402 403 // The breakpoint site may have many locations associated with it, 404 // not all of them valid for this thread. Skip the ones that 405 // aren't: 406 if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) { 407 if (log) { 408 log->Printf("Breakpoint %s hit on thread 0x%llx but it was not " 409 "for this thread, continuing.", 410 loc_desc.GetData(), static_cast<unsigned long long>( 411 thread_sp->GetID())); 412 } 413 continue; 414 } 415 416 internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal(); 417 418 // First run the precondition, but since the precondition is per 419 // breakpoint, only run it once per breakpoint. 420 std::pair<std::unordered_set<break_id_t>::iterator, bool> result = 421 precondition_breakpoints.insert( 422 bp_loc_sp->GetBreakpoint().GetID()); 423 if (!result.second) 424 continue; 425 426 bool precondition_result = 427 bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context); 428 if (!precondition_result) 429 continue; 430 431 // Next run the condition for the breakpoint. If that says we 432 // should stop, then we'll run the callback for the breakpoint. If 433 // the callback says we shouldn't stop that will win. 434 435 if (bp_loc_sp->GetConditionText() != nullptr) { 436 Status condition_error; 437 bool condition_says_stop = 438 bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error); 439 440 if (!condition_error.Success()) { 441 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); 442 StreamSP error_sp = debugger.GetAsyncErrorStream(); 443 error_sp->Printf("Stopped due to an error evaluating condition " 444 "of breakpoint "); 445 bp_loc_sp->GetDescription(error_sp.get(), 446 eDescriptionLevelBrief); 447 error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText()); 448 error_sp->EOL(); 449 const char *err_str = 450 condition_error.AsCString("<Unknown Error>"); 451 if (log) 452 log->Printf("Error evaluating condition: \"%s\"\n", err_str); 453 454 error_sp->PutCString(err_str); 455 error_sp->EOL(); 456 error_sp->Flush(); 457 } else { 458 if (log) { 459 log->Printf("Condition evaluated for breakpoint %s on thread " 460 "0x%llx conditon_says_stop: %i.", 461 loc_desc.GetData(), 462 static_cast<unsigned long long>( 463 thread_sp->GetID()), 464 condition_says_stop); 465 } 466 if (!condition_says_stop) { 467 // We don't want to increment the hit count of breakpoints if 468 // the condition fails. We've already bumped it by the time 469 // we get here, so undo the bump: 470 bp_loc_sp->UndoBumpHitCount(); 471 continue; 472 } 473 } 474 } 475 476 // Check the auto-continue bit on the location, do this before the 477 // callback since it may change this, but that would be for the 478 // NEXT hit. Note, you might think you could check auto-continue 479 // before the condition, and not evaluate the condition if it says 480 // to continue. But failing the condition means the breakpoint was 481 // effectively NOT HIT. So these two states are different. 482 bool auto_continue_says_stop = true; 483 if (bp_loc_sp->IsAutoContinue()) 484 { 485 if (log) 486 log->Printf("Continuing breakpoint %s as AutoContinue was set.", 487 loc_desc.GetData()); 488 // We want this stop reported, so you will know we auto-continued 489 // but only for external breakpoints: 490 if (!internal_breakpoint) 491 thread_sp->SetShouldReportStop(eVoteYes); 492 auto_continue_says_stop = false; 493 } 494 495 bool callback_says_stop = true; 496 497 // FIXME: For now the callbacks have to run in async mode - the 498 // first time we restart we need 499 // to get out of there. So set it here. 500 // When we figure out how to nest breakpoint hits then this will 501 // change. 502 503 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger(); 504 bool old_async = debugger.GetAsyncExecution(); 505 debugger.SetAsyncExecution(true); 506 507 callback_says_stop = bp_loc_sp->InvokeCallback(&context); 508 509 debugger.SetAsyncExecution(old_async); 510 511 if (callback_says_stop && auto_continue_says_stop) 512 m_should_stop = true; 513 514 // If we are going to stop for this breakpoint, then remove the 515 // breakpoint. 516 if (callback_says_stop && bp_loc_sp && 517 bp_loc_sp->GetBreakpoint().IsOneShot()) { 518 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID( 519 bp_loc_sp->GetBreakpoint().GetID()); 520 } 521 // Also make sure that the callback hasn't continued the target. If 522 // it did, when we'll set m_should_start to false and get out of 523 // here. 524 if (HasTargetRunSinceMe()) { 525 m_should_stop = false; 526 break; 527 } 528 } 529 } 530 // We've figured out what this stop wants to do, so mark it as valid so 531 // we don't compute it again. 532 m_should_stop_is_valid = true; 533 } else { 534 m_should_stop = true; 535 m_should_stop_is_valid = true; 536 Log *log_process( 537 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 538 539 if (log_process) 540 log_process->Printf( 541 "Process::%s could not find breakpoint site id: %" PRId64 "...", 542 __FUNCTION__, m_value); 543 } 544 545 if ((!m_should_stop || internal_breakpoint) && 546 thread_sp->CompletedPlanOverridesBreakpoint()) { 547 548 // Override should_stop decision when we have completed step plan 549 // additionally to the breakpoint 550 m_should_stop = true; 551 552 // Here we clean the preset stop info so the next GetStopInfo call will 553 // find the appropriate stop info, which should be the stop info 554 // related to the completed plan 555 thread_sp->ResetStopInfo(); 556 } 557 558 if (log) 559 log->Printf("Process::%s returning from action with m_should_stop: %d.", 560 __FUNCTION__, m_should_stop); 561 } 562 } 563 564 private: 565 bool m_should_stop; 566 bool m_should_stop_is_valid; 567 bool m_should_perform_action; // Since we are trying to preserve the "state" 568 // of the system even if we run functions 569 // etc. behind the users backs, we need to make sure we only REALLY perform 570 // the action once. 571 lldb::addr_t m_address; // We use this to capture the breakpoint site address 572 // when we create the StopInfo, 573 // in case somebody deletes it between the time the StopInfo is made and the 574 // description is asked for. 575 lldb::break_id_t m_break_id; 576 bool m_was_one_shot; 577 }; 578 579 //---------------------------------------------------------------------- 580 // StopInfoWatchpoint 581 //---------------------------------------------------------------------- 582 583 class StopInfoWatchpoint : public StopInfo { 584 public: 585 // Make sure watchpoint is properly disabled and subsequently enabled while 586 // performing watchpoint actions. 587 class WatchpointSentry { 588 public: 589 WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp), 590 watchpoint_sp(w_sp) { 591 if (process_sp && watchpoint_sp) { 592 const bool notify = false; 593 watchpoint_sp->TurnOnEphemeralMode(); 594 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify); 595 process_sp->AddPreResumeAction(SentryPreResumeAction, this); 596 } 597 } 598 599 void DoReenable() { 600 if (process_sp && watchpoint_sp) { 601 bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode(); 602 watchpoint_sp->TurnOffEphemeralMode(); 603 const bool notify = false; 604 if (was_disabled) { 605 process_sp->DisableWatchpoint(watchpoint_sp.get(), notify); 606 } else { 607 process_sp->EnableWatchpoint(watchpoint_sp.get(), notify); 608 } 609 } 610 } 611 612 ~WatchpointSentry() { 613 DoReenable(); 614 if (process_sp) 615 process_sp->ClearPreResumeAction(SentryPreResumeAction, this); 616 } 617 618 static bool SentryPreResumeAction(void *sentry_void) { 619 WatchpointSentry *sentry = (WatchpointSentry *) sentry_void; 620 sentry->DoReenable(); 621 return true; 622 } 623 624 private: 625 ProcessSP process_sp; 626 WatchpointSP watchpoint_sp; 627 }; 628 629 StopInfoWatchpoint(Thread &thread, break_id_t watch_id, 630 lldb::addr_t watch_hit_addr) 631 : StopInfo(thread, watch_id), m_should_stop(false), 632 m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {} 633 634 ~StopInfoWatchpoint() override = default; 635 636 StopReason GetStopReason() const override { return eStopReasonWatchpoint; } 637 638 const char *GetDescription() override { 639 if (m_description.empty()) { 640 StreamString strm; 641 strm.Printf("watchpoint %" PRIi64, m_value); 642 m_description = strm.GetString(); 643 } 644 return m_description.c_str(); 645 } 646 647 protected: 648 bool ShouldStopSynchronous(Event *event_ptr) override { 649 // ShouldStop() method is idempotent and should not affect hit count. See 650 // Process::RunPrivateStateThread()->Process()->HandlePrivateEvent() 651 // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()-> 652 // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()-> 653 // StopInfoWatchpoint::ShouldStop() and 654 // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()-> 655 // StopInfoWatchpoint::PerformAction(). 656 if (m_should_stop_is_valid) 657 return m_should_stop; 658 659 ThreadSP thread_sp(m_thread_wp.lock()); 660 if (thread_sp) { 661 WatchpointSP wp_sp( 662 thread_sp->CalculateTarget()->GetWatchpointList().FindByID( 663 GetValue())); 664 if (wp_sp) { 665 // Check if we should stop at a watchpoint. 666 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0)); 667 StoppointCallbackContext context(event_ptr, exe_ctx, true); 668 m_should_stop = wp_sp->ShouldStop(&context); 669 } else { 670 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 671 672 if (log) 673 log->Printf( 674 "Process::%s could not find watchpoint location id: %" PRId64 675 "...", 676 __FUNCTION__, GetValue()); 677 678 m_should_stop = true; 679 } 680 } 681 m_should_stop_is_valid = true; 682 return m_should_stop; 683 } 684 685 bool ShouldStop(Event *event_ptr) override { 686 // This just reports the work done by PerformAction or the synchronous 687 // stop. It should only ever get called after they have had a chance to 688 // run. 689 assert(m_should_stop_is_valid); 690 return m_should_stop; 691 } 692 693 void PerformAction(Event *event_ptr) override { 694 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS); 695 // We're going to calculate if we should stop or not in some way during the 696 // course of this code. Also by default we're going to stop, so set that 697 // here. 698 m_should_stop = true; 699 700 701 ThreadSP thread_sp(m_thread_wp.lock()); 702 if (thread_sp) { 703 704 WatchpointSP wp_sp( 705 thread_sp->CalculateTarget()->GetWatchpointList().FindByID( 706 GetValue())); 707 if (wp_sp) { 708 ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0)); 709 ProcessSP process_sp = exe_ctx.GetProcessSP(); 710 711 { 712 // check if this process is running on an architecture where 713 // watchpoints trigger before the associated instruction runs. if so, 714 // disable the WP, single-step and then re-enable the watchpoint 715 if (process_sp) { 716 uint32_t num; 717 bool wp_triggers_after; 718 719 if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after) 720 .Success()) { 721 if (!wp_triggers_after) { 722 // We need to preserve the watch_index before watchpoint is 723 // disable. Since Watchpoint::SetEnabled will clear the watch 724 // index. This will fix TestWatchpointIter failure 725 Watchpoint *wp = wp_sp.get(); 726 uint32_t watch_index = wp->GetHardwareIndex(); 727 process_sp->DisableWatchpoint(wp, false); 728 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo(); 729 assert(stored_stop_info_sp.get() == this); 730 731 Status new_plan_status; 732 ThreadPlanSP new_plan_sp( 733 thread_sp->QueueThreadPlanForStepSingleInstruction( 734 false, // step-over 735 false, // abort_other_plans 736 true, // stop_other_threads 737 new_plan_status)); 738 if (new_plan_sp && new_plan_status.Success()) { 739 new_plan_sp->SetIsMasterPlan(true); 740 new_plan_sp->SetOkayToDiscard(false); 741 new_plan_sp->SetPrivate(true); 742 } 743 process_sp->GetThreadList().SetSelectedThreadByID( 744 thread_sp->GetID()); 745 process_sp->ResumeSynchronous(nullptr); 746 process_sp->GetThreadList().SetSelectedThreadByID( 747 thread_sp->GetID()); 748 thread_sp->SetStopInfo(stored_stop_info_sp); 749 process_sp->EnableWatchpoint(wp, false); 750 wp->SetHardwareIndex(watch_index); 751 } 752 } 753 } 754 } 755 756 // This sentry object makes sure the current watchpoint is disabled 757 // while performing watchpoint actions, and it is then enabled after we 758 // are finished. 759 WatchpointSentry sentry(process_sp, wp_sp); 760 761 /* 762 * MIPS: Last 3bits of the watchpoint address are masked by the kernel. 763 * For example: 764 * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is 765 * set at 'm', then 766 * watch exception is generated even when 'n' is read/written. To handle 767 * this case, 768 * server emulates the instruction at PC and finds the base address of 769 * the load/store 770 * instruction and appends it in the description of the stop-info 771 * packet. If watchpoint 772 * is not set on this address by user then this do not stop. 773 */ 774 if (m_watch_hit_addr != LLDB_INVALID_ADDRESS) { 775 WatchpointSP wp_hit_sp = 776 thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress( 777 m_watch_hit_addr); 778 if (!wp_hit_sp) { 779 m_should_stop = false; 780 wp_sp->IncrementFalseAlarmsAndReviseHitCount(); 781 } 782 } 783 784 // TODO: This condition should be checked in the synchronous part of the 785 // watchpoint code 786 // (Watchpoint::ShouldStop), so that we avoid pulling an event even if 787 // the watchpoint fails the ignore count condition. It is moved here 788 // temporarily, because for archs with 789 // watchpoint_exceptions_received=before, the code in the previous 790 // lines takes care of moving the inferior to next PC. We have to check 791 // the ignore count condition after this is done, otherwise we will hit 792 // same watchpoint multiple times until we pass ignore condition, but 793 // we won't actually be ignoring them. 794 if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount()) 795 m_should_stop = false; 796 797 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); 798 799 if (m_should_stop && wp_sp->GetConditionText() != nullptr) { 800 // We need to make sure the user sees any parse errors in their 801 // condition, so we'll hook the constructor errors up to the 802 // debugger's Async I/O. 803 ExpressionResults result_code; 804 EvaluateExpressionOptions expr_options; 805 expr_options.SetUnwindOnError(true); 806 expr_options.SetIgnoreBreakpoints(true); 807 ValueObjectSP result_value_sp; 808 Status error; 809 result_code = UserExpression::Evaluate( 810 exe_ctx, expr_options, wp_sp->GetConditionText(), 811 llvm::StringRef(), result_value_sp, error); 812 813 if (result_code == eExpressionCompleted) { 814 if (result_value_sp) { 815 Scalar scalar_value; 816 if (result_value_sp->ResolveValue(scalar_value)) { 817 if (scalar_value.ULongLong(1) == 0) { 818 // We have been vetoed. This takes precedence over querying 819 // the watchpoint whether it should stop (aka ignore count 820 // and friends). See also StopInfoWatchpoint::ShouldStop() 821 // as well as Process::ProcessEventData::DoOnRemoval(). 822 m_should_stop = false; 823 } else 824 m_should_stop = true; 825 if (log) 826 log->Printf( 827 "Condition successfully evaluated, result is %s.\n", 828 m_should_stop ? "true" : "false"); 829 } else { 830 m_should_stop = true; 831 if (log) 832 log->Printf( 833 "Failed to get an integer result from the expression."); 834 } 835 } 836 } else { 837 StreamSP error_sp = debugger.GetAsyncErrorStream(); 838 error_sp->Printf( 839 "Stopped due to an error evaluating condition of watchpoint "); 840 wp_sp->GetDescription(error_sp.get(), eDescriptionLevelBrief); 841 error_sp->Printf(": \"%s\"", wp_sp->GetConditionText()); 842 error_sp->EOL(); 843 const char *err_str = error.AsCString("<Unknown Error>"); 844 if (log) 845 log->Printf("Error evaluating condition: \"%s\"\n", err_str); 846 847 error_sp->PutCString(err_str); 848 error_sp->EOL(); 849 error_sp->Flush(); 850 // If the condition fails to be parsed or run, we should stop. 851 m_should_stop = true; 852 } 853 } 854 855 // If the condition says to stop, we run the callback to further decide 856 // whether to stop. 857 if (m_should_stop) { 858 // FIXME: For now the callbacks have to run in async mode - the 859 // first time we restart we need 860 // to get out of there. So set it here. 861 // When we figure out how to nest watchpoint hits then this will 862 // change. 863 864 bool old_async = debugger.GetAsyncExecution(); 865 debugger.SetAsyncExecution(true); 866 867 StoppointCallbackContext context(event_ptr, exe_ctx, false); 868 bool stop_requested = wp_sp->InvokeCallback(&context); 869 870 debugger.SetAsyncExecution(old_async); 871 872 // Also make sure that the callback hasn't continued the target. If 873 // it did, when we'll set m_should_stop to false and get out of here. 874 if (HasTargetRunSinceMe()) 875 m_should_stop = false; 876 877 if (m_should_stop && !stop_requested) { 878 // We have been vetoed by the callback mechanism. 879 m_should_stop = false; 880 } 881 } 882 // Finally, if we are going to stop, print out the new & old values: 883 if (m_should_stop) { 884 wp_sp->CaptureWatchedValue(exe_ctx); 885 886 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); 887 StreamSP output_sp = debugger.GetAsyncOutputStream(); 888 wp_sp->DumpSnapshots(output_sp.get()); 889 output_sp->EOL(); 890 output_sp->Flush(); 891 } 892 893 } else { 894 Log *log_process( 895 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 896 897 if (log_process) 898 log_process->Printf( 899 "Process::%s could not find watchpoint id: %" PRId64 "...", 900 __FUNCTION__, m_value); 901 } 902 if (log) 903 log->Printf("Process::%s returning from action with m_should_stop: %d.", 904 __FUNCTION__, m_should_stop); 905 906 m_should_stop_is_valid = true; 907 } 908 } 909 910 private: 911 bool m_should_stop; 912 bool m_should_stop_is_valid; 913 lldb::addr_t m_watch_hit_addr; 914 }; 915 916 //---------------------------------------------------------------------- 917 // StopInfoUnixSignal 918 //---------------------------------------------------------------------- 919 920 class StopInfoUnixSignal : public StopInfo { 921 public: 922 StopInfoUnixSignal(Thread &thread, int signo, const char *description) 923 : StopInfo(thread, signo) { 924 SetDescription(description); 925 } 926 927 ~StopInfoUnixSignal() override = default; 928 929 StopReason GetStopReason() const override { return eStopReasonSignal; } 930 931 bool ShouldStopSynchronous(Event *event_ptr) override { 932 ThreadSP thread_sp(m_thread_wp.lock()); 933 if (thread_sp) 934 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value); 935 return false; 936 } 937 938 bool ShouldStop(Event *event_ptr) override { 939 ThreadSP thread_sp(m_thread_wp.lock()); 940 if (thread_sp) 941 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value); 942 return false; 943 } 944 945 // If should stop returns false, check if we should notify of this event 946 bool DoShouldNotify(Event *event_ptr) override { 947 ThreadSP thread_sp(m_thread_wp.lock()); 948 if (thread_sp) { 949 bool should_notify = 950 thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value); 951 if (should_notify) { 952 StreamString strm; 953 strm.Printf( 954 "thread %d received signal: %s", thread_sp->GetIndexID(), 955 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString( 956 m_value)); 957 Process::ProcessEventData::AddRestartedReason(event_ptr, 958 strm.GetData()); 959 } 960 return should_notify; 961 } 962 return true; 963 } 964 965 void WillResume(lldb::StateType resume_state) override { 966 ThreadSP thread_sp(m_thread_wp.lock()); 967 if (thread_sp) { 968 if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress( 969 m_value)) 970 thread_sp->SetResumeSignal(m_value); 971 } 972 } 973 974 const char *GetDescription() override { 975 if (m_description.empty()) { 976 ThreadSP thread_sp(m_thread_wp.lock()); 977 if (thread_sp) { 978 StreamString strm; 979 const char *signal_name = 980 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString( 981 m_value); 982 if (signal_name) 983 strm.Printf("signal %s", signal_name); 984 else 985 strm.Printf("signal %" PRIi64, m_value); 986 m_description = strm.GetString(); 987 } 988 } 989 return m_description.c_str(); 990 } 991 }; 992 993 //---------------------------------------------------------------------- 994 // StopInfoTrace 995 //---------------------------------------------------------------------- 996 997 class StopInfoTrace : public StopInfo { 998 public: 999 StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {} 1000 1001 ~StopInfoTrace() override = default; 1002 1003 StopReason GetStopReason() const override { return eStopReasonTrace; } 1004 1005 const char *GetDescription() override { 1006 if (m_description.empty()) 1007 return "trace"; 1008 else 1009 return m_description.c_str(); 1010 } 1011 }; 1012 1013 //---------------------------------------------------------------------- 1014 // StopInfoException 1015 //---------------------------------------------------------------------- 1016 1017 class StopInfoException : public StopInfo { 1018 public: 1019 StopInfoException(Thread &thread, const char *description) 1020 : StopInfo(thread, LLDB_INVALID_UID) { 1021 if (description) 1022 SetDescription(description); 1023 } 1024 1025 ~StopInfoException() override = default; 1026 1027 StopReason GetStopReason() const override { return eStopReasonException; } 1028 1029 const char *GetDescription() override { 1030 if (m_description.empty()) 1031 return "exception"; 1032 else 1033 return m_description.c_str(); 1034 } 1035 }; 1036 1037 //---------------------------------------------------------------------- 1038 // StopInfoThreadPlan 1039 //---------------------------------------------------------------------- 1040 1041 class StopInfoThreadPlan : public StopInfo { 1042 public: 1043 StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, 1044 ExpressionVariableSP &expression_variable_sp) 1045 : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp), 1046 m_return_valobj_sp(return_valobj_sp), 1047 m_expression_variable_sp(expression_variable_sp) {} 1048 1049 ~StopInfoThreadPlan() override = default; 1050 1051 StopReason GetStopReason() const override { return eStopReasonPlanComplete; } 1052 1053 const char *GetDescription() override { 1054 if (m_description.empty()) { 1055 StreamString strm; 1056 m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief); 1057 m_description = strm.GetString(); 1058 } 1059 return m_description.c_str(); 1060 } 1061 1062 ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; } 1063 1064 ExpressionVariableSP GetExpressionVariable() { 1065 return m_expression_variable_sp; 1066 } 1067 1068 protected: 1069 bool ShouldStop(Event *event_ptr) override { 1070 if (m_plan_sp) 1071 return m_plan_sp->ShouldStop(event_ptr); 1072 else 1073 return StopInfo::ShouldStop(event_ptr); 1074 } 1075 1076 private: 1077 ThreadPlanSP m_plan_sp; 1078 ValueObjectSP m_return_valobj_sp; 1079 ExpressionVariableSP m_expression_variable_sp; 1080 }; 1081 1082 //---------------------------------------------------------------------- 1083 // StopInfoExec 1084 //---------------------------------------------------------------------- 1085 1086 class StopInfoExec : public StopInfo { 1087 public: 1088 StopInfoExec(Thread &thread) 1089 : StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {} 1090 1091 ~StopInfoExec() override = default; 1092 1093 bool ShouldStop(Event *event_ptr) override { 1094 ThreadSP thread_sp(m_thread_wp.lock()); 1095 if (thread_sp) 1096 return thread_sp->GetProcess()->GetStopOnExec(); 1097 return false; 1098 } 1099 1100 StopReason GetStopReason() const override { return eStopReasonExec; } 1101 1102 const char *GetDescription() override { return "exec"; } 1103 1104 protected: 1105 void PerformAction(Event *event_ptr) override { 1106 // Only perform the action once 1107 if (m_performed_action) 1108 return; 1109 m_performed_action = true; 1110 ThreadSP thread_sp(m_thread_wp.lock()); 1111 if (thread_sp) 1112 thread_sp->GetProcess()->DidExec(); 1113 } 1114 1115 bool m_performed_action; 1116 }; 1117 1118 } // namespace lldb_private 1119 1120 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread, 1121 break_id_t break_id) { 1122 return StopInfoSP(new StopInfoBreakpoint(thread, break_id)); 1123 } 1124 1125 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread, 1126 break_id_t break_id, 1127 bool should_stop) { 1128 return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop)); 1129 } 1130 1131 StopInfoSP 1132 StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, break_id_t watch_id, 1133 lldb::addr_t watch_hit_addr) { 1134 return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr)); 1135 } 1136 1137 StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo, 1138 const char *description) { 1139 return StopInfoSP(new StopInfoUnixSignal(thread, signo, description)); 1140 } 1141 1142 StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) { 1143 return StopInfoSP(new StopInfoTrace(thread)); 1144 } 1145 1146 StopInfoSP StopInfo::CreateStopReasonWithPlan( 1147 ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp, 1148 ExpressionVariableSP expression_variable_sp) { 1149 return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp, 1150 expression_variable_sp)); 1151 } 1152 1153 StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread, 1154 const char *description) { 1155 return StopInfoSP(new StopInfoException(thread, description)); 1156 } 1157 1158 StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) { 1159 return StopInfoSP(new StopInfoExec(thread)); 1160 } 1161 1162 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) { 1163 if (stop_info_sp && 1164 stop_info_sp->GetStopReason() == eStopReasonPlanComplete) { 1165 StopInfoThreadPlan *plan_stop_info = 1166 static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); 1167 return plan_stop_info->GetReturnValueObject(); 1168 } else 1169 return ValueObjectSP(); 1170 } 1171 1172 ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) { 1173 if (stop_info_sp && 1174 stop_info_sp->GetStopReason() == eStopReasonPlanComplete) { 1175 StopInfoThreadPlan *plan_stop_info = 1176 static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); 1177 return plan_stop_info->GetExpressionVariable(); 1178 } else 1179 return ExpressionVariableSP(); 1180 } 1181 1182 lldb::ValueObjectSP 1183 StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp, 1184 lldb::addr_t *crashing_address) { 1185 if (!stop_info_sp) { 1186 return ValueObjectSP(); 1187 } 1188 1189 const char *description = stop_info_sp->GetDescription(); 1190 if (!description) { 1191 return ValueObjectSP(); 1192 } 1193 1194 ThreadSP thread_sp = stop_info_sp->GetThread(); 1195 if (!thread_sp) { 1196 return ValueObjectSP(); 1197 } 1198 1199 StackFrameSP frame_sp = thread_sp->GetSelectedFrame(); 1200 1201 if (!frame_sp) { 1202 return ValueObjectSP(); 1203 } 1204 1205 const char address_string[] = "address="; 1206 1207 const char *address_loc = strstr(description, address_string); 1208 if (!address_loc) { 1209 return ValueObjectSP(); 1210 } 1211 1212 address_loc += (sizeof(address_string) - 1); 1213 1214 uint64_t address = strtoull(address_loc, 0, 0); 1215 if (crashing_address) { 1216 *crashing_address = address; 1217 } 1218 1219 return frame_sp->GuessValueForAddress(address); 1220 } 1221