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