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