blob: 64bbe80ee2b164533c50cd8a9401f1c7f37900e1 [file] [log] [blame]
Greg Claytonf4b47e12010-08-04 01:40:35 +00001//===-- 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/Target/StopInfo.h"
11
12// C Includes
13// C++ Includes
14#include <string>
15
16// Other libraries and framework includes
17// Project includes
18#include "lldb/Core/Log.h"
Greg Clayton4e78f602010-11-18 18:52:36 +000019#include "lldb/Breakpoint/Breakpoint.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000020#include "lldb/Breakpoint/BreakpointLocation.h"
21#include "lldb/Breakpoint/StoppointCallbackContext.h"
Johnny Chen01a67862011-10-14 00:42:25 +000022#include "lldb/Breakpoint/Watchpoint.h"
Jim Ingham4b536182011-08-09 02:12:22 +000023#include "lldb/Core/Debugger.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000024#include "lldb/Core/StreamString.h"
Zachary Turnera78bd7f2015-03-03 23:11:11 +000025#include "lldb/Core/ValueObject.h"
Jim Ingham4b536182011-08-09 02:12:22 +000026#include "lldb/Expression/ClangUserExpression.h"
27#include "lldb/Target/Target.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000028#include "lldb/Target/Thread.h"
29#include "lldb/Target/ThreadPlan.h"
30#include "lldb/Target/Process.h"
31#include "lldb/Target/UnixSignals.h"
32
33using namespace lldb;
34using namespace lldb_private;
35
36StopInfo::StopInfo (Thread &thread, uint64_t value) :
Greg Clayton46c2b6e2013-04-29 23:30:46 +000037 m_thread_wp (thread.shared_from_this()),
Greg Clayton1ac04c32012-02-21 00:09:25 +000038 m_stop_id (thread.GetProcess()->GetStopID()),
39 m_resume_id (thread.GetProcess()->GetResumeID()),
Jim Ingham0161b492013-02-09 01:29:05 +000040 m_value (value),
Jason Molenda0453be92015-05-15 00:19:28 +000041 m_description (),
Jim Ingham221d51c2013-05-08 00:35:16 +000042 m_override_should_notify (eLazyBoolCalculate),
Kuba Breckaafdf8422014-10-10 23:43:03 +000043 m_override_should_stop (eLazyBoolCalculate),
44 m_extended_info()
Greg Claytonf4b47e12010-08-04 01:40:35 +000045{
46}
47
48bool
49StopInfo::IsValid () const
50{
Greg Clayton46c2b6e2013-04-29 23:30:46 +000051 ThreadSP thread_sp (m_thread_wp.lock());
52 if (thread_sp)
53 return thread_sp->GetProcess()->GetStopID() == m_stop_id;
54 return false;
Greg Claytonf4b47e12010-08-04 01:40:35 +000055}
56
Jim Ingham77787032011-01-20 02:03:18 +000057void
58StopInfo::MakeStopInfoValid ()
59{
Greg Clayton46c2b6e2013-04-29 23:30:46 +000060 ThreadSP thread_sp (m_thread_wp.lock());
61 if (thread_sp)
62 {
63 m_stop_id = thread_sp->GetProcess()->GetStopID();
64 m_resume_id = thread_sp->GetProcess()->GetResumeID();
65 }
Jim Ingham77787032011-01-20 02:03:18 +000066}
67
Jim Ingham0faa43f2011-11-08 03:00:11 +000068bool
69StopInfo::HasTargetRunSinceMe ()
Jim Ingham4b536182011-08-09 02:12:22 +000070{
Greg Clayton46c2b6e2013-04-29 23:30:46 +000071 ThreadSP thread_sp (m_thread_wp.lock());
72
73 if (thread_sp)
Jim Ingham0faa43f2011-11-08 03:00:11 +000074 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +000075 lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
76 if (ret_type == eStateRunning)
Jim Ingham0faa43f2011-11-08 03:00:11 +000077 {
78 return true;
79 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +000080 else if (ret_type == eStateStopped)
81 {
82 // This is a little tricky. We want to count "run and stopped again before you could
83 // ask this question as a "TRUE" answer to HasTargetRunSinceMe. But we don't want to
84 // include any running of the target done for expressions. So we track both resumes,
85 // and resumes caused by expressions, and check if there are any resumes NOT caused
86 // by expressions.
87
88 uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
89 uint32_t last_user_expression_id = thread_sp->GetProcess()->GetLastUserExpressionResumeID ();
90 if (curr_resume_id == m_resume_id)
91 {
92 return false;
93 }
94 else if (curr_resume_id > last_user_expression_id)
95 {
96 return true;
97 }
98 }
Jim Ingham0faa43f2011-11-08 03:00:11 +000099 }
100 return false;
Jim Ingham4b536182011-08-09 02:12:22 +0000101}
102
Greg Claytonf4b47e12010-08-04 01:40:35 +0000103//----------------------------------------------------------------------
104// StopInfoBreakpoint
105//----------------------------------------------------------------------
106
Jim Ingham4b536182011-08-09 02:12:22 +0000107namespace lldb_private
108{
Greg Claytonf4b47e12010-08-04 01:40:35 +0000109class StopInfoBreakpoint : public StopInfo
110{
111public:
Greg Claytonf4b47e12010-08-04 01:40:35 +0000112 StopInfoBreakpoint (Thread &thread, break_id_t break_id) :
113 StopInfo (thread, break_id),
Greg Claytonf4b47e12010-08-04 01:40:35 +0000114 m_should_stop (false),
Jim Ingham0f16e732011-02-08 05:20:59 +0000115 m_should_stop_is_valid (false),
Jim Ingham52c7d202011-10-28 01:12:19 +0000116 m_should_perform_action (true),
Jim Inghamca36cd12012-10-05 19:16:31 +0000117 m_address (LLDB_INVALID_ADDRESS),
118 m_break_id(LLDB_INVALID_BREAK_ID),
119 m_was_one_shot (false)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000120 {
Jim Inghamca36cd12012-10-05 19:16:31 +0000121 StoreBPInfo();
Greg Claytonf4b47e12010-08-04 01:40:35 +0000122 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000123
Jim Ingham36f3b362010-10-14 23:45:03 +0000124 StopInfoBreakpoint (Thread &thread, break_id_t break_id, bool should_stop) :
125 StopInfo (thread, break_id),
Jim Ingham36f3b362010-10-14 23:45:03 +0000126 m_should_stop (should_stop),
Jim Ingham0f16e732011-02-08 05:20:59 +0000127 m_should_stop_is_valid (true),
Jim Ingham52c7d202011-10-28 01:12:19 +0000128 m_should_perform_action (true),
Jim Inghamca36cd12012-10-05 19:16:31 +0000129 m_address (LLDB_INVALID_ADDRESS),
130 m_break_id(LLDB_INVALID_BREAK_ID),
131 m_was_one_shot (false)
132 {
133 StoreBPInfo();
134 }
135
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000136 void
137 StoreBPInfo ()
Jim Ingham36f3b362010-10-14 23:45:03 +0000138 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000139 ThreadSP thread_sp (m_thread_wp.lock());
140 if (thread_sp)
Jim Ingham52c7d202011-10-28 01:12:19 +0000141 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000142 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
143 if (bp_site_sp)
Jim Inghamca36cd12012-10-05 19:16:31 +0000144 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000145 if (bp_site_sp->GetNumberOfOwners() == 1)
Jim Inghamca36cd12012-10-05 19:16:31 +0000146 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000147 BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
148 if (bp_loc_sp)
149 {
150 m_break_id = bp_loc_sp->GetBreakpoint().GetID();
151 m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
152 }
Jim Inghamca36cd12012-10-05 19:16:31 +0000153 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000154 m_address = bp_site_sp->GetLoadAddress();
Jim Inghamca36cd12012-10-05 19:16:31 +0000155 }
Jim Ingham52c7d202011-10-28 01:12:19 +0000156 }
Jim Ingham36f3b362010-10-14 23:45:03 +0000157 }
158
Greg Claytonf4b47e12010-08-04 01:40:35 +0000159 virtual ~StopInfoBreakpoint ()
160 {
161 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000162
Greg Claytonab745c22015-04-07 22:17:41 +0000163 virtual bool
164 IsValidForOperatingSystemThread (Thread &thread)
165 {
166 ProcessSP process_sp (thread.GetProcess());
167 if (process_sp)
168 {
169 BreakpointSiteSP bp_site_sp (process_sp->GetBreakpointSiteList().FindByID (m_value));
170 if (bp_site_sp)
171 return bp_site_sp->ValidForThisThread (&thread);
172 }
173 return false;
174 }
175
Greg Claytonf4b47e12010-08-04 01:40:35 +0000176 virtual StopReason
177 GetStopReason () const
178 {
179 return eStopReasonBreakpoint;
180 }
181
182 virtual bool
Jim Ingham6d66ce62012-04-20 21:16:56 +0000183 ShouldStopSynchronous (Event *event_ptr)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000184 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000185 ThreadSP thread_sp (m_thread_wp.lock());
186 if (thread_sp)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000187 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000188 if (!m_should_stop_is_valid)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000189 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000190 // Only check once if we should stop at a breakpoint
191 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
192 if (bp_site_sp)
193 {
194 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
195 StoppointCallbackContext context (event_ptr, exe_ctx, true);
Jim Inghama672ece2014-10-22 01:54:17 +0000196 bp_site_sp->BumpHitCounts();
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000197 m_should_stop = bp_site_sp->ShouldStop (&context);
198 }
199 else
200 {
201 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonf4b47e12010-08-04 01:40:35 +0000202
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000203 if (log)
204 log->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value);
Greg Claytonf4b47e12010-08-04 01:40:35 +0000205
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000206 m_should_stop = true;
207 }
208 m_should_stop_is_valid = true;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000209 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000210 return m_should_stop;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000211 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000212 return false;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000213 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000214
Jim Inghamf57b4352012-11-10 02:08:14 +0000215 virtual bool
Jim Ingham221d51c2013-05-08 00:35:16 +0000216 DoShouldNotify (Event *event_ptr)
Jim Inghamf57b4352012-11-10 02:08:14 +0000217 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000218 ThreadSP thread_sp (m_thread_wp.lock());
219 if (thread_sp)
Jim Inghamf57b4352012-11-10 02:08:14 +0000220 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000221 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
222 if (bp_site_sp)
Jim Inghamf57b4352012-11-10 02:08:14 +0000223 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000224 bool all_internal = true;
225
226 for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++)
Jim Inghamf57b4352012-11-10 02:08:14 +0000227 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000228 if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal())
229 {
230 all_internal = false;
231 break;
232 }
Jim Inghamf57b4352012-11-10 02:08:14 +0000233 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000234 return all_internal == false;
Jim Inghamf57b4352012-11-10 02:08:14 +0000235 }
Jim Inghamf57b4352012-11-10 02:08:14 +0000236 }
237 return true;
238 }
239
240 virtual const char *
241 GetDescription ()
242 {
243 if (m_description.empty())
244 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000245 ThreadSP thread_sp (m_thread_wp.lock());
246 if (thread_sp)
Jim Inghamf57b4352012-11-10 02:08:14 +0000247 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000248 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
249 if (bp_site_sp)
Jim Ingham29950772013-01-26 02:19:28 +0000250 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000251 StreamString strm;
252 // If we have just hit an internal breakpoint, and it has a kind description, print that instead of the
253 // full breakpoint printing:
254 if (bp_site_sp->IsInternal())
Jim Ingham29950772013-01-26 02:19:28 +0000255 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000256 size_t num_owners = bp_site_sp->GetNumberOfOwners();
257 for (size_t idx = 0; idx < num_owners; idx++)
Jim Ingham29950772013-01-26 02:19:28 +0000258 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000259 const char *kind = bp_site_sp->GetOwnerAtIndex(idx)->GetBreakpoint().GetBreakpointKind();
260 if (kind != NULL)
261 {
262 m_description.assign (kind);
263 return kind;
264 }
Jim Ingham29950772013-01-26 02:19:28 +0000265 }
266 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000267
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000268 strm.Printf("breakpoint ");
269 bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
270 m_description.swap (strm.GetString());
Jim Ingham29950772013-01-26 02:19:28 +0000271 }
Jim Inghamf57b4352012-11-10 02:08:14 +0000272 else
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000273 {
274 StreamString strm;
275 if (m_break_id != LLDB_INVALID_BREAK_ID)
276 {
277 BreakpointSP break_sp = thread_sp->GetProcess()->GetTarget().GetBreakpointByID(m_break_id);
278 if (break_sp)
279 {
280 if (break_sp->IsInternal())
281 {
282 const char *kind = break_sp->GetBreakpointKind();
283 if (kind)
284 strm.Printf ("internal %s breakpoint(%d).", kind, m_break_id);
285 else
286 strm.Printf ("internal breakpoint(%d).", m_break_id);
287 }
288 else
289 {
290 strm.Printf ("breakpoint %d.", m_break_id);
291 }
292 }
293 else
294 {
295 if (m_was_one_shot)
296 strm.Printf ("one-shot breakpoint %d", m_break_id);
297 else
298 strm.Printf ("breakpoint %d which has been deleted.", m_break_id);
299 }
300 }
301 else if (m_address == LLDB_INVALID_ADDRESS)
302 strm.Printf("breakpoint site %" PRIi64 " which has been deleted - unknown address", m_value);
303 else
304 strm.Printf("breakpoint site %" PRIi64 " which has been deleted - was at 0x%" PRIx64, m_value, m_address);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000305
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000306 m_description.swap (strm.GetString());
307 }
Jim Inghamf57b4352012-11-10 02:08:14 +0000308 }
309 }
310 return m_description.c_str();
311 }
312
313protected:
Jim Ingham6d66ce62012-04-20 21:16:56 +0000314 bool
315 ShouldStop (Event *event_ptr)
316 {
317 // This just reports the work done by PerformAction or the synchronous stop. It should
318 // only ever get called after they have had a chance to run.
319 assert (m_should_stop_is_valid);
320 return m_should_stop;
321 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000322
Jim Ingham3ebcf7f2010-08-10 00:59:59 +0000323 virtual void
324 PerformAction (Event *event_ptr)
325 {
Jim Ingham0f16e732011-02-08 05:20:59 +0000326 if (!m_should_perform_action)
327 return;
328 m_should_perform_action = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000329
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000330 ThreadSP thread_sp (m_thread_wp.lock());
331
332 if (thread_sp)
Jim Ingham5cb9a182013-03-28 00:13:30 +0000333 {
Jim Inghamcca89952014-08-05 01:58:14 +0000334 Log *log = lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000335
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000336 if (!thread_sp->IsValid())
Jim Ingham3ebcf7f2010-08-10 00:59:59 +0000337 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000338 // This shouldn't ever happen, but just in case, don't do more harm.
Jason Molenda3f032ff2013-08-06 23:08:59 +0000339 if (log)
340 {
341 log->Printf ("PerformAction got called with an invalid thread.");
342 }
Jim Ingham79ea1d82011-12-09 04:17:31 +0000343 m_should_stop = true;
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000344 m_should_stop_is_valid = true;
345 return;
Jim Ingham79ea1d82011-12-09 04:17:31 +0000346 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000347
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000348 BreakpointSiteSP bp_site_sp (thread_sp->GetProcess()->GetBreakpointSiteList().FindByID (m_value));
Jim Ingham46e9f9d2015-04-23 00:28:25 +0000349 std::unordered_set<break_id_t> precondition_breakpoints;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000350
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000351 if (bp_site_sp)
Jim Ingham79ea1d82011-12-09 04:17:31 +0000352 {
Jim Ingham9d1ccda2015-07-29 17:51:36 +0000353 // Let's copy the owners list out of the site and store them in a local list. That way if
354 // one of the breakpoint actions changes the site, then we won't be operating on a bad list.
355 BreakpointLocationCollection site_locations;
356 size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000357
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000358 if (num_owners == 0)
359 {
360 m_should_stop = true;
Jim Ingham184e9812013-01-15 02:47:48 +0000361 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000362 else
Jim Ingham4b536182011-08-09 02:12:22 +0000363 {
Jim Ingham46e9f9d2015-04-23 00:28:25 +0000364 // We go through each location, and test first its precondition - this overrides everything. Note,
365 // we only do this once per breakpoint - not once per location...
366 // Then check the condition. If the condition says to stop,
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000367 // then we run the callback for that location. If that callback says to stop as well, then
368 // we set m_should_stop to true; we are going to stop.
369 // But we still want to give all the breakpoints whose conditions say we are going to stop a
370 // chance to run their callbacks.
371 // Of course if any callback restarts the target by putting "continue" in the callback, then
372 // we're going to restart, without running the rest of the callbacks. And in this case we will
373 // end up not stopping even if another location said we should stop. But that's better than not
374 // running all the callbacks.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000375
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000376 m_should_stop = false;
377
378 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
379 Process *process = exe_ctx.GetProcessPtr();
380 if (process->GetModIDRef().IsLastResumeForUserExpression())
Jim Ingham4b536182011-08-09 02:12:22 +0000381 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000382 // If we are in the middle of evaluating an expression, don't run asynchronous breakpoint commands or
383 // expressions. That could lead to infinite recursion if the command or condition re-calls the function
384 // with this breakpoint.
385 // TODO: We can keep a list of the breakpoints we've seen while running expressions in the nested
386 // PerformAction calls that can arise when the action runs a function that hits another breakpoint,
387 // and only stop running commands when we see the same breakpoint hit a second time.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000388
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000389 m_should_stop_is_valid = true;
390 if (log)
391 log->Printf ("StopInfoBreakpoint::PerformAction - Hit a breakpoint while running an expression,"
392 " not running commands to avoid recursion.");
393 bool ignoring_breakpoints = process->GetIgnoreBreakpointsInExpressions();
394 if (ignoring_breakpoints)
Jim Ingham4b536182011-08-09 02:12:22 +0000395 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000396 m_should_stop = false;
397 // Internal breakpoints will always stop.
398 for (size_t j = 0; j < num_owners; j++)
399 {
400 lldb::BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(j);
401 if (bp_loc_sp->GetBreakpoint().IsInternal())
402 {
403 m_should_stop = true;
404 break;
405 }
406 }
Jim Ingham4b536182011-08-09 02:12:22 +0000407 }
Sean Callanan3dbf3462013-04-19 07:09:15 +0000408 else
409 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000410 m_should_stop = true;
411 }
412 if (log)
413 log->Printf ("StopInfoBreakpoint::PerformAction - in expression, continuing: %s.",
414 m_should_stop ? "true" : "false");
415 process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf("Warning: hit breakpoint while "
416 "running function, skipping commands and conditions to prevent recursion.");
417 return;
418 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000419
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000420 StoppointCallbackContext context (event_ptr, exe_ctx, false);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000421
Jim Inghama672ece2014-10-22 01:54:17 +0000422 // For safety's sake let's also grab an extra reference to the breakpoint owners of the locations we're
423 // going to examine, since the locations are going to have to get back to their breakpoints, and the
424 // locations don't keep their owners alive. I'm just sticking the BreakpointSP's in a vector since
Jim Ingham9d1ccda2015-07-29 17:51:36 +0000425 // I'm only using it to locally increment their retain counts.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000426
Jim Inghama672ece2014-10-22 01:54:17 +0000427 std::vector<lldb::BreakpointSP> location_owners;
428
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000429 for (size_t j = 0; j < num_owners; j++)
Jim Inghama672ece2014-10-22 01:54:17 +0000430 {
Jim Ingham9d1ccda2015-07-29 17:51:36 +0000431 BreakpointLocationSP loc(site_locations.GetByIndex(j));
Jim Inghama672ece2014-10-22 01:54:17 +0000432 location_owners.push_back(loc->GetBreakpoint().shared_from_this());
433
434 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000435
436 for (size_t j = 0; j < num_owners; j++)
437 {
438 lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000439
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000440 // If another action disabled this breakpoint or its location, then don't run the actions.
441 if (!bp_loc_sp->IsEnabled() || !bp_loc_sp->GetBreakpoint().IsEnabled())
442 continue;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000443
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000444 // The breakpoint site may have many locations associated with it, not all of them valid for
445 // this thread. Skip the ones that aren't:
446 if (!bp_loc_sp->ValidForThisThread(thread_sp.get()))
Jim Inghama8b99ca2014-01-15 03:30:04 +0000447 {
448 if (log)
449 {
450 StreamString s;
451 bp_loc_sp->GetDescription(&s, eDescriptionLevelBrief);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000452 log->Printf ("Breakpoint %s hit on thread 0x%llx but it was not for this thread, continuing.",
453 s.GetData(),
454 static_cast<unsigned long long>(thread_sp->GetID()));
Jim Inghama8b99ca2014-01-15 03:30:04 +0000455 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000456 continue;
Jim Inghama8b99ca2014-01-15 03:30:04 +0000457 }
Jim Ingham46e9f9d2015-04-23 00:28:25 +0000458
459 // First run the precondition, but since the precondition is per breakpoint, only run it once
460 // per breakpoint.
461 std::pair<std::unordered_set<break_id_t>::iterator, bool> result
462 = precondition_breakpoints.insert(bp_loc_sp->GetBreakpoint().GetID());
463 if (!result.second)
464 continue;
465
466 bool precondition_result = bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
467 if (!precondition_result)
468 continue;
469
470 // Next run the condition for the breakpoint. If that says we should stop, then we'll run
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000471 // the callback for the breakpoint. If the callback says we shouldn't stop that will win.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000472
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000473 if (bp_loc_sp->GetConditionText() != NULL)
474 {
475 Error condition_error;
476 bool condition_says_stop = bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000477
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000478 if (!condition_error.Success())
479 {
480 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
481 StreamSP error_sp = debugger.GetAsyncErrorStream ();
482 error_sp->Printf ("Stopped due to an error evaluating condition of breakpoint ");
483 bp_loc_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief);
484 error_sp->Printf (": \"%s\"",
485 bp_loc_sp->GetConditionText());
486 error_sp->EOL();
487 const char *err_str = condition_error.AsCString("<Unknown Error>");
488 if (log)
489 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000490
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000491 error_sp->PutCString (err_str);
492 error_sp->EOL();
493 error_sp->Flush();
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000494 }
495 else
496 {
Jim Inghama8b99ca2014-01-15 03:30:04 +0000497 if (log)
498 {
499 StreamString s;
500 bp_loc_sp->GetDescription(&s, eDescriptionLevelBrief);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000501 log->Printf ("Condition evaluated for breakpoint %s on thread 0x%llx conditon_says_stop: %i.",
502 s.GetData(),
503 static_cast<unsigned long long>(thread_sp->GetID()),
504 condition_says_stop);
Jim Inghama8b99ca2014-01-15 03:30:04 +0000505 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000506 if (!condition_says_stop)
Jim Inghamd762df82015-01-15 01:41:04 +0000507 {
508 // We don't want to increment the hit count of breakpoints if the condition fails.
509 // We've already bumped it by the time we get here, so undo the bump:
510 bp_loc_sp->UndoBumpHitCount();
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000511 continue;
Jim Inghamd762df82015-01-15 01:41:04 +0000512 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000513 }
514 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000515
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000516 bool callback_says_stop;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000517
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000518 // FIXME: For now the callbacks have to run in async mode - the first time we restart we need
519 // to get out of there. So set it here.
520 // When we figure out how to nest breakpoint hits then this will change.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000521
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000522 Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
523 bool old_async = debugger.GetAsyncExecution();
524 debugger.SetAsyncExecution (true);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000525
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000526 callback_says_stop = bp_loc_sp->InvokeCallback (&context);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000527
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000528 debugger.SetAsyncExecution (old_async);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000529
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000530 if (callback_says_stop)
531 m_should_stop = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000532
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000533 // If we are going to stop for this breakpoint, then remove the breakpoint.
534 if (callback_says_stop && bp_loc_sp && bp_loc_sp->GetBreakpoint().IsOneShot())
535 {
536 thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID (bp_loc_sp->GetBreakpoint().GetID());
537 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000538
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000539 // Also make sure that the callback hasn't continued the target.
540 // If it did, when we'll set m_should_start to false and get out of here.
541 if (HasTargetRunSinceMe ())
542 {
543 m_should_stop = false;
544 break;
Sean Callanan3dbf3462013-04-19 07:09:15 +0000545 }
Jim Ingham4b536182011-08-09 02:12:22 +0000546 }
Jim Ingham4b536182011-08-09 02:12:22 +0000547 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000548 // We've figured out what this stop wants to do, so mark it as valid so we don't compute it again.
549 m_should_stop_is_valid = true;
550
Jim Ingham3ebcf7f2010-08-10 00:59:59 +0000551 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000552 else
553 {
554 m_should_stop = true;
555 m_should_stop_is_valid = true;
556 Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Ingham79ea1d82011-12-09 04:17:31 +0000557
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000558 if (log_process)
559 log_process->Printf ("Process::%s could not find breakpoint site id: %" PRId64 "...", __FUNCTION__, m_value);
560 }
561 if (log)
562 log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop);
Jim Ingham3ebcf7f2010-08-10 00:59:59 +0000563 }
Jim Ingham3ebcf7f2010-08-10 00:59:59 +0000564 }
Greg Claytonf4b47e12010-08-04 01:40:35 +0000565
566private:
Greg Claytonf4b47e12010-08-04 01:40:35 +0000567 bool m_should_stop;
568 bool m_should_stop_is_valid;
Jim Ingham0f16e732011-02-08 05:20:59 +0000569 bool m_should_perform_action; // Since we are trying to preserve the "state" of the system even if we run functions
570 // etc. behind the users backs, we need to make sure we only REALLY perform the action once.
Jim Ingham52c7d202011-10-28 01:12:19 +0000571 lldb::addr_t m_address; // We use this to capture the breakpoint site address when we create the StopInfo,
572 // in case somebody deletes it between the time the StopInfo is made and the
573 // description is asked for.
Jim Inghamca36cd12012-10-05 19:16:31 +0000574 lldb::break_id_t m_break_id;
575 bool m_was_one_shot;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000576};
577
578
579//----------------------------------------------------------------------
580// StopInfoWatchpoint
581//----------------------------------------------------------------------
582
583class StopInfoWatchpoint : public StopInfo
584{
585public:
Jim Inghamf57b4352012-11-10 02:08:14 +0000586 // Make sure watchpoint is properly disabled and subsequently enabled while performing watchpoint actions.
587 class WatchpointSentry {
588 public:
589 WatchpointSentry(Process *p, Watchpoint *w):
590 process(p),
591 watchpoint(w)
592 {
593 if (process && watchpoint)
594 {
Jim Ingham1b5792e2012-12-18 02:03:49 +0000595 const bool notify = false;
Jim Inghamf57b4352012-11-10 02:08:14 +0000596 watchpoint->TurnOnEphemeralMode();
Jim Ingham1b5792e2012-12-18 02:03:49 +0000597 process->DisableWatchpoint(watchpoint, notify);
Jim Inghamf57b4352012-11-10 02:08:14 +0000598 }
599 }
600 ~WatchpointSentry()
601 {
602 if (process && watchpoint)
603 {
604 if (!watchpoint->IsDisabledDuringEphemeralMode())
Jim Ingham1b5792e2012-12-18 02:03:49 +0000605 {
606 const bool notify = false;
607 process->EnableWatchpoint(watchpoint, notify);
608 }
Jim Inghamf57b4352012-11-10 02:08:14 +0000609 watchpoint->TurnOffEphemeralMode();
610 }
611 }
612 private:
613 Process *process;
614 Watchpoint *watchpoint;
615 };
Greg Claytonf4b47e12010-08-04 01:40:35 +0000616
617 StopInfoWatchpoint (Thread &thread, break_id_t watch_id) :
Johnny Chenfd158f42011-09-21 22:47:15 +0000618 StopInfo(thread, watch_id),
Johnny Chenfd158f42011-09-21 22:47:15 +0000619 m_should_stop(false),
620 m_should_stop_is_valid(false)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000621 {
622 }
623
624 virtual ~StopInfoWatchpoint ()
625 {
626 }
627
628 virtual StopReason
629 GetStopReason () const
630 {
631 return eStopReasonWatchpoint;
632 }
633
Jim Inghamf57b4352012-11-10 02:08:14 +0000634 virtual const char *
635 GetDescription ()
636 {
637 if (m_description.empty())
638 {
639 StreamString strm;
Daniel Malead01b2952012-11-29 21:49:15 +0000640 strm.Printf("watchpoint %" PRIi64, m_value);
Jim Inghamf57b4352012-11-10 02:08:14 +0000641 m_description.swap (strm.GetString());
642 }
643 return m_description.c_str();
644 }
645
646protected:
Johnny Chenfd158f42011-09-21 22:47:15 +0000647 virtual bool
Jim Ingham9b620f32013-02-22 21:23:43 +0000648 ShouldStopSynchronous (Event *event_ptr)
Johnny Chenfd158f42011-09-21 22:47:15 +0000649 {
650 // ShouldStop() method is idempotent and should not affect hit count.
Johnny Chen16dcf712011-10-17 18:58:00 +0000651 // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
652 // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
653 // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
654 // StopInfoWatchpoint::ShouldStop() and
655 // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
656 // StopInfoWatchpoint::PerformAction().
Johnny Chenfd158f42011-09-21 22:47:15 +0000657 if (m_should_stop_is_valid)
658 return m_should_stop;
659
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000660 ThreadSP thread_sp (m_thread_wp.lock());
661 if (thread_sp)
Johnny Chenfd158f42011-09-21 22:47:15 +0000662 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000663 WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
664 if (wp_sp)
665 {
666 // Check if we should stop at a watchpoint.
667 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
668 StoppointCallbackContext context (event_ptr, exe_ctx, true);
669 m_should_stop = wp_sp->ShouldStop (&context);
670 }
671 else
672 {
673 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Johnny Chenfd158f42011-09-21 22:47:15 +0000674
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000675 if (log)
676 log->Printf ("Process::%s could not find watchpoint location id: %" PRId64 "...",
677 __FUNCTION__, GetValue());
Johnny Chenfd158f42011-09-21 22:47:15 +0000678
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000679 m_should_stop = true;
680 }
Johnny Chenfd158f42011-09-21 22:47:15 +0000681 }
682 m_should_stop_is_valid = true;
683 return m_should_stop;
684 }
685
Jim Ingham9b620f32013-02-22 21:23:43 +0000686 bool
687 ShouldStop (Event *event_ptr)
688 {
689 // This just reports the work done by PerformAction or the synchronous stop. It should
690 // only ever get called after they have had a chance to run.
691 assert (m_should_stop_is_valid);
692 return m_should_stop;
693 }
694
Johnny Chen16dcf712011-10-17 18:58:00 +0000695 virtual void
696 PerformAction (Event *event_ptr)
697 {
Greg Clayton5160ce52013-03-27 23:08:40 +0000698 Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS);
Johnny Chen16dcf712011-10-17 18:58:00 +0000699 // We're going to calculate if we should stop or not in some way during the course of
700 // this code. Also by default we're going to stop, so set that here.
701 m_should_stop = true;
702
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000703 ThreadSP thread_sp (m_thread_wp.lock());
704 if (thread_sp)
Johnny Chen16dcf712011-10-17 18:58:00 +0000705 {
Johnny Chen0f7ad8d2012-08-21 22:06:34 +0000706
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000707 WatchpointSP wp_sp (thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
708 if (wp_sp)
Enrico Granataf04a2192012-07-13 23:18:48 +0000709 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000710 ExecutionContext exe_ctx (thread_sp->GetStackFrameAtIndex(0));
711 Process* process = exe_ctx.GetProcessPtr();
712
713 // This sentry object makes sure the current watchpoint is disabled while performing watchpoint actions,
714 // and it is then enabled after we are finished.
715 WatchpointSentry sentry(process, wp_sp.get());
716
Enrico Granataf04a2192012-07-13 23:18:48 +0000717 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000718 // check if this process is running on an architecture where watchpoints trigger
719 // before the associated instruction runs. if so, disable the WP, single-step and then
720 // re-enable the watchpoint
721 if (process)
Enrico Granataf04a2192012-07-13 23:18:48 +0000722 {
Jason Molendafe806902013-05-04 00:39:52 +0000723 uint32_t num;
724 bool wp_triggers_after;
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000725 if (process->GetWatchpointSupportInfo(num, wp_triggers_after).Success())
Enrico Granataf04a2192012-07-13 23:18:48 +0000726 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000727 if (!wp_triggers_after)
728 {
Jim Ingham363ddd72013-07-02 21:12:44 +0000729 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
730 assert (stored_stop_info_sp.get() == this);
731
Jim Ingham4d56e9c2013-07-18 21:48:26 +0000732 ThreadPlanSP new_plan_sp(thread_sp->QueueThreadPlanForStepSingleInstruction(false, // step-over
Greg Claytondc6224e2014-10-21 01:00:42 +0000733 false, // abort_other_plans
734 true)); // stop_other_threads
Jim Ingham4d56e9c2013-07-18 21:48:26 +0000735 new_plan_sp->SetIsMasterPlan (true);
736 new_plan_sp->SetOkayToDiscard (false);
737 new_plan_sp->SetPrivate (true);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000738 process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID());
Greg Claytondc6224e2014-10-21 01:00:42 +0000739 process->ResumeSynchronous(NULL);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000740 process->GetThreadList().SetSelectedThreadByID (thread_sp->GetID());
Jim Ingham363ddd72013-07-02 21:12:44 +0000741 thread_sp->SetStopInfo(stored_stop_info_sp);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000742 }
Enrico Granataf04a2192012-07-13 23:18:48 +0000743 }
744 }
745 }
Johnny Chen209bd652012-08-13 21:09:54 +0000746
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000747 if (m_should_stop && wp_sp->GetConditionText() != NULL)
Johnny Chen16dcf712011-10-17 18:58:00 +0000748 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000749 // We need to make sure the user sees any parse errors in their condition, so we'll hook the
750 // constructor errors up to the debugger's Async I/O.
Jim Ingham1624a2d2014-05-05 02:26:40 +0000751 ExpressionResults result_code;
Greg Clayton62afb9f2013-11-04 19:35:17 +0000752 EvaluateExpressionOptions expr_options;
753 expr_options.SetUnwindOnError(true);
754 expr_options.SetIgnoreBreakpoints(true);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000755 ValueObjectSP result_value_sp;
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000756 Error error;
Greg Clayton62afb9f2013-11-04 19:35:17 +0000757 result_code = ClangUserExpression::Evaluate (exe_ctx,
758 expr_options,
759 wp_sp->GetConditionText(),
760 NULL,
761 result_value_sp,
762 error);
Jim Ingham8646d3c2014-05-05 02:47:44 +0000763 if (result_code == eExpressionCompleted)
Johnny Chen16dcf712011-10-17 18:58:00 +0000764 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000765 if (result_value_sp)
Johnny Chen16dcf712011-10-17 18:58:00 +0000766 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000767 Scalar scalar_value;
768 if (result_value_sp->ResolveValue (scalar_value))
Johnny Chen16dcf712011-10-17 18:58:00 +0000769 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000770 if (scalar_value.ULongLong(1) == 0)
771 {
772 // We have been vetoed. This takes precedence over querying
773 // the watchpoint whether it should stop (aka ignore count and
774 // friends). See also StopInfoWatchpoint::ShouldStop() as well
775 // as Process::ProcessEventData::DoOnRemoval().
776 m_should_stop = false;
777 }
778 else
779 m_should_stop = true;
780 if (log)
781 log->Printf("Condition successfully evaluated, result is %s.\n",
782 m_should_stop ? "true" : "false");
Johnny Chen16dcf712011-10-17 18:58:00 +0000783 }
784 else
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000785 {
Johnny Chen16dcf712011-10-17 18:58:00 +0000786 m_should_stop = true;
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000787 if (log)
788 log->Printf("Failed to get an integer result from the expression.");
789 }
Johnny Chen16dcf712011-10-17 18:58:00 +0000790 }
791 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000792 else
793 {
794 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
795 StreamSP error_sp = debugger.GetAsyncErrorStream ();
796 error_sp->Printf ("Stopped due to an error evaluating condition of watchpoint ");
797 wp_sp->GetDescription (error_sp.get(), eDescriptionLevelBrief);
798 error_sp->Printf (": \"%s\"",
799 wp_sp->GetConditionText());
800 error_sp->EOL();
801 const char *err_str = error.AsCString("<Unknown Error>");
802 if (log)
803 log->Printf("Error evaluating condition: \"%s\"\n", err_str);
804
805 error_sp->PutCString (err_str);
806 error_sp->EOL();
807 error_sp->Flush();
808 // If the condition fails to be parsed or run, we should stop.
809 m_should_stop = true;
810 }
Johnny Chen16dcf712011-10-17 18:58:00 +0000811 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000812
813 // If the condition says to stop, we run the callback to further decide whether to stop.
814 if (m_should_stop)
Johnny Chen16dcf712011-10-17 18:58:00 +0000815 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000816 StoppointCallbackContext context (event_ptr, exe_ctx, false);
817 bool stop_requested = wp_sp->InvokeCallback (&context);
818 // Also make sure that the callback hasn't continued the target.
819 // If it did, when we'll set m_should_stop to false and get out of here.
820 if (HasTargetRunSinceMe ())
821 m_should_stop = false;
822
823 if (m_should_stop && !stop_requested)
824 {
825 // We have been vetoed by the callback mechanism.
826 m_should_stop = false;
827 }
828 }
829 // Finally, if we are going to stop, print out the new & old values:
830 if (m_should_stop)
831 {
832 wp_sp->CaptureWatchedValue(exe_ctx);
833
Greg Clayton1ac04c32012-02-21 00:09:25 +0000834 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000835 StreamSP output_sp = debugger.GetAsyncOutputStream ();
836 wp_sp->DumpSnapshots(output_sp.get());
837 output_sp->EOL();
838 output_sp->Flush();
Johnny Chen16dcf712011-10-17 18:58:00 +0000839 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000840
Johnny Chen16dcf712011-10-17 18:58:00 +0000841 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000842 else
843 {
844 Log * log_process(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Johnny Chen13206412012-08-09 23:10:57 +0000845
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000846 if (log_process)
847 log_process->Printf ("Process::%s could not find watchpoint id: %" PRId64 "...", __FUNCTION__, m_value);
Johnny Chen13206412012-08-09 23:10:57 +0000848 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000849 if (log)
850 log->Printf ("Process::%s returning from action with m_should_stop: %d.", __FUNCTION__, m_should_stop);
Jim Inghama7dfb662012-10-23 07:20:06 +0000851
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000852 m_should_stop_is_valid = true;
Johnny Chen16dcf712011-10-17 18:58:00 +0000853 }
Johnny Chen16dcf712011-10-17 18:58:00 +0000854 }
855
Greg Claytonf4b47e12010-08-04 01:40:35 +0000856private:
Johnny Chenfd158f42011-09-21 22:47:15 +0000857 bool m_should_stop;
858 bool m_should_stop_is_valid;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000859};
860
861
862
863//----------------------------------------------------------------------
864// StopInfoUnixSignal
865//----------------------------------------------------------------------
866
867class StopInfoUnixSignal : public StopInfo
868{
869public:
870
Pavel Labathc4e25c92015-05-29 10:13:03 +0000871 StopInfoUnixSignal (Thread &thread, int signo, const char *description) :
Greg Claytona658fd22011-06-04 01:26:29 +0000872 StopInfo (thread, signo)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000873 {
Pavel Labathc4e25c92015-05-29 10:13:03 +0000874 SetDescription (description);
Greg Claytonf4b47e12010-08-04 01:40:35 +0000875 }
876
877 virtual ~StopInfoUnixSignal ()
878 {
879 }
880
881
882 virtual StopReason
883 GetStopReason () const
884 {
885 return eStopReasonSignal;
886 }
887
888 virtual bool
Jim Ingham0161b492013-02-09 01:29:05 +0000889 ShouldStopSynchronous (Event *event_ptr)
890 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000891 ThreadSP thread_sp (m_thread_wp.lock());
892 if (thread_sp)
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000893 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000894 return false;
Jim Ingham0161b492013-02-09 01:29:05 +0000895 }
896
897 virtual bool
Greg Claytonf4b47e12010-08-04 01:40:35 +0000898 ShouldStop (Event *event_ptr)
899 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000900 ThreadSP thread_sp (m_thread_wp.lock());
901 if (thread_sp)
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000902 return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000903 return false;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000904 }
905
906
907 // If should stop returns false, check if we should notify of this event
908 virtual bool
Jim Ingham221d51c2013-05-08 00:35:16 +0000909 DoShouldNotify (Event *event_ptr)
Greg Claytonf4b47e12010-08-04 01:40:35 +0000910 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000911 ThreadSP thread_sp (m_thread_wp.lock());
912 if (thread_sp)
Jim Ingham0161b492013-02-09 01:29:05 +0000913 {
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000914 bool should_notify = thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000915 if (should_notify)
916 {
917 StreamString strm;
918 strm.Printf ("thread %d received signal: %s",
919 thread_sp->GetIndexID(),
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000920 thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(m_value));
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000921 Process::ProcessEventData::AddRestartedReason(event_ptr, strm.GetData());
922 }
923 return should_notify;
Jim Ingham0161b492013-02-09 01:29:05 +0000924 }
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000925 return true;
Greg Claytonf4b47e12010-08-04 01:40:35 +0000926 }
927
928
929 virtual void
930 WillResume (lldb::StateType resume_state)
931 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000932 ThreadSP thread_sp (m_thread_wp.lock());
933 if (thread_sp)
934 {
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000935 if (thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(m_value) == false)
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000936 thread_sp->SetResumeSignal(m_value);
937 }
Greg Claytonf4b47e12010-08-04 01:40:35 +0000938 }
939
940 virtual const char *
941 GetDescription ()
942 {
943 if (m_description.empty())
944 {
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000945 ThreadSP thread_sp (m_thread_wp.lock());
946 if (thread_sp)
947 {
948 StreamString strm;
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000949 const char *signal_name = thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(m_value);
Greg Clayton46c2b6e2013-04-29 23:30:46 +0000950 if (signal_name)
951 strm.Printf("signal %s", signal_name);
952 else
953 strm.Printf("signal %" PRIi64, m_value);
954 m_description.swap (strm.GetString());
955 }
Greg Claytonf4b47e12010-08-04 01:40:35 +0000956 }
957 return m_description.c_str();
958 }
Greg Claytonf4b47e12010-08-04 01:40:35 +0000959};
960
961//----------------------------------------------------------------------
962// StopInfoTrace
963//----------------------------------------------------------------------
964
965class StopInfoTrace : public StopInfo
966{
967public:
968
969 StopInfoTrace (Thread &thread) :
970 StopInfo (thread, LLDB_INVALID_UID)
971 {
972 }
973
974 virtual ~StopInfoTrace ()
975 {
976 }
977
978 virtual StopReason
979 GetStopReason () const
980 {
981 return eStopReasonTrace;
982 }
983
984 virtual const char *
985 GetDescription ()
986 {
Greg Claytona658fd22011-06-04 01:26:29 +0000987 if (m_description.empty())
Greg Claytonf4b47e12010-08-04 01:40:35 +0000988 return "trace";
Greg Claytona658fd22011-06-04 01:26:29 +0000989 else
990 return m_description.c_str();
991 }
992};
993
994
995//----------------------------------------------------------------------
996// StopInfoException
997//----------------------------------------------------------------------
998
999class StopInfoException : public StopInfo
1000{
1001public:
1002
1003 StopInfoException (Thread &thread, const char *description) :
1004 StopInfo (thread, LLDB_INVALID_UID)
1005 {
1006 if (description)
1007 SetDescription (description);
1008 }
1009
1010 virtual
1011 ~StopInfoException ()
1012 {
1013 }
1014
1015 virtual StopReason
1016 GetStopReason () const
1017 {
1018 return eStopReasonException;
1019 }
1020
1021 virtual const char *
1022 GetDescription ()
1023 {
1024 if (m_description.empty())
1025 return "exception";
1026 else
1027 return m_description.c_str();
Greg Claytonf4b47e12010-08-04 01:40:35 +00001028 }
1029};
1030
1031
1032//----------------------------------------------------------------------
1033// StopInfoThreadPlan
1034//----------------------------------------------------------------------
1035
1036class StopInfoThreadPlan : public StopInfo
1037{
1038public:
1039
Jim Ingham30fadaf2014-07-08 01:07:32 +00001040 StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ClangExpressionVariableSP &expression_variable_sp) :
Greg Claytonf4b47e12010-08-04 01:40:35 +00001041 StopInfo (plan_sp->GetThread(), LLDB_INVALID_UID),
Jim Ingham73ca05a2011-12-17 01:35:57 +00001042 m_plan_sp (plan_sp),
Jim Ingham30fadaf2014-07-08 01:07:32 +00001043 m_return_valobj_sp (return_valobj_sp),
1044 m_expression_variable_sp (expression_variable_sp)
Greg Claytonf4b47e12010-08-04 01:40:35 +00001045 {
1046 }
1047
1048 virtual ~StopInfoThreadPlan ()
1049 {
1050 }
1051
1052 virtual StopReason
1053 GetStopReason () const
1054 {
1055 return eStopReasonPlanComplete;
1056 }
1057
1058 virtual const char *
1059 GetDescription ()
1060 {
1061 if (m_description.empty())
1062 {
1063 StreamString strm;
1064 m_plan_sp->GetDescription (&strm, eDescriptionLevelBrief);
1065 m_description.swap (strm.GetString());
1066 }
1067 return m_description.c_str();
1068 }
Jim Ingham73ca05a2011-12-17 01:35:57 +00001069
1070 ValueObjectSP
1071 GetReturnValueObject()
1072 {
1073 return m_return_valobj_sp;
1074 }
Jim Ingham0161b492013-02-09 01:29:05 +00001075
Jim Ingham30fadaf2014-07-08 01:07:32 +00001076 ClangExpressionVariableSP
1077 GetExpressionVariable()
1078 {
1079 return m_expression_variable_sp;
1080 }
1081
Jim Ingham0161b492013-02-09 01:29:05 +00001082protected:
1083 virtual bool
1084 ShouldStop (Event *event_ptr)
1085 {
1086 if (m_plan_sp)
1087 return m_plan_sp->ShouldStop(event_ptr);
1088 else
1089 return StopInfo::ShouldStop(event_ptr);
1090 }
Greg Claytonf4b47e12010-08-04 01:40:35 +00001091
1092private:
1093 ThreadPlanSP m_plan_sp;
Jim Ingham73ca05a2011-12-17 01:35:57 +00001094 ValueObjectSP m_return_valobj_sp;
Jim Ingham30fadaf2014-07-08 01:07:32 +00001095 ClangExpressionVariableSP m_expression_variable_sp;
Greg Claytonf4b47e12010-08-04 01:40:35 +00001096};
Greg Clayton90ba8112012-12-05 00:16:59 +00001097
1098class StopInfoExec : public StopInfo
1099{
1100public:
1101
1102 StopInfoExec (Thread &thread) :
1103 StopInfo (thread, LLDB_INVALID_UID),
1104 m_performed_action (false)
1105 {
1106 }
1107
1108 virtual
1109 ~StopInfoExec ()
1110 {
1111 }
1112
1113 virtual StopReason
1114 GetStopReason () const
1115 {
1116 return eStopReasonExec;
1117 }
1118
1119 virtual const char *
1120 GetDescription ()
1121 {
1122 return "exec";
1123 }
1124protected:
Greg Clayton90ba8112012-12-05 00:16:59 +00001125
1126 virtual void
1127 PerformAction (Event *event_ptr)
1128 {
1129 // Only perform the action once
1130 if (m_performed_action)
1131 return;
1132 m_performed_action = true;
Greg Clayton46c2b6e2013-04-29 23:30:46 +00001133 ThreadSP thread_sp (m_thread_wp.lock());
1134 if (thread_sp)
1135 thread_sp->GetProcess()->DidExec();
Greg Clayton90ba8112012-12-05 00:16:59 +00001136 }
1137
1138 bool m_performed_action;
1139};
1140
Jim Ingham4b536182011-08-09 02:12:22 +00001141} // namespace lldb_private
Greg Claytonf4b47e12010-08-04 01:40:35 +00001142
1143StopInfoSP
1144StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id)
1145{
1146 return StopInfoSP (new StopInfoBreakpoint (thread, break_id));
1147}
1148
1149StopInfoSP
Jim Ingham36f3b362010-10-14 23:45:03 +00001150StopInfo::CreateStopReasonWithBreakpointSiteID (Thread &thread, break_id_t break_id, bool should_stop)
1151{
1152 return StopInfoSP (new StopInfoBreakpoint (thread, break_id, should_stop));
1153}
1154
1155StopInfoSP
Greg Claytonf4b47e12010-08-04 01:40:35 +00001156StopInfo::CreateStopReasonWithWatchpointID (Thread &thread, break_id_t watch_id)
1157{
1158 return StopInfoSP (new StopInfoWatchpoint (thread, watch_id));
1159}
1160
1161StopInfoSP
Pavel Labathc4e25c92015-05-29 10:13:03 +00001162StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo, const char *description)
Greg Claytonf4b47e12010-08-04 01:40:35 +00001163{
Pavel Labathc4e25c92015-05-29 10:13:03 +00001164 return StopInfoSP (new StopInfoUnixSignal (thread, signo, description));
Greg Claytonf4b47e12010-08-04 01:40:35 +00001165}
1166
1167StopInfoSP
1168StopInfo::CreateStopReasonToTrace (Thread &thread)
1169{
1170 return StopInfoSP (new StopInfoTrace (thread));
1171}
1172
1173StopInfoSP
Jim Ingham30fadaf2014-07-08 01:07:32 +00001174StopInfo::CreateStopReasonWithPlan (ThreadPlanSP &plan_sp,
1175 ValueObjectSP return_valobj_sp,
1176 ClangExpressionVariableSP expression_variable_sp)
Greg Claytonf4b47e12010-08-04 01:40:35 +00001177{
Jim Ingham30fadaf2014-07-08 01:07:32 +00001178 return StopInfoSP (new StopInfoThreadPlan (plan_sp, return_valobj_sp, expression_variable_sp));
Greg Claytonf4b47e12010-08-04 01:40:35 +00001179}
Greg Claytona658fd22011-06-04 01:26:29 +00001180
1181StopInfoSP
1182StopInfo::CreateStopReasonWithException (Thread &thread, const char *description)
1183{
1184 return StopInfoSP (new StopInfoException (thread, description));
1185}
Jim Ingham73ca05a2011-12-17 01:35:57 +00001186
Greg Clayton90ba8112012-12-05 00:16:59 +00001187StopInfoSP
1188StopInfo::CreateStopReasonWithExec (Thread &thread)
1189{
1190 return StopInfoSP (new StopInfoExec (thread));
1191}
1192
Jim Ingham73ca05a2011-12-17 01:35:57 +00001193ValueObjectSP
1194StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp)
1195{
1196 if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete)
1197 {
1198 StopInfoThreadPlan *plan_stop_info = static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1199 return plan_stop_info->GetReturnValueObject();
1200 }
1201 else
1202 return ValueObjectSP();
1203}
Jim Ingham30fadaf2014-07-08 01:07:32 +00001204
1205ClangExpressionVariableSP
1206StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp)
1207{
1208 if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete)
1209 {
1210 StopInfoThreadPlan *plan_stop_info = static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1211 return plan_stop_info->GetExpressionVariable();
1212 }
1213 else
1214 return ClangExpressionVariableSP();
1215}