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