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