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