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