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