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