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