1 | //===-- StopInfo.cpp ------------------------------------------------------===// |
---|---|
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include <string> |
10 | |
11 | #include "lldb/Breakpoint/Breakpoint.h" |
12 | #include "lldb/Breakpoint/BreakpointLocation.h" |
13 | #include "lldb/Breakpoint/StoppointCallbackContext.h" |
14 | #include "lldb/Breakpoint/Watchpoint.h" |
15 | #include "lldb/Breakpoint/WatchpointResource.h" |
16 | #include "lldb/Core/Debugger.h" |
17 | #include "lldb/Expression/UserExpression.h" |
18 | #include "lldb/Symbol/Block.h" |
19 | #include "lldb/Target/Process.h" |
20 | #include "lldb/Target/StopInfo.h" |
21 | #include "lldb/Target/Target.h" |
22 | #include "lldb/Target/Thread.h" |
23 | #include "lldb/Target/ThreadPlan.h" |
24 | #include "lldb/Target/ThreadPlanStepInstruction.h" |
25 | #include "lldb/Target/UnixSignals.h" |
26 | #include "lldb/Utility/LLDBLog.h" |
27 | #include "lldb/Utility/Log.h" |
28 | #include "lldb/Utility/StreamString.h" |
29 | #include "lldb/ValueObject/ValueObject.h" |
30 | |
31 | using namespace lldb; |
32 | using namespace lldb_private; |
33 | |
34 | StopInfo::StopInfo(Thread &thread, uint64_t value) |
35 | : m_thread_wp(thread.shared_from_this()), |
36 | m_stop_id(thread.GetProcess()->GetStopID()), |
37 | m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value), |
38 | m_description(), m_override_should_notify(eLazyBoolCalculate), |
39 | m_override_should_stop(eLazyBoolCalculate), m_extended_info() {} |
40 | |
41 | bool StopInfo::IsValid() const { |
42 | ThreadSP thread_sp(m_thread_wp.lock()); |
43 | if (thread_sp) |
44 | return thread_sp->GetProcess()->GetStopID() == m_stop_id; |
45 | return false; |
46 | } |
47 | |
48 | void StopInfo::MakeStopInfoValid() { |
49 | ThreadSP thread_sp(m_thread_wp.lock()); |
50 | if (thread_sp) { |
51 | m_stop_id = thread_sp->GetProcess()->GetStopID(); |
52 | m_resume_id = thread_sp->GetProcess()->GetResumeID(); |
53 | } |
54 | } |
55 | |
56 | bool StopInfo::HasTargetRunSinceMe() { |
57 | ThreadSP thread_sp(m_thread_wp.lock()); |
58 | |
59 | if (thread_sp) { |
60 | lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState(); |
61 | if (ret_type == eStateRunning) { |
62 | return true; |
63 | } else if (ret_type == eStateStopped) { |
64 | // This is a little tricky. We want to count "run and stopped again |
65 | // before you could ask this question as a "TRUE" answer to |
66 | // HasTargetRunSinceMe. But we don't want to include any running of the |
67 | // target done for expressions. So we track both resumes, and resumes |
68 | // caused by expressions, and check if there are any resumes |
69 | // NOT caused |
70 | // by expressions. |
71 | |
72 | uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID(); |
73 | uint32_t last_user_expression_id = |
74 | thread_sp->GetProcess()->GetLastUserExpressionResumeID(); |
75 | if (curr_resume_id == m_resume_id) { |
76 | return false; |
77 | } else if (curr_resume_id > last_user_expression_id) { |
78 | return true; |
79 | } |
80 | } |
81 | } |
82 | return false; |
83 | } |
84 | |
85 | // StopInfoBreakpoint |
86 | |
87 | namespace lldb_private { |
88 | class StopInfoBreakpoint : public StopInfo { |
89 | public: |
90 | StopInfoBreakpoint(Thread &thread, break_id_t break_id) |
91 | : StopInfo(thread, break_id), m_should_stop(false), |
92 | m_should_stop_is_valid(false), m_should_perform_action(true), |
93 | m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID), |
94 | m_was_all_internal(false), m_was_one_shot(false) { |
95 | StoreBPInfo(); |
96 | } |
97 | |
98 | StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop) |
99 | : StopInfo(thread, break_id), m_should_stop(should_stop), |
100 | m_should_stop_is_valid(true), m_should_perform_action(true), |
101 | m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID), |
102 | m_was_all_internal(false), m_was_one_shot(false) { |
103 | StoreBPInfo(); |
104 | } |
105 | |
106 | ~StopInfoBreakpoint() override = default; |
107 | |
108 | void StoreBPInfo() { |
109 | ThreadSP thread_sp(m_thread_wp.lock()); |
110 | if (thread_sp) { |
111 | BreakpointSiteSP bp_site_sp( |
112 | thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(site_id: m_value)); |
113 | if (bp_site_sp) { |
114 | uint32_t num_constituents = bp_site_sp->GetNumberOfConstituents(); |
115 | if (num_constituents == 1) { |
116 | BreakpointLocationSP bp_loc_sp = bp_site_sp->GetConstituentAtIndex(idx: 0); |
117 | if (bp_loc_sp) { |
118 | Breakpoint & bkpt = bp_loc_sp->GetBreakpoint(); |
119 | m_break_id = bkpt.GetID(); |
120 | m_was_one_shot = bkpt.IsOneShot(); |
121 | m_was_all_internal = bkpt.IsInternal(); |
122 | } |
123 | } else { |
124 | m_was_all_internal = true; |
125 | for (uint32_t i = 0; i < num_constituents; i++) { |
126 | if (!bp_site_sp->GetConstituentAtIndex(idx: i) |
127 | ->GetBreakpoint() |
128 | .IsInternal()) { |
129 | m_was_all_internal = false; |
130 | break; |
131 | } |
132 | } |
133 | } |
134 | m_address = bp_site_sp->GetLoadAddress(); |
135 | } |
136 | } |
137 | } |
138 | |
139 | bool IsValidForOperatingSystemThread(Thread &thread) override { |
140 | ProcessSP process_sp(thread.GetProcess()); |
141 | if (process_sp) { |
142 | BreakpointSiteSP bp_site_sp( |
143 | process_sp->GetBreakpointSiteList().FindByID(site_id: m_value)); |
144 | if (bp_site_sp) |
145 | return bp_site_sp->ValidForThisThread(thread); |
146 | } |
147 | return false; |
148 | } |
149 | |
150 | StopReason GetStopReason() const override { return eStopReasonBreakpoint; } |
151 | |
152 | bool ShouldStopSynchronous(Event *event_ptr) override { |
153 | ThreadSP thread_sp(m_thread_wp.lock()); |
154 | if (thread_sp) { |
155 | if (!m_should_stop_is_valid) { |
156 | // Only check once if we should stop at a breakpoint |
157 | BreakpointSiteSP bp_site_sp( |
158 | thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(site_id: m_value)); |
159 | if (bp_site_sp) { |
160 | ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(idx: 0)); |
161 | StoppointCallbackContext context(event_ptr, exe_ctx, true); |
162 | bp_site_sp->BumpHitCounts(); |
163 | m_should_stop = bp_site_sp->ShouldStop(context: &context); |
164 | } else { |
165 | Log *log = GetLog(mask: LLDBLog::Process); |
166 | |
167 | LLDB_LOGF(log, |
168 | "Process::%s could not find breakpoint site id: %"PRId64 |
169 | "...", |
170 | __FUNCTION__, m_value); |
171 | |
172 | m_should_stop = true; |
173 | } |
174 | m_should_stop_is_valid = true; |
175 | } |
176 | return m_should_stop; |
177 | } |
178 | return false; |
179 | } |
180 | |
181 | bool DoShouldNotify(Event *event_ptr) override { |
182 | return !m_was_all_internal; |
183 | } |
184 | |
185 | const char *GetDescription() override { |
186 | if (m_description.empty()) { |
187 | ThreadSP thread_sp(m_thread_wp.lock()); |
188 | if (thread_sp) { |
189 | BreakpointSiteSP bp_site_sp( |
190 | thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(site_id: m_value)); |
191 | if (bp_site_sp) { |
192 | StreamString strm; |
193 | // If we have just hit an internal breakpoint, and it has a kind |
194 | // description, print that instead of the full breakpoint printing: |
195 | if (bp_site_sp->IsInternal()) { |
196 | size_t num_constituents = bp_site_sp->GetNumberOfConstituents(); |
197 | for (size_t idx = 0; idx < num_constituents; idx++) { |
198 | const char *kind = bp_site_sp->GetConstituentAtIndex(idx) |
199 | ->GetBreakpoint() |
200 | .GetBreakpointKind(); |
201 | if (kind != nullptr) { |
202 | m_description.assign(s: kind); |
203 | return kind; |
204 | } |
205 | } |
206 | } |
207 | |
208 | strm.Printf(format: "breakpoint "); |
209 | bp_site_sp->GetDescription(s: &strm, level: eDescriptionLevelBrief); |
210 | m_description = std::string(strm.GetString()); |
211 | } else { |
212 | StreamString strm; |
213 | if (m_break_id != LLDB_INVALID_BREAK_ID) { |
214 | BreakpointSP break_sp = |
215 | thread_sp->GetProcess()->GetTarget().GetBreakpointByID( |
216 | break_id: m_break_id); |
217 | if (break_sp) { |
218 | if (break_sp->IsInternal()) { |
219 | const char *kind = break_sp->GetBreakpointKind(); |
220 | if (kind) |
221 | strm.Printf(format: "internal %s breakpoint(%d).", kind, m_break_id); |
222 | else |
223 | strm.Printf(format: "internal breakpoint(%d).", m_break_id); |
224 | } else { |
225 | strm.Printf(format: "breakpoint %d.", m_break_id); |
226 | } |
227 | } else { |
228 | if (m_was_one_shot) |
229 | strm.Printf(format: "one-shot breakpoint %d", m_break_id); |
230 | else |
231 | strm.Printf(format: "breakpoint %d which has been deleted.", |
232 | m_break_id); |
233 | } |
234 | } else if (m_address == LLDB_INVALID_ADDRESS) |
235 | strm.Printf(format: "breakpoint site %"PRIi64 |
236 | " which has been deleted - unknown address", |
237 | m_value); |
238 | else |
239 | strm.Printf(format: "breakpoint site %"PRIi64 |
240 | " which has been deleted - was at 0x%"PRIx64, |
241 | m_value, m_address); |
242 | |
243 | m_description = std::string(strm.GetString()); |
244 | } |
245 | } |
246 | } |
247 | return m_description.c_str(); |
248 | } |
249 | |
250 | std::optional<uint32_t> |
251 | GetSuggestedStackFrameIndex(bool inlined_stack) override { |
252 | if (!inlined_stack) |
253 | return {}; |
254 | |
255 | ThreadSP thread_sp(m_thread_wp.lock()); |
256 | if (!thread_sp) |
257 | return {}; |
258 | BreakpointSiteSP bp_site_sp( |
259 | thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(site_id: m_value)); |
260 | if (!bp_site_sp) |
261 | return {}; |
262 | |
263 | return bp_site_sp->GetSuggestedStackFrameIndex(); |
264 | } |
265 | |
266 | bool ShouldShow() const override { return !m_was_all_internal; } |
267 | |
268 | bool ShouldSelect() const override { return !m_was_all_internal; } |
269 | |
270 | protected: |
271 | bool ShouldStop(Event *event_ptr) override { |
272 | // This just reports the work done by PerformAction or the synchronous |
273 | // stop. It should only ever get called after they have had a chance to |
274 | // run. |
275 | assert(m_should_stop_is_valid); |
276 | return m_should_stop; |
277 | } |
278 | |
279 | void PerformAction(Event *event_ptr) override { |
280 | if (!m_should_perform_action) |
281 | return; |
282 | m_should_perform_action = false; |
283 | bool all_stopping_locs_internal = true; |
284 | |
285 | ThreadSP thread_sp(m_thread_wp.lock()); |
286 | |
287 | if (thread_sp) { |
288 | Log *log = GetLog(mask: LLDBLog::Breakpoints | LLDBLog::Step); |
289 | |
290 | if (!thread_sp->IsValid()) { |
291 | // This shouldn't ever happen, but just in case, don't do more harm. |
292 | if (log) { |
293 | LLDB_LOGF(log, "PerformAction got called with an invalid thread."); |
294 | } |
295 | m_should_stop = true; |
296 | m_should_stop_is_valid = true; |
297 | return; |
298 | } |
299 | |
300 | BreakpointSiteSP bp_site_sp( |
301 | thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(site_id: m_value)); |
302 | std::unordered_set<break_id_t> precondition_breakpoints; |
303 | // Breakpoints that fail their condition check are not considered to |
304 | // have been hit. If the only locations at this site have failed their |
305 | // conditions, we should change the stop-info to none. Otherwise, if we |
306 | // hit another breakpoint on a different thread which does stop, users |
307 | // will see a breakpont hit with a failed condition, which is wrong. |
308 | // Use this variable to tell us if that is true. |
309 | bool actually_hit_any_locations = false; |
310 | if (bp_site_sp) { |
311 | // Let's copy the constituents list out of the site and store them in a |
312 | // local list. That way if one of the breakpoint actions changes the |
313 | // site, then we won't be operating on a bad list. |
314 | BreakpointLocationCollection site_locations; |
315 | size_t num_constituents = |
316 | bp_site_sp->CopyConstituentsList(out_collection&: site_locations); |
317 | |
318 | if (num_constituents == 0) { |
319 | m_should_stop = true; |
320 | actually_hit_any_locations = true; // We're going to stop, don't |
321 | // change the stop info. |
322 | } else { |
323 | // We go through each location, and test first its precondition - |
324 | // this overrides everything. Note, we only do this once per |
325 | // breakpoint - not once per location... Then check the condition. |
326 | // If the condition says to stop, then we run the callback for that |
327 | // location. If that callback says to stop as well, then we set |
328 | // m_should_stop to true; we are going to stop. But we still want to |
329 | // give all the breakpoints whose conditions say we are going to stop |
330 | // a chance to run their callbacks. Of course if any callback |
331 | // restarts the target by putting "continue" in the callback, then |
332 | // we're going to restart, without running the rest of the callbacks. |
333 | // And in this case we will end up not stopping even if another |
334 | // location said we should stop. But that's better than not running |
335 | // all the callbacks. |
336 | |
337 | // There's one other complication here. We may have run an async |
338 | // breakpoint callback that said we should stop. We only want to |
339 | // override that if another breakpoint action says we shouldn't |
340 | // stop. If nobody else has an opinion, then we should stop if the |
341 | // async callback says we should. An example of this is the async |
342 | // shared library load notification breakpoint and the setting |
343 | // stop-on-sharedlibrary-events. |
344 | // We'll keep the async value in async_should_stop, and track whether |
345 | // anyone said we should NOT stop in actually_said_continue. |
346 | bool async_should_stop = false; |
347 | if (m_should_stop_is_valid) |
348 | async_should_stop = m_should_stop; |
349 | bool actually_said_continue = false; |
350 | |
351 | m_should_stop = false; |
352 | |
353 | // We don't select threads as we go through them testing breakpoint |
354 | // conditions and running commands. So we need to set the thread for |
355 | // expression evaluation here: |
356 | ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp); |
357 | |
358 | ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(idx: 0)); |
359 | Process *process = exe_ctx.GetProcessPtr(); |
360 | if (process->GetModIDRef().IsRunningExpression()) { |
361 | // If we are in the middle of evaluating an expression, don't run |
362 | // asynchronous breakpoint commands or expressions. That could |
363 | // lead to infinite recursion if the command or condition re-calls |
364 | // the function with this breakpoint. |
365 | // TODO: We can keep a list of the breakpoints we've seen while |
366 | // running expressions in the nested |
367 | // PerformAction calls that can arise when the action runs a |
368 | // function that hits another breakpoint, and only stop running |
369 | // commands when we see the same breakpoint hit a second time. |
370 | |
371 | m_should_stop_is_valid = true; |
372 | |
373 | // It is possible that the user has a breakpoint at the same site |
374 | // as the completed plan had (e.g. user has a breakpoint |
375 | // on a module entry point, and `ThreadPlanCallFunction` ends |
376 | // also there). We can't find an internal breakpoint in the loop |
377 | // later because it was already removed on the plan completion. |
378 | // So check if the plan was completed, and stop if so. |
379 | if (thread_sp->CompletedPlanOverridesBreakpoint()) { |
380 | m_should_stop = true; |
381 | thread_sp->ResetStopInfo(); |
382 | return; |
383 | } |
384 | |
385 | LLDB_LOGF(log, "StopInfoBreakpoint::PerformAction - Hit a " |
386 | "breakpoint while running an expression," |
387 | " not running commands to avoid recursion."); |
388 | bool ignoring_breakpoints = |
389 | process->GetIgnoreBreakpointsInExpressions(); |
390 | // Internal breakpoints should be allowed to do their job, we |
391 | // can make sure they don't do anything that would cause recursive |
392 | // command execution: |
393 | if (!m_was_all_internal) { |
394 | m_should_stop = !ignoring_breakpoints; |
395 | LLDB_LOGF(log, |
396 | "StopInfoBreakpoint::PerformAction - in expression, " |
397 | "continuing: %s.", |
398 | m_should_stop ? "true": "false"); |
399 | Debugger::ReportWarning( |
400 | message: "hit breakpoint while running function, skipping commands " |
401 | "and conditions to prevent recursion", |
402 | debugger_id: process->GetTarget().GetDebugger().GetID()); |
403 | return; |
404 | } |
405 | } |
406 | |
407 | StoppointCallbackContext context(event_ptr, exe_ctx, false); |
408 | |
409 | // For safety's sake let's also grab an extra reference to the |
410 | // breakpoint constituents of the locations we're going to examine, |
411 | // since the locations are going to have to get back to their |
412 | // breakpoints, and the locations don't keep their constituents alive. |
413 | // I'm just sticking the BreakpointSP's in a vector since I'm only |
414 | // using it to locally increment their retain counts. |
415 | |
416 | std::vector<lldb::BreakpointSP> location_constituents; |
417 | |
418 | for (size_t j = 0; j < num_constituents; j++) { |
419 | BreakpointLocationSP loc(site_locations.GetByIndex(i: j)); |
420 | location_constituents.push_back( |
421 | x: loc->GetBreakpoint().shared_from_this()); |
422 | } |
423 | |
424 | for (size_t j = 0; j < num_constituents; j++) { |
425 | lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(i: j); |
426 | StreamString loc_desc; |
427 | if (log) { |
428 | bp_loc_sp->GetDescription(s: &loc_desc, level: eDescriptionLevelBrief); |
429 | } |
430 | // If another action disabled this breakpoint or its location, then |
431 | // don't run the actions. |
432 | if (!bp_loc_sp->IsEnabled() || |
433 | !bp_loc_sp->GetBreakpoint().IsEnabled()) |
434 | continue; |
435 | |
436 | // The breakpoint site may have many locations associated with it, |
437 | // not all of them valid for this thread. Skip the ones that |
438 | // aren't: |
439 | if (!bp_loc_sp->ValidForThisThread(thread&: *thread_sp)) { |
440 | if (log) { |
441 | LLDB_LOGF(log, |
442 | "Breakpoint %s hit on thread 0x%llx but it was not " |
443 | "for this thread, continuing.", |
444 | loc_desc.GetData(), |
445 | static_cast<unsigned long long>(thread_sp->GetID())); |
446 | } |
447 | continue; |
448 | } |
449 | |
450 | // First run the precondition, but since the precondition is per |
451 | // breakpoint, only run it once per breakpoint. |
452 | std::pair<std::unordered_set<break_id_t>::iterator, bool> result = |
453 | precondition_breakpoints.insert( |
454 | x: bp_loc_sp->GetBreakpoint().GetID()); |
455 | if (!result.second) |
456 | continue; |
457 | |
458 | bool precondition_result = |
459 | bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context); |
460 | if (!precondition_result) { |
461 | actually_said_continue = true; |
462 | continue; |
463 | } |
464 | // Next run the condition for the breakpoint. If that says we |
465 | // should stop, then we'll run the callback for the breakpoint. If |
466 | // the callback says we shouldn't stop that will win. |
467 | |
468 | if (bp_loc_sp->GetConditionText() == nullptr) |
469 | actually_hit_any_locations = true; |
470 | else { |
471 | Status condition_error; |
472 | bool condition_says_stop = |
473 | bp_loc_sp->ConditionSaysStop(exe_ctx, error&: condition_error); |
474 | |
475 | if (!condition_error.Success()) { |
476 | // If the condition fails to evaluate, we are going to stop |
477 | // at it, so the location was hit. |
478 | actually_hit_any_locations = true; |
479 | const char *err_str = |
480 | condition_error.AsCString(default_error_str: "<unknown error>"); |
481 | LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str); |
482 | |
483 | StreamString strm; |
484 | strm << "stopped due to an error evaluating condition of " |
485 | "breakpoint "; |
486 | bp_loc_sp->GetDescription(s: &strm, level: eDescriptionLevelBrief); |
487 | strm << ": \""<< bp_loc_sp->GetConditionText() << "\"\n"; |
488 | strm << err_str; |
489 | |
490 | Debugger::ReportError( |
491 | message: strm.GetString().str(), |
492 | debugger_id: exe_ctx.GetTargetRef().GetDebugger().GetID()); |
493 | } else { |
494 | LLDB_LOGF(log, |
495 | "Condition evaluated for breakpoint %s on thread " |
496 | "0x%llx condition_says_stop: %i.", |
497 | loc_desc.GetData(), |
498 | static_cast<unsigned long long>(thread_sp->GetID()), |
499 | condition_says_stop); |
500 | if (condition_says_stop) |
501 | actually_hit_any_locations = true; |
502 | else { |
503 | // We don't want to increment the hit count of breakpoints if |
504 | // the condition fails. We've already bumped it by the time |
505 | // we get here, so undo the bump: |
506 | bp_loc_sp->UndoBumpHitCount(); |
507 | actually_said_continue = true; |
508 | continue; |
509 | } |
510 | } |
511 | } |
512 | |
513 | // We've done all the checks whose failure means "we consider lldb |
514 | // not to have hit the breakpoint". Now we're going to check for |
515 | // conditions that might continue after hitting. Start with the |
516 | // ignore count: |
517 | if (!bp_loc_sp->IgnoreCountShouldStop()) { |
518 | actually_said_continue = true; |
519 | continue; |
520 | } |
521 | |
522 | // Check the auto-continue bit on the location, do this before the |
523 | // callback since it may change this, but that would be for the |
524 | // NEXT hit. Note, you might think you could check auto-continue |
525 | // before the condition, and not evaluate the condition if it says |
526 | // to continue. But failing the condition means the breakpoint was |
527 | // effectively NOT HIT. So these two states are different. |
528 | bool auto_continue_says_stop = true; |
529 | if (bp_loc_sp->IsAutoContinue()) |
530 | { |
531 | LLDB_LOGF(log, |
532 | "Continuing breakpoint %s as AutoContinue was set.", |
533 | loc_desc.GetData()); |
534 | // We want this stop reported, so you will know we auto-continued |
535 | // but only for external breakpoints: |
536 | if (!bp_loc_sp->GetBreakpoint().IsInternal()) |
537 | thread_sp->SetShouldReportStop(eVoteYes); |
538 | auto_continue_says_stop = false; |
539 | } |
540 | |
541 | bool callback_says_stop = true; |
542 | |
543 | // FIXME: For now the callbacks have to run in async mode - the |
544 | // first time we restart we need |
545 | // to get out of there. So set it here. |
546 | // When we figure out how to nest breakpoint hits then this will |
547 | // change. |
548 | |
549 | // Don't run async callbacks in PerformAction. They have already |
550 | // been taken into account with async_should_stop. |
551 | if (!bp_loc_sp->IsCallbackSynchronous()) { |
552 | Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger(); |
553 | bool old_async = debugger.GetAsyncExecution(); |
554 | debugger.SetAsyncExecution(true); |
555 | |
556 | callback_says_stop = bp_loc_sp->InvokeCallback(context: &context); |
557 | |
558 | debugger.SetAsyncExecution(old_async); |
559 | |
560 | if (callback_says_stop && auto_continue_says_stop) |
561 | m_should_stop = true; |
562 | else |
563 | actually_said_continue = true; |
564 | } |
565 | |
566 | if (m_should_stop && !bp_loc_sp->GetBreakpoint().IsInternal()) |
567 | all_stopping_locs_internal = false; |
568 | |
569 | // If we are going to stop for this breakpoint, then remove the |
570 | // breakpoint. |
571 | if (callback_says_stop && bp_loc_sp && |
572 | bp_loc_sp->GetBreakpoint().IsOneShot()) { |
573 | thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID( |
574 | break_id: bp_loc_sp->GetBreakpoint().GetID()); |
575 | } |
576 | // Also make sure that the callback hasn't continued the target. If |
577 | // it did, when we'll set m_should_start to false and get out of |
578 | // here. |
579 | if (HasTargetRunSinceMe()) { |
580 | m_should_stop = false; |
581 | actually_said_continue = true; |
582 | break; |
583 | } |
584 | } |
585 | // At this point if nobody actually told us to continue, we should |
586 | // give the async breakpoint callback a chance to weigh in: |
587 | if (!actually_said_continue && !m_should_stop) { |
588 | m_should_stop = async_should_stop; |
589 | } |
590 | } |
591 | // We've figured out what this stop wants to do, so mark it as valid so |
592 | // we don't compute it again. |
593 | m_should_stop_is_valid = true; |
594 | } else { |
595 | m_should_stop = true; |
596 | m_should_stop_is_valid = true; |
597 | actually_hit_any_locations = true; |
598 | Log *log_process(GetLog(mask: LLDBLog::Process)); |
599 | |
600 | LLDB_LOGF(log_process, |
601 | "Process::%s could not find breakpoint site id: %"PRId64 |
602 | "...", |
603 | __FUNCTION__, m_value); |
604 | } |
605 | |
606 | if ((!m_should_stop || all_stopping_locs_internal) && |
607 | thread_sp->CompletedPlanOverridesBreakpoint()) { |
608 | |
609 | // Override should_stop decision when we have completed step plan |
610 | // additionally to the breakpoint |
611 | m_should_stop = true; |
612 | |
613 | // We know we're stopping for a completed plan and we don't want to |
614 | // show the breakpoint stop, so compute the public stop info immediately |
615 | // here. |
616 | thread_sp->CalculatePublicStopInfo(); |
617 | } else if (!actually_hit_any_locations) { |
618 | // In the end, we didn't actually have any locations that passed their |
619 | // "was I hit" checks. So say we aren't stopped. |
620 | GetThread()->ResetStopInfo(); |
621 | LLDB_LOGF(log, "Process::%s all locations failed condition checks.", |
622 | __FUNCTION__); |
623 | } |
624 | |
625 | LLDB_LOGF(log, |
626 | "Process::%s returning from action with m_should_stop: %d.", |
627 | __FUNCTION__, m_should_stop); |
628 | } |
629 | } |
630 | |
631 | private: |
632 | bool m_should_stop; |
633 | bool m_should_stop_is_valid; |
634 | bool m_should_perform_action; // Since we are trying to preserve the "state" |
635 | // of the system even if we run functions |
636 | // etc. behind the users backs, we need to make sure we only REALLY perform |
637 | // the action once. |
638 | lldb::addr_t m_address; // We use this to capture the breakpoint site address |
639 | // when we create the StopInfo, |
640 | // in case somebody deletes it between the time the StopInfo is made and the |
641 | // description is asked for. |
642 | lldb::break_id_t m_break_id; |
643 | bool m_was_all_internal; |
644 | bool m_was_one_shot; |
645 | }; |
646 | |
647 | // StopInfoWatchpoint |
648 | |
649 | class StopInfoWatchpoint : public StopInfo { |
650 | public: |
651 | // Make sure watchpoint is properly disabled and subsequently enabled while |
652 | // performing watchpoint actions. |
653 | class WatchpointSentry { |
654 | public: |
655 | WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp), |
656 | watchpoint_sp(w_sp) { |
657 | if (process_sp && watchpoint_sp) { |
658 | const bool notify = false; |
659 | watchpoint_sp->TurnOnEphemeralMode(); |
660 | process_sp->DisableWatchpoint(wp_sp: watchpoint_sp, notify); |
661 | process_sp->AddPreResumeAction(callback: SentryPreResumeAction, baton: this); |
662 | } |
663 | } |
664 | |
665 | void DoReenable() { |
666 | if (process_sp && watchpoint_sp) { |
667 | bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode(); |
668 | watchpoint_sp->TurnOffEphemeralMode(); |
669 | const bool notify = false; |
670 | if (was_disabled) { |
671 | process_sp->DisableWatchpoint(wp_sp: watchpoint_sp, notify); |
672 | } else { |
673 | process_sp->EnableWatchpoint(wp_sp: watchpoint_sp, notify); |
674 | } |
675 | } |
676 | } |
677 | |
678 | ~WatchpointSentry() { |
679 | DoReenable(); |
680 | if (process_sp) |
681 | process_sp->ClearPreResumeAction(callback: SentryPreResumeAction, baton: this); |
682 | } |
683 | |
684 | static bool SentryPreResumeAction(void *sentry_void) { |
685 | WatchpointSentry *sentry = (WatchpointSentry *) sentry_void; |
686 | sentry->DoReenable(); |
687 | return true; |
688 | } |
689 | |
690 | private: |
691 | ProcessSP process_sp; |
692 | WatchpointSP watchpoint_sp; |
693 | }; |
694 | |
695 | StopInfoWatchpoint(Thread &thread, break_id_t watch_id, bool silently_skip_wp) |
696 | : StopInfo(thread, watch_id), m_silently_skip_wp(silently_skip_wp) {} |
697 | |
698 | ~StopInfoWatchpoint() override = default; |
699 | |
700 | StopReason GetStopReason() const override { return eStopReasonWatchpoint; } |
701 | |
702 | const char *GetDescription() override { |
703 | if (m_description.empty()) { |
704 | StreamString strm; |
705 | strm.Printf(format: "watchpoint %"PRIi64, m_value); |
706 | m_description = std::string(strm.GetString()); |
707 | } |
708 | return m_description.c_str(); |
709 | } |
710 | |
711 | protected: |
712 | using StopInfoWatchpointSP = std::shared_ptr<StopInfoWatchpoint>; |
713 | // This plan is used to orchestrate stepping over the watchpoint for |
714 | // architectures (e.g. ARM) that report the watch before running the watched |
715 | // access. This is the sort of job you have to defer to the thread plans, |
716 | // if you try to do it directly in the stop info and there are other threads |
717 | // that needed to process this stop you will have yanked control away from |
718 | // them and they won't behave correctly. |
719 | class ThreadPlanStepOverWatchpoint : public ThreadPlanStepInstruction { |
720 | public: |
721 | ThreadPlanStepOverWatchpoint(Thread &thread, |
722 | StopInfoWatchpointSP stop_info_sp, |
723 | WatchpointSP watch_sp) |
724 | : ThreadPlanStepInstruction(thread, false, true, eVoteNoOpinion, |
725 | eVoteNoOpinion), |
726 | m_stop_info_sp(stop_info_sp), m_watch_sp(watch_sp) { |
727 | assert(watch_sp); |
728 | } |
729 | |
730 | bool DoWillResume(lldb::StateType resume_state, |
731 | bool current_plan) override { |
732 | if (resume_state == eStateSuspended) |
733 | return true; |
734 | |
735 | if (!m_did_disable_wp) { |
736 | GetThread().GetProcess()->DisableWatchpoint(wp_sp: m_watch_sp, notify: false); |
737 | m_did_disable_wp = true; |
738 | } |
739 | return true; |
740 | } |
741 | |
742 | bool DoPlanExplainsStop(Event *event_ptr) override { |
743 | if (ThreadPlanStepInstruction::DoPlanExplainsStop(event_ptr)) |
744 | return true; |
745 | StopInfoSP stop_info_sp = GetThread().GetPrivateStopInfo(); |
746 | // lldb-server resets the stop info for threads that didn't get to run, |
747 | // so we might have not gotten to run, but still have a watchpoint stop |
748 | // reason, in which case this will indeed be for us. |
749 | if (stop_info_sp |
750 | && stop_info_sp->GetStopReason() == eStopReasonWatchpoint) |
751 | return true; |
752 | return false; |
753 | } |
754 | |
755 | void DidPop() override { |
756 | // Don't artifically keep the watchpoint alive. |
757 | m_watch_sp.reset(); |
758 | } |
759 | |
760 | bool ShouldStop(Event *event_ptr) override { |
761 | bool should_stop = ThreadPlanStepInstruction::ShouldStop(event_ptr); |
762 | bool plan_done = MischiefManaged(); |
763 | if (plan_done) { |
764 | m_stop_info_sp->SetStepOverPlanComplete(); |
765 | GetThread().SetStopInfo(m_stop_info_sp); |
766 | ResetWatchpoint(); |
767 | } |
768 | return should_stop; |
769 | } |
770 | |
771 | bool ShouldRunBeforePublicStop() override { |
772 | return true; |
773 | } |
774 | |
775 | protected: |
776 | void ResetWatchpoint() { |
777 | if (!m_did_disable_wp) |
778 | return; |
779 | m_did_disable_wp = true; |
780 | GetThread().GetProcess()->EnableWatchpoint(wp_sp: m_watch_sp, notify: true); |
781 | } |
782 | |
783 | private: |
784 | StopInfoWatchpointSP m_stop_info_sp; |
785 | WatchpointSP m_watch_sp; |
786 | bool m_did_disable_wp = false; |
787 | }; |
788 | |
789 | bool ShouldStopSynchronous(Event *event_ptr) override { |
790 | // If we are running our step-over the watchpoint plan, stop if it's done |
791 | // and continue if it's not: |
792 | if (m_should_stop_is_valid) |
793 | return m_should_stop; |
794 | |
795 | // If we are running our step over plan, then stop here and let the regular |
796 | // ShouldStop figure out what we should do: Otherwise, give our plan |
797 | // more time to get run: |
798 | if (m_using_step_over_plan) |
799 | return m_step_over_plan_complete; |
800 | |
801 | Log *log = GetLog(mask: LLDBLog::Process); |
802 | ThreadSP thread_sp(m_thread_wp.lock()); |
803 | assert(thread_sp); |
804 | |
805 | if (thread_sp->GetTemporaryResumeState() == eStateSuspended) { |
806 | // This is the second firing of a watchpoint so don't process it again. |
807 | LLDB_LOG(log, "We didn't run but stopped with a StopInfoWatchpoint, we " |
808 | "have already handled this one, don't do it again."); |
809 | m_should_stop = false; |
810 | m_should_stop_is_valid = true; |
811 | return m_should_stop; |
812 | } |
813 | |
814 | WatchpointSP wp_sp( |
815 | thread_sp->CalculateTarget()->GetWatchpointList().FindByID(watchID: GetValue())); |
816 | // If we can no longer find the watchpoint, we just have to stop: |
817 | if (!wp_sp) { |
818 | |
819 | LLDB_LOGF(log, |
820 | "Process::%s could not find watchpoint location id: %"PRId64 |
821 | "...", |
822 | __FUNCTION__, GetValue()); |
823 | |
824 | m_should_stop = true; |
825 | m_should_stop_is_valid = true; |
826 | return true; |
827 | } |
828 | |
829 | ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(idx: 0)); |
830 | StoppointCallbackContext context(event_ptr, exe_ctx, true); |
831 | m_should_stop = wp_sp->ShouldStop(context: &context); |
832 | if (!m_should_stop) { |
833 | // This won't happen at present because we only allow one watchpoint per |
834 | // watched range. So we won't stop at a watched address with a disabled |
835 | // watchpoint. If we start allowing overlapping watchpoints, then we |
836 | // will have to make watchpoints be real "WatchpointSite" and delegate to |
837 | // all the watchpoints sharing the site. In that case, the code below |
838 | // would be the right thing to do. |
839 | m_should_stop_is_valid = true; |
840 | return m_should_stop; |
841 | } |
842 | // If this is a system where we need to execute the watchpoint by hand |
843 | // after the hit, queue a thread plan to do that, and then say not to stop. |
844 | // Otherwise, let the async action figure out whether the watchpoint should |
845 | // stop |
846 | |
847 | ProcessSP process_sp = exe_ctx.GetProcessSP(); |
848 | bool wp_triggers_after = process_sp->GetWatchpointReportedAfter(); |
849 | |
850 | if (!wp_triggers_after) { |
851 | // We have to step over the watchpoint before we know what to do: |
852 | StopInfoWatchpointSP me_as_siwp_sp |
853 | = std::static_pointer_cast<StopInfoWatchpoint>(r: shared_from_this()); |
854 | ThreadPlanSP step_over_wp_sp(new ThreadPlanStepOverWatchpoint( |
855 | *(thread_sp.get()), me_as_siwp_sp, wp_sp)); |
856 | // When this plan is done we want to stop, so set this as a Controlling |
857 | // plan. |
858 | step_over_wp_sp->SetIsControllingPlan(true); |
859 | step_over_wp_sp->SetOkayToDiscard(false); |
860 | |
861 | Status error; |
862 | error = thread_sp->QueueThreadPlan(plan_sp&: step_over_wp_sp, abort_other_plans: false); |
863 | // If we couldn't push the thread plan, just stop here: |
864 | if (!error.Success()) { |
865 | LLDB_LOGF(log, "Could not push our step over watchpoint plan: %s", |
866 | error.AsCString()); |
867 | |
868 | m_should_stop = true; |
869 | m_should_stop_is_valid = true; |
870 | return true; |
871 | } else { |
872 | // Otherwise, don't set m_should_stop, we don't know that yet. Just |
873 | // say we should continue, and tell the thread we really should do so: |
874 | thread_sp->SetShouldRunBeforePublicStop(true); |
875 | m_using_step_over_plan = true; |
876 | return false; |
877 | } |
878 | } else { |
879 | // We didn't have to do anything special |
880 | m_should_stop_is_valid = true; |
881 | return m_should_stop; |
882 | } |
883 | |
884 | return m_should_stop; |
885 | } |
886 | |
887 | bool ShouldStop(Event *event_ptr) override { |
888 | // This just reports the work done by PerformAction or the synchronous |
889 | // stop. It should only ever get called after they have had a chance to |
890 | // run. |
891 | assert(m_should_stop_is_valid); |
892 | return m_should_stop; |
893 | } |
894 | |
895 | void PerformAction(Event *event_ptr) override { |
896 | Log *log = GetLog(mask: LLDBLog::Watchpoints); |
897 | // We're going to calculate if we should stop or not in some way during the |
898 | // course of this code. Also by default we're going to stop, so set that |
899 | // here. |
900 | m_should_stop = true; |
901 | |
902 | |
903 | ThreadSP thread_sp(m_thread_wp.lock()); |
904 | if (thread_sp) { |
905 | |
906 | WatchpointSP wp_sp( |
907 | thread_sp->CalculateTarget()->GetWatchpointList().FindByID( |
908 | watchID: GetValue())); |
909 | if (wp_sp) { |
910 | // This sentry object makes sure the current watchpoint is disabled |
911 | // while performing watchpoint actions, and it is then enabled after we |
912 | // are finished. |
913 | ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(idx: 0)); |
914 | ProcessSP process_sp = exe_ctx.GetProcessSP(); |
915 | |
916 | WatchpointSentry sentry(process_sp, wp_sp); |
917 | |
918 | if (m_silently_skip_wp) { |
919 | m_should_stop = false; |
920 | wp_sp->UndoHitCount(); |
921 | } |
922 | |
923 | if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount()) { |
924 | m_should_stop = false; |
925 | m_should_stop_is_valid = true; |
926 | } |
927 | |
928 | Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); |
929 | |
930 | if (m_should_stop && wp_sp->GetConditionText() != nullptr) { |
931 | // We need to make sure the user sees any parse errors in their |
932 | // condition, so we'll hook the constructor errors up to the |
933 | // debugger's Async I/O. |
934 | ExpressionResults result_code; |
935 | EvaluateExpressionOptions expr_options; |
936 | expr_options.SetUnwindOnError(true); |
937 | expr_options.SetIgnoreBreakpoints(true); |
938 | ValueObjectSP result_value_sp; |
939 | result_code = UserExpression::Evaluate( |
940 | exe_ctx, options: expr_options, expr_cstr: wp_sp->GetConditionText(), |
941 | expr_prefix: llvm::StringRef(), result_valobj_sp&: result_value_sp); |
942 | |
943 | if (result_code == eExpressionCompleted) { |
944 | if (result_value_sp) { |
945 | Scalar scalar_value; |
946 | if (result_value_sp->ResolveValue(scalar&: scalar_value)) { |
947 | if (scalar_value.ULongLong(fail_value: 1) == 0) { |
948 | // The condition failed, which we consider "not having hit |
949 | // the watchpoint" so undo the hit count here. |
950 | wp_sp->UndoHitCount(); |
951 | m_should_stop = false; |
952 | } else |
953 | m_should_stop = true; |
954 | LLDB_LOGF(log, |
955 | "Condition successfully evaluated, result is %s.\n", |
956 | m_should_stop ? "true": "false"); |
957 | } else { |
958 | m_should_stop = true; |
959 | LLDB_LOGF( |
960 | log, |
961 | "Failed to get an integer result from the expression."); |
962 | } |
963 | } |
964 | } else { |
965 | const char *err_str = "<unknown error>"; |
966 | if (result_value_sp) |
967 | err_str = result_value_sp->GetError().AsCString(); |
968 | |
969 | LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str); |
970 | |
971 | StreamString strm; |
972 | strm << "stopped due to an error evaluating condition of " |
973 | "watchpoint "; |
974 | wp_sp->GetDescription(s: &strm, level: eDescriptionLevelBrief); |
975 | strm << ": \""<< wp_sp->GetConditionText() << "\"\n"; |
976 | strm << err_str; |
977 | |
978 | Debugger::ReportError(message: strm.GetString().str(), |
979 | debugger_id: exe_ctx.GetTargetRef().GetDebugger().GetID()); |
980 | } |
981 | } |
982 | |
983 | // If the condition says to stop, we run the callback to further decide |
984 | // whether to stop. |
985 | if (m_should_stop) { |
986 | // FIXME: For now the callbacks have to run in async mode - the |
987 | // first time we restart we need |
988 | // to get out of there. So set it here. |
989 | // When we figure out how to nest watchpoint hits then this will |
990 | // change. |
991 | |
992 | bool old_async = debugger.GetAsyncExecution(); |
993 | debugger.SetAsyncExecution(true); |
994 | |
995 | StoppointCallbackContext context(event_ptr, exe_ctx, false); |
996 | bool stop_requested = wp_sp->InvokeCallback(context: &context); |
997 | |
998 | debugger.SetAsyncExecution(old_async); |
999 | |
1000 | // Also make sure that the callback hasn't continued the target. If |
1001 | // it did, when we'll set m_should_stop to false and get out of here. |
1002 | if (HasTargetRunSinceMe()) |
1003 | m_should_stop = false; |
1004 | |
1005 | if (m_should_stop && !stop_requested) { |
1006 | // We have been vetoed by the callback mechanism. |
1007 | m_should_stop = false; |
1008 | } |
1009 | } |
1010 | |
1011 | // Don't stop if the watched region value is unmodified, and |
1012 | // this is a Modify-type watchpoint. |
1013 | if (m_should_stop && !wp_sp->WatchedValueReportable(exe_ctx)) { |
1014 | wp_sp->UndoHitCount(); |
1015 | m_should_stop = false; |
1016 | } |
1017 | |
1018 | // Finally, if we are going to stop, print out the new & old values: |
1019 | if (m_should_stop) { |
1020 | wp_sp->CaptureWatchedValue(exe_ctx); |
1021 | |
1022 | Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger(); |
1023 | StreamUP output_up = debugger.GetAsyncOutputStream(); |
1024 | if (wp_sp->DumpSnapshots(s: output_up.get())) |
1025 | output_up->EOL(); |
1026 | } |
1027 | |
1028 | } else { |
1029 | Log *log_process(GetLog(mask: LLDBLog::Process)); |
1030 | |
1031 | LLDB_LOGF(log_process, |
1032 | "Process::%s could not find watchpoint id: %"PRId64 "...", |
1033 | __FUNCTION__, m_value); |
1034 | } |
1035 | LLDB_LOGF(log, |
1036 | "Process::%s returning from action with m_should_stop: %d.", |
1037 | __FUNCTION__, m_should_stop); |
1038 | |
1039 | m_should_stop_is_valid = true; |
1040 | } |
1041 | } |
1042 | |
1043 | private: |
1044 | void SetStepOverPlanComplete() { |
1045 | assert(m_using_step_over_plan); |
1046 | m_step_over_plan_complete = true; |
1047 | } |
1048 | |
1049 | bool m_should_stop = false; |
1050 | bool m_should_stop_is_valid = false; |
1051 | // A false watchpoint hit has happened - |
1052 | // the thread stopped with a watchpoint |
1053 | // hit notification, but the watched region |
1054 | // was not actually accessed (as determined |
1055 | // by the gdb stub we're talking to). |
1056 | // Continue past this watchpoint without |
1057 | // notifying the user; on some targets this |
1058 | // may mean disable wp, instruction step, |
1059 | // re-enable wp, continue. |
1060 | // On others, just continue. |
1061 | bool m_silently_skip_wp = false; |
1062 | bool m_step_over_plan_complete = false; |
1063 | bool m_using_step_over_plan = false; |
1064 | }; |
1065 | |
1066 | // StopInfoUnixSignal |
1067 | |
1068 | class StopInfoUnixSignal : public StopInfo { |
1069 | public: |
1070 | StopInfoUnixSignal(Thread &thread, int signo, const char *description, |
1071 | std::optional<int> code) |
1072 | : StopInfo(thread, signo), m_code(code) { |
1073 | SetDescription(description); |
1074 | } |
1075 | |
1076 | ~StopInfoUnixSignal() override = default; |
1077 | |
1078 | StopReason GetStopReason() const override { return eStopReasonSignal; } |
1079 | |
1080 | bool ShouldStopSynchronous(Event *event_ptr) override { |
1081 | ThreadSP thread_sp(m_thread_wp.lock()); |
1082 | if (thread_sp) |
1083 | return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(signo: m_value); |
1084 | return false; |
1085 | } |
1086 | |
1087 | bool ShouldStop(Event *event_ptr) override { return IsShouldStopSignal(); } |
1088 | |
1089 | // If should stop returns false, check if we should notify of this event |
1090 | bool DoShouldNotify(Event *event_ptr) override { |
1091 | ThreadSP thread_sp(m_thread_wp.lock()); |
1092 | if (thread_sp) { |
1093 | bool should_notify = |
1094 | thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(signo: m_value); |
1095 | if (should_notify) { |
1096 | StreamString strm; |
1097 | strm.Format( |
1098 | format: "thread {0:d} received signal: {1}", args: thread_sp->GetIndexID(), |
1099 | args: thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsStringRef( |
1100 | signo: m_value)); |
1101 | Process::ProcessEventData::AddRestartedReason(event_ptr, |
1102 | reason: strm.GetData()); |
1103 | } |
1104 | return should_notify; |
1105 | } |
1106 | return true; |
1107 | } |
1108 | |
1109 | void WillResume(lldb::StateType resume_state) override { |
1110 | ThreadSP thread_sp(m_thread_wp.lock()); |
1111 | if (thread_sp) { |
1112 | if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress( |
1113 | signo: m_value)) |
1114 | thread_sp->SetResumeSignal(m_value); |
1115 | } |
1116 | } |
1117 | |
1118 | const char *GetDescription() override { |
1119 | if (m_description.empty()) { |
1120 | ThreadSP thread_sp(m_thread_wp.lock()); |
1121 | if (thread_sp) { |
1122 | UnixSignalsSP unix_signals = thread_sp->GetProcess()->GetUnixSignals(); |
1123 | StreamString strm; |
1124 | strm << "signal "; |
1125 | |
1126 | std::string signal_name = |
1127 | unix_signals->GetSignalDescription(signo: m_value, code: m_code); |
1128 | if (signal_name.size()) |
1129 | strm << signal_name; |
1130 | else |
1131 | strm.Printf(format: "%"PRIi64, m_value); |
1132 | |
1133 | m_description = std::string(strm.GetString()); |
1134 | } |
1135 | } |
1136 | return m_description.c_str(); |
1137 | } |
1138 | |
1139 | bool ShouldSelect() const override { return IsShouldStopSignal(); } |
1140 | |
1141 | private: |
1142 | // In siginfo_t terms, if m_value is si_signo, m_code is si_code. |
1143 | std::optional<int> m_code; |
1144 | |
1145 | bool IsShouldStopSignal() const { |
1146 | if (ThreadSP thread_sp = m_thread_wp.lock()) |
1147 | return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(signo: m_value); |
1148 | return false; |
1149 | } |
1150 | }; |
1151 | |
1152 | // StopInfoInterrupt |
1153 | |
1154 | class StopInfoInterrupt : public StopInfo { |
1155 | public: |
1156 | StopInfoInterrupt(Thread &thread, int signo, const char *description) |
1157 | : StopInfo(thread, signo) { |
1158 | SetDescription(description); |
1159 | } |
1160 | |
1161 | ~StopInfoInterrupt() override = default; |
1162 | |
1163 | StopReason GetStopReason() const override { |
1164 | return lldb::eStopReasonInterrupt; |
1165 | } |
1166 | |
1167 | const char *GetDescription() override { |
1168 | if (m_description.empty()) { |
1169 | m_description = "async interrupt"; |
1170 | } |
1171 | return m_description.c_str(); |
1172 | } |
1173 | }; |
1174 | |
1175 | // StopInfoTrace |
1176 | |
1177 | class StopInfoTrace : public StopInfo { |
1178 | public: |
1179 | StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {} |
1180 | |
1181 | ~StopInfoTrace() override = default; |
1182 | |
1183 | StopReason GetStopReason() const override { return eStopReasonTrace; } |
1184 | |
1185 | const char *GetDescription() override { |
1186 | if (m_description.empty()) |
1187 | return "trace"; |
1188 | else |
1189 | return m_description.c_str(); |
1190 | } |
1191 | |
1192 | std::optional<uint32_t> |
1193 | GetSuggestedStackFrameIndex(bool inlined_stack) override { |
1194 | // Trace only knows how to adjust inlined stacks: |
1195 | if (!inlined_stack) |
1196 | return {}; |
1197 | |
1198 | ThreadSP thread_sp = GetThread(); |
1199 | StackFrameSP frame_0_sp = thread_sp->GetStackFrameAtIndex(idx: 0); |
1200 | if (!frame_0_sp) |
1201 | return {}; |
1202 | if (!frame_0_sp->IsInlined()) |
1203 | return {}; |
1204 | Block *block_ptr = frame_0_sp->GetFrameBlock(); |
1205 | if (!block_ptr) |
1206 | return {}; |
1207 | Address pc_address = frame_0_sp->GetFrameCodeAddress(); |
1208 | AddressRange containing_range; |
1209 | if (!block_ptr->GetRangeContainingAddress(addr: pc_address, range&: containing_range) || |
1210 | pc_address != containing_range.GetBaseAddress()) |
1211 | return {}; |
1212 | |
1213 | int num_inlined_functions = 0; |
1214 | |
1215 | for (Block *container_ptr = block_ptr->GetInlinedParent(); |
1216 | container_ptr != nullptr; |
1217 | container_ptr = container_ptr->GetInlinedParent()) { |
1218 | if (!container_ptr->GetRangeContainingAddress(addr: pc_address, |
1219 | range&: containing_range)) |
1220 | break; |
1221 | if (pc_address != containing_range.GetBaseAddress()) |
1222 | break; |
1223 | |
1224 | num_inlined_functions++; |
1225 | } |
1226 | inlined_stack = true; |
1227 | return num_inlined_functions + 1; |
1228 | } |
1229 | }; |
1230 | |
1231 | // StopInfoException |
1232 | |
1233 | class StopInfoException : public StopInfo { |
1234 | public: |
1235 | StopInfoException(Thread &thread, const char *description) |
1236 | : StopInfo(thread, LLDB_INVALID_UID) { |
1237 | if (description) |
1238 | SetDescription(description); |
1239 | } |
1240 | |
1241 | ~StopInfoException() override = default; |
1242 | |
1243 | StopReason GetStopReason() const override { return eStopReasonException; } |
1244 | |
1245 | const char *GetDescription() override { |
1246 | if (m_description.empty()) |
1247 | return "exception"; |
1248 | else |
1249 | return m_description.c_str(); |
1250 | } |
1251 | }; |
1252 | |
1253 | // StopInfoProcessorTrace |
1254 | |
1255 | class StopInfoProcessorTrace : public StopInfo { |
1256 | public: |
1257 | StopInfoProcessorTrace(Thread &thread, const char *description) |
1258 | : StopInfo(thread, LLDB_INVALID_UID) { |
1259 | if (description) |
1260 | SetDescription(description); |
1261 | } |
1262 | |
1263 | ~StopInfoProcessorTrace() override = default; |
1264 | |
1265 | StopReason GetStopReason() const override { |
1266 | return eStopReasonProcessorTrace; |
1267 | } |
1268 | |
1269 | const char *GetDescription() override { |
1270 | if (m_description.empty()) |
1271 | return "processor trace event"; |
1272 | else |
1273 | return m_description.c_str(); |
1274 | } |
1275 | }; |
1276 | |
1277 | // StopInfoHistoryBoundary |
1278 | |
1279 | class StopInfoHistoryBoundary : public StopInfo { |
1280 | public: |
1281 | StopInfoHistoryBoundary(Thread &thread, const char *description) |
1282 | : StopInfo(thread, LLDB_INVALID_UID) { |
1283 | if (description) |
1284 | SetDescription(description); |
1285 | } |
1286 | |
1287 | ~StopInfoHistoryBoundary() override = default; |
1288 | |
1289 | StopReason GetStopReason() const override { |
1290 | return eStopReasonHistoryBoundary; |
1291 | } |
1292 | |
1293 | const char *GetDescription() override { |
1294 | if (m_description.empty()) |
1295 | return "history boundary"; |
1296 | return m_description.c_str(); |
1297 | } |
1298 | }; |
1299 | |
1300 | // StopInfoThreadPlan |
1301 | |
1302 | class StopInfoThreadPlan : public StopInfo { |
1303 | public: |
1304 | StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, |
1305 | ExpressionVariableSP &expression_variable_sp) |
1306 | : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp), |
1307 | m_return_valobj_sp(return_valobj_sp), |
1308 | m_expression_variable_sp(expression_variable_sp) {} |
1309 | |
1310 | ~StopInfoThreadPlan() override = default; |
1311 | |
1312 | StopReason GetStopReason() const override { return eStopReasonPlanComplete; } |
1313 | |
1314 | const char *GetDescription() override { |
1315 | if (m_description.empty()) { |
1316 | StreamString strm; |
1317 | m_plan_sp->GetDescription(s: &strm, level: eDescriptionLevelBrief); |
1318 | m_description = std::string(strm.GetString()); |
1319 | } |
1320 | return m_description.c_str(); |
1321 | } |
1322 | |
1323 | ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; } |
1324 | |
1325 | ExpressionVariableSP GetExpressionVariable() { |
1326 | return m_expression_variable_sp; |
1327 | } |
1328 | |
1329 | protected: |
1330 | bool ShouldStop(Event *event_ptr) override { |
1331 | if (m_plan_sp) |
1332 | return m_plan_sp->ShouldStop(event_ptr); |
1333 | else |
1334 | return StopInfo::ShouldStop(event_ptr); |
1335 | } |
1336 | |
1337 | private: |
1338 | ThreadPlanSP m_plan_sp; |
1339 | ValueObjectSP m_return_valobj_sp; |
1340 | ExpressionVariableSP m_expression_variable_sp; |
1341 | }; |
1342 | |
1343 | // StopInfoExec |
1344 | |
1345 | class StopInfoExec : public StopInfo { |
1346 | public: |
1347 | StopInfoExec(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {} |
1348 | |
1349 | ~StopInfoExec() override = default; |
1350 | |
1351 | bool ShouldStop(Event *event_ptr) override { |
1352 | ThreadSP thread_sp(m_thread_wp.lock()); |
1353 | if (thread_sp) |
1354 | return thread_sp->GetProcess()->GetStopOnExec(); |
1355 | return false; |
1356 | } |
1357 | |
1358 | StopReason GetStopReason() const override { return eStopReasonExec; } |
1359 | |
1360 | const char *GetDescription() override { return "exec"; } |
1361 | |
1362 | protected: |
1363 | void PerformAction(Event *event_ptr) override { |
1364 | // Only perform the action once |
1365 | if (m_performed_action) |
1366 | return; |
1367 | m_performed_action = true; |
1368 | ThreadSP thread_sp(m_thread_wp.lock()); |
1369 | if (thread_sp) |
1370 | thread_sp->GetProcess()->DidExec(); |
1371 | } |
1372 | |
1373 | bool m_performed_action = false; |
1374 | }; |
1375 | |
1376 | // StopInfoFork |
1377 | |
1378 | class StopInfoFork : public StopInfo { |
1379 | public: |
1380 | StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid) |
1381 | : StopInfo(thread, child_pid), m_child_pid(child_pid), |
1382 | m_child_tid(child_tid) {} |
1383 | |
1384 | ~StopInfoFork() override = default; |
1385 | |
1386 | bool ShouldStop(Event *event_ptr) override { return false; } |
1387 | |
1388 | StopReason GetStopReason() const override { return eStopReasonFork; } |
1389 | |
1390 | const char *GetDescription() override { return "fork"; } |
1391 | |
1392 | protected: |
1393 | void PerformAction(Event *event_ptr) override { |
1394 | // Only perform the action once |
1395 | if (m_performed_action) |
1396 | return; |
1397 | m_performed_action = true; |
1398 | ThreadSP thread_sp(m_thread_wp.lock()); |
1399 | if (thread_sp) |
1400 | thread_sp->GetProcess()->DidFork(child_pid: m_child_pid, child_tid: m_child_tid); |
1401 | } |
1402 | |
1403 | bool m_performed_action = false; |
1404 | |
1405 | private: |
1406 | lldb::pid_t m_child_pid; |
1407 | lldb::tid_t m_child_tid; |
1408 | }; |
1409 | |
1410 | // StopInfoVFork |
1411 | |
1412 | class StopInfoVFork : public StopInfo { |
1413 | public: |
1414 | StopInfoVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid) |
1415 | : StopInfo(thread, child_pid), m_child_pid(child_pid), |
1416 | m_child_tid(child_tid) {} |
1417 | |
1418 | ~StopInfoVFork() override = default; |
1419 | |
1420 | bool ShouldStop(Event *event_ptr) override { return false; } |
1421 | |
1422 | StopReason GetStopReason() const override { return eStopReasonVFork; } |
1423 | |
1424 | const char *GetDescription() override { return "vfork"; } |
1425 | |
1426 | protected: |
1427 | void PerformAction(Event *event_ptr) override { |
1428 | // Only perform the action once |
1429 | if (m_performed_action) |
1430 | return; |
1431 | m_performed_action = true; |
1432 | ThreadSP thread_sp(m_thread_wp.lock()); |
1433 | if (thread_sp) |
1434 | thread_sp->GetProcess()->DidVFork(child_pid: m_child_pid, child_tid: m_child_tid); |
1435 | } |
1436 | |
1437 | bool m_performed_action = false; |
1438 | |
1439 | private: |
1440 | lldb::pid_t m_child_pid; |
1441 | lldb::tid_t m_child_tid; |
1442 | }; |
1443 | |
1444 | // StopInfoVForkDone |
1445 | |
1446 | class StopInfoVForkDone : public StopInfo { |
1447 | public: |
1448 | StopInfoVForkDone(Thread &thread) : StopInfo(thread, 0) {} |
1449 | |
1450 | ~StopInfoVForkDone() override = default; |
1451 | |
1452 | bool ShouldStop(Event *event_ptr) override { return false; } |
1453 | |
1454 | StopReason GetStopReason() const override { return eStopReasonVForkDone; } |
1455 | |
1456 | const char *GetDescription() override { return "vforkdone"; } |
1457 | |
1458 | protected: |
1459 | void PerformAction(Event *event_ptr) override { |
1460 | // Only perform the action once |
1461 | if (m_performed_action) |
1462 | return; |
1463 | m_performed_action = true; |
1464 | ThreadSP thread_sp(m_thread_wp.lock()); |
1465 | if (thread_sp) |
1466 | thread_sp->GetProcess()->DidVForkDone(); |
1467 | } |
1468 | |
1469 | bool m_performed_action = false; |
1470 | }; |
1471 | |
1472 | } // namespace lldb_private |
1473 | |
1474 | StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread, |
1475 | break_id_t break_id) { |
1476 | thread.SetThreadHitBreakpointSite(); |
1477 | |
1478 | return StopInfoSP(new StopInfoBreakpoint(thread, break_id)); |
1479 | } |
1480 | |
1481 | StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread, |
1482 | break_id_t break_id, |
1483 | bool should_stop) { |
1484 | return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop)); |
1485 | } |
1486 | |
1487 | // LWP_TODO: We'll need a CreateStopReasonWithWatchpointResourceID akin |
1488 | // to CreateStopReasonWithBreakpointSiteID |
1489 | StopInfoSP StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, |
1490 | break_id_t watch_id, |
1491 | bool silently_continue) { |
1492 | return StopInfoSP( |
1493 | new StopInfoWatchpoint(thread, watch_id, silently_continue)); |
1494 | } |
1495 | |
1496 | StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo, |
1497 | const char *description, |
1498 | std::optional<int> code) { |
1499 | thread.GetProcess()->GetUnixSignals()->IncrementSignalHitCount(signo); |
1500 | return StopInfoSP(new StopInfoUnixSignal(thread, signo, description, code)); |
1501 | } |
1502 | |
1503 | StopInfoSP StopInfo::CreateStopReasonWithInterrupt(Thread &thread, int signo, |
1504 | const char *description) { |
1505 | return StopInfoSP(new StopInfoInterrupt(thread, signo, description)); |
1506 | } |
1507 | |
1508 | StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) { |
1509 | return StopInfoSP(new StopInfoTrace(thread)); |
1510 | } |
1511 | |
1512 | StopInfoSP StopInfo::CreateStopReasonWithPlan( |
1513 | ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp, |
1514 | ExpressionVariableSP expression_variable_sp) { |
1515 | return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp, |
1516 | expression_variable_sp)); |
1517 | } |
1518 | |
1519 | StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread, |
1520 | const char *description) { |
1521 | return StopInfoSP(new StopInfoException(thread, description)); |
1522 | } |
1523 | |
1524 | StopInfoSP StopInfo::CreateStopReasonProcessorTrace(Thread &thread, |
1525 | const char *description) { |
1526 | return StopInfoSP(new StopInfoProcessorTrace(thread, description)); |
1527 | } |
1528 | |
1529 | StopInfoSP StopInfo::CreateStopReasonHistoryBoundary(Thread &thread, |
1530 | const char *description) { |
1531 | return StopInfoSP(new StopInfoHistoryBoundary(thread, description)); |
1532 | } |
1533 | |
1534 | StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) { |
1535 | return StopInfoSP(new StopInfoExec(thread)); |
1536 | } |
1537 | |
1538 | StopInfoSP StopInfo::CreateStopReasonFork(Thread &thread, |
1539 | lldb::pid_t child_pid, |
1540 | lldb::tid_t child_tid) { |
1541 | return StopInfoSP(new StopInfoFork(thread, child_pid, child_tid)); |
1542 | } |
1543 | |
1544 | |
1545 | StopInfoSP StopInfo::CreateStopReasonVFork(Thread &thread, |
1546 | lldb::pid_t child_pid, |
1547 | lldb::tid_t child_tid) { |
1548 | return StopInfoSP(new StopInfoVFork(thread, child_pid, child_tid)); |
1549 | } |
1550 | |
1551 | StopInfoSP StopInfo::CreateStopReasonVForkDone(Thread &thread) { |
1552 | return StopInfoSP(new StopInfoVForkDone(thread)); |
1553 | } |
1554 | |
1555 | ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) { |
1556 | if (stop_info_sp && |
1557 | stop_info_sp->GetStopReason() == eStopReasonPlanComplete) { |
1558 | StopInfoThreadPlan *plan_stop_info = |
1559 | static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); |
1560 | return plan_stop_info->GetReturnValueObject(); |
1561 | } else |
1562 | return ValueObjectSP(); |
1563 | } |
1564 | |
1565 | ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) { |
1566 | if (stop_info_sp && |
1567 | stop_info_sp->GetStopReason() == eStopReasonPlanComplete) { |
1568 | StopInfoThreadPlan *plan_stop_info = |
1569 | static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); |
1570 | return plan_stop_info->GetExpressionVariable(); |
1571 | } else |
1572 | return ExpressionVariableSP(); |
1573 | } |
1574 | |
1575 | lldb::ValueObjectSP |
1576 | StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp, |
1577 | lldb::addr_t *crashing_address) { |
1578 | if (!stop_info_sp) { |
1579 | return ValueObjectSP(); |
1580 | } |
1581 | |
1582 | const char *description = stop_info_sp->GetDescription(); |
1583 | if (!description) { |
1584 | return ValueObjectSP(); |
1585 | } |
1586 | |
1587 | ThreadSP thread_sp = stop_info_sp->GetThread(); |
1588 | if (!thread_sp) { |
1589 | return ValueObjectSP(); |
1590 | } |
1591 | |
1592 | StackFrameSP frame_sp = |
1593 | thread_sp->GetSelectedFrame(select_most_relevant: DoNoSelectMostRelevantFrame); |
1594 | |
1595 | if (!frame_sp) { |
1596 | return ValueObjectSP(); |
1597 | } |
1598 | |
1599 | const char address_string[] = "address="; |
1600 | |
1601 | const char *address_loc = strstr(haystack: description, needle: address_string); |
1602 | if (!address_loc) { |
1603 | return ValueObjectSP(); |
1604 | } |
1605 | |
1606 | address_loc += (sizeof(address_string) - 1); |
1607 | |
1608 | uint64_t address = strtoull(nptr: address_loc, endptr: nullptr, base: 0); |
1609 | if (crashing_address) { |
1610 | *crashing_address = address; |
1611 | } |
1612 | |
1613 | return frame_sp->GuessValueForAddress(addr: address); |
1614 | } |
1615 |
Definitions
- StopInfo
- IsValid
- MakeStopInfoValid
- HasTargetRunSinceMe
- StopInfoBreakpoint
- StopInfoBreakpoint
- StopInfoBreakpoint
- ~StopInfoBreakpoint
- StoreBPInfo
- IsValidForOperatingSystemThread
- GetStopReason
- ShouldStopSynchronous
- DoShouldNotify
- GetDescription
- GetSuggestedStackFrameIndex
- ShouldShow
- ShouldSelect
- ShouldStop
- PerformAction
- StopInfoWatchpoint
- WatchpointSentry
- WatchpointSentry
- DoReenable
- ~WatchpointSentry
- SentryPreResumeAction
- StopInfoWatchpoint
- ~StopInfoWatchpoint
- GetStopReason
- GetDescription
- ThreadPlanStepOverWatchpoint
- ThreadPlanStepOverWatchpoint
- DoWillResume
- DoPlanExplainsStop
- DidPop
- ShouldStop
- ShouldRunBeforePublicStop
- ResetWatchpoint
- ShouldStopSynchronous
- ShouldStop
- PerformAction
- SetStepOverPlanComplete
- StopInfoUnixSignal
- StopInfoUnixSignal
- ~StopInfoUnixSignal
- GetStopReason
- ShouldStopSynchronous
- ShouldStop
- DoShouldNotify
- WillResume
- GetDescription
- ShouldSelect
- IsShouldStopSignal
- StopInfoInterrupt
- StopInfoInterrupt
- ~StopInfoInterrupt
- GetStopReason
- GetDescription
- StopInfoTrace
- StopInfoTrace
- ~StopInfoTrace
- GetStopReason
- GetDescription
- GetSuggestedStackFrameIndex
- StopInfoException
- StopInfoException
- ~StopInfoException
- GetStopReason
- GetDescription
- StopInfoProcessorTrace
- StopInfoProcessorTrace
- ~StopInfoProcessorTrace
- GetStopReason
- GetDescription
- StopInfoHistoryBoundary
- StopInfoHistoryBoundary
- ~StopInfoHistoryBoundary
- GetStopReason
- GetDescription
- StopInfoThreadPlan
- StopInfoThreadPlan
- ~StopInfoThreadPlan
- GetStopReason
- GetDescription
- GetReturnValueObject
- GetExpressionVariable
- ShouldStop
- StopInfoExec
- StopInfoExec
- ~StopInfoExec
- ShouldStop
- GetStopReason
- GetDescription
- PerformAction
- StopInfoFork
- StopInfoFork
- ~StopInfoFork
- ShouldStop
- GetStopReason
- GetDescription
- PerformAction
- StopInfoVFork
- StopInfoVFork
- ~StopInfoVFork
- ShouldStop
- GetStopReason
- GetDescription
- PerformAction
- StopInfoVForkDone
- StopInfoVForkDone
- ~StopInfoVForkDone
- ShouldStop
- GetStopReason
- GetDescription
- PerformAction
- CreateStopReasonWithBreakpointSiteID
- CreateStopReasonWithBreakpointSiteID
- CreateStopReasonWithWatchpointID
- CreateStopReasonWithSignal
- CreateStopReasonWithInterrupt
- CreateStopReasonToTrace
- CreateStopReasonWithPlan
- CreateStopReasonWithException
- CreateStopReasonProcessorTrace
- CreateStopReasonHistoryBoundary
- CreateStopReasonWithExec
- CreateStopReasonFork
- CreateStopReasonVFork
- CreateStopReasonVForkDone
- GetReturnValueObject
- GetExpressionVariable
Learn to use CMake with our Intro Training
Find out more