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
StopInfo(Thread & thread,uint64_t value)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
IsValid() const48 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
MakeStopInfoValid()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
HasTargetRunSinceMe()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
StopInfoBreakpoint(Thread & thread,break_id_t break_id)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
StopInfoBreakpoint(Thread & thread,break_id_t break_id,bool should_stop)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
StoreBPInfo()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
~StopInfoBreakpoint()161 virtual ~StopInfoBreakpoint ()
162 {
163 }
164
165 virtual StopReason
GetStopReason() const166 GetStopReason () const
167 {
168 return eStopReasonBreakpoint;
169 }
170
171 virtual bool
ShouldStopSynchronous(Event * event_ptr)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
DoShouldNotify(Event * event_ptr)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 *
GetDescription()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
ShouldStop(Event * event_ptr)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
PerformAction(Event * event_ptr)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
521 private:
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
539 class StopInfoWatchpoint : public StopInfo
540 {
541 public:
542 // Make sure watchpoint is properly disabled and subsequently enabled while performing watchpoint actions.
543 class WatchpointSentry {
544 public:
WatchpointSentry(Process * p,Watchpoint * w)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 }
~WatchpointSentry()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
StopInfoWatchpoint(Thread & thread,break_id_t watch_id)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
~StopInfoWatchpoint()581 virtual ~StopInfoWatchpoint ()
582 {
583 }
584
585 virtual StopReason
GetStopReason() const586 GetStopReason () const
587 {
588 return eStopReasonWatchpoint;
589 }
590
591 virtual const char *
GetDescription()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
603 protected:
604 virtual bool
ShouldStopSynchronous(Event * event_ptr)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
ShouldStop(Event * event_ptr)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
PerformAction(Event * event_ptr)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
814 private:
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
826 class StopInfoUnixSignal : public StopInfo
827 {
828 public:
829
StopInfoUnixSignal(Thread & thread,int signo)830 StopInfoUnixSignal (Thread &thread, int signo) :
831 StopInfo (thread, signo)
832 {
833 }
834
~StopInfoUnixSignal()835 virtual ~StopInfoUnixSignal ()
836 {
837 }
838
839
840 virtual StopReason
GetStopReason() const841 GetStopReason () const
842 {
843 return eStopReasonSignal;
844 }
845
846 virtual bool
ShouldStopSynchronous(Event * event_ptr)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
ShouldStop(Event * event_ptr)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
DoShouldNotify(Event * event_ptr)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
WillResume(lldb::StateType resume_state)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 *
GetDescription()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
923 class StopInfoTrace : public StopInfo
924 {
925 public:
926
StopInfoTrace(Thread & thread)927 StopInfoTrace (Thread &thread) :
928 StopInfo (thread, LLDB_INVALID_UID)
929 {
930 }
931
~StopInfoTrace()932 virtual ~StopInfoTrace ()
933 {
934 }
935
936 virtual StopReason
GetStopReason() const937 GetStopReason () const
938 {
939 return eStopReasonTrace;
940 }
941
942 virtual const char *
GetDescription()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
957 class StopInfoException : public StopInfo
958 {
959 public:
960
StopInfoException(Thread & thread,const char * description)961 StopInfoException (Thread &thread, const char *description) :
962 StopInfo (thread, LLDB_INVALID_UID)
963 {
964 if (description)
965 SetDescription (description);
966 }
967
968 virtual
~StopInfoException()969 ~StopInfoException ()
970 {
971 }
972
973 virtual StopReason
GetStopReason() const974 GetStopReason () const
975 {
976 return eStopReasonException;
977 }
978
979 virtual const char *
GetDescription()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
994 class StopInfoThreadPlan : public StopInfo
995 {
996 public:
997
StopInfoThreadPlan(ThreadPlanSP & plan_sp,ValueObjectSP & return_valobj_sp)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
~StopInfoThreadPlan()1005 virtual ~StopInfoThreadPlan ()
1006 {
1007 }
1008
1009 virtual StopReason
GetStopReason() const1010 GetStopReason () const
1011 {
1012 return eStopReasonPlanComplete;
1013 }
1014
1015 virtual const char *
GetDescription()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
GetReturnValueObject()1028 GetReturnValueObject()
1029 {
1030 return m_return_valobj_sp;
1031 }
1032
1033 protected:
1034 virtual bool
ShouldStop(Event * event_ptr)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
1043 private:
1044 ThreadPlanSP m_plan_sp;
1045 ValueObjectSP m_return_valobj_sp;
1046 };
1047
1048 class StopInfoExec : public StopInfo
1049 {
1050 public:
1051
StopInfoExec(Thread & thread)1052 StopInfoExec (Thread &thread) :
1053 StopInfo (thread, LLDB_INVALID_UID),
1054 m_performed_action (false)
1055 {
1056 }
1057
1058 virtual
~StopInfoExec()1059 ~StopInfoExec ()
1060 {
1061 }
1062
1063 virtual StopReason
GetStopReason() const1064 GetStopReason () const
1065 {
1066 return eStopReasonExec;
1067 }
1068
1069 virtual const char *
GetDescription()1070 GetDescription ()
1071 {
1072 return "exec";
1073 }
1074 protected:
1075
1076 virtual void
PerformAction(Event * event_ptr)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
1093 StopInfoSP
CreateStopReasonWithBreakpointSiteID(Thread & thread,break_id_t break_id)1094 StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id)
1095 {
1096 return StopInfoSP (new StopInfoBreakpoint (thread, break_id));
1097 }
1098
1099 StopInfoSP
CreateStopReasonWithBreakpointSiteID(Thread & thread,break_id_t break_id,bool should_stop)1100 StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id, bool should_stop)
1101 {
1102 return StopInfoSP (new StopInfoBreakpoint (thread, break_id, should_stop));
1103 }
1104
1105 StopInfoSP
CreateStopReasonWithWatchpointID(Thread & thread,break_id_t watch_id)1106 StopInfo::CreateStopReasonWithWatchpointID (Thread &thread, break_id_t watch_id)
1107 {
1108 return StopInfoSP (new StopInfoWatchpoint (thread, watch_id));
1109 }
1110
1111 StopInfoSP
CreateStopReasonWithSignal(Thread & thread,int signo)1112 StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo)
1113 {
1114 return StopInfoSP (new StopInfoUnixSignal (thread, signo));
1115 }
1116
1117 StopInfoSP
CreateStopReasonToTrace(Thread & thread)1118 StopInfo::CreateStopReasonToTrace (Thread &thread)
1119 {
1120 return StopInfoSP (new StopInfoTrace (thread));
1121 }
1122
1123 StopInfoSP
CreateStopReasonWithPlan(ThreadPlanSP & plan_sp,ValueObjectSP return_valobj_sp)1124 StopInfo::CreateStopReasonWithPlan (ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp)
1125 {
1126 return StopInfoSP (new StopInfoThreadPlan (plan_sp, return_valobj_sp));
1127 }
1128
1129 StopInfoSP
CreateStopReasonWithException(Thread & thread,const char * description)1130 StopInfo::CreateStopReasonWithException (Thread &thread, const char *description)
1131 {
1132 return StopInfoSP (new StopInfoException (thread, description));
1133 }
1134
1135 StopInfoSP
CreateStopReasonWithExec(Thread & thread)1136 StopInfo::CreateStopReasonWithExec (Thread &thread)
1137 {
1138 return StopInfoSP (new StopInfoExec (thread));
1139 }
1140
1141 ValueObjectSP
GetReturnValueObject(StopInfoSP & stop_info_sp)1142 StopInfo::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