LLDB mainline
BreakpointLocation.cpp
Go to the documentation of this file.
1//===-- BreakpointLocation.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
12#include "lldb/Core/Debugger.h"
13#include "lldb/Core/Module.h"
19#include "lldb/Symbol/Symbol.h"
21#include "lldb/Target/Process.h"
22#include "lldb/Target/Target.h"
23#include "lldb/Target/Thread.h"
26#include "lldb/Utility/Log.h"
28
29using namespace lldb;
30using namespace lldb_private;
31
33 const Address &addr, lldb::tid_t tid,
34 bool hardware, bool check_for_resolver)
35 : m_should_resolve_indirect_functions(false), m_is_reexported(false),
36 m_is_indirect(false), m_address(addr), m_owner(owner),
37 m_condition_hash(0), m_loc_id(loc_id), m_hit_counter() {
38 if (check_for_resolver) {
39 Symbol *symbol = m_address.CalculateSymbolContextSymbol();
40 if (symbol && symbol->IsIndirect()) {
41 SetShouldResolveIndirectFunctions(true);
42 }
43 }
44
45 SetThreadIDInternal(tid);
46}
47
49
52}
53
56 if (m_options_up && m_options_up->IsOptionSet(kind))
57 return *m_options_up;
58 else
59 return m_owner.GetOptions();
60}
61
63
65
67
69 if (!m_owner.IsEnabled())
70 return false;
71 else if (m_options_up != nullptr)
72 return m_options_up->IsEnabled();
73 else
74 return true;
75}
76
79 if (enabled) {
81 } else {
83 }
84 SendBreakpointLocationChangedEvent(enabled ? eBreakpointEventTypeEnabled
85 : eBreakpointEventTypeDisabled);
86}
87
89 if (m_options_up &&
91 return m_options_up->IsAutoContinue();
92 else
93 return m_owner.IsAutoContinue();
94}
95
96void BreakpointLocation::SetAutoContinue(bool auto_continue) {
97 GetLocationOptions().SetAutoContinue(auto_continue);
98 SendBreakpointLocationChangedEvent(eBreakpointEventTypeAutoContinueChanged);
99}
100
102 SetThreadIDInternal(thread_id);
103 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
104}
105
107 const ThreadSpec *thread_spec =
110 if (thread_spec)
111 return thread_spec->GetTID();
112 else
114}
115
117 if (index != 0)
119 else {
120 // If we're resetting this to an invalid thread id, then don't make an
121 // options pointer just to do that.
122 if (m_options_up != nullptr)
123 m_options_up->GetThreadSpec()->SetIndex(index);
124 }
125 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
126}
127
129 const ThreadSpec *thread_spec =
132 if (thread_spec)
133 return thread_spec->GetIndex();
134 else
135 return 0;
136}
137
138void BreakpointLocation::SetThreadName(const char *thread_name) {
139 if (thread_name != nullptr)
140 GetLocationOptions().GetThreadSpec()->SetName(thread_name);
141 else {
142 // If we're resetting this to an invalid thread id, then don't make an
143 // options pointer just to do that.
144 if (m_options_up != nullptr)
145 m_options_up->GetThreadSpec()->SetName(thread_name);
146 }
147 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
148}
149
151 const ThreadSpec *thread_spec =
154 if (thread_spec)
155 return thread_spec->GetName();
156 else
157 return nullptr;
158}
159
160void BreakpointLocation::SetQueueName(const char *queue_name) {
161 if (queue_name != nullptr)
163 else {
164 // If we're resetting this to an invalid thread id, then don't make an
165 // options pointer just to do that.
166 if (m_options_up != nullptr)
167 m_options_up->GetThreadSpec()->SetQueueName(queue_name);
168 }
169 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
170}
171
173 const ThreadSpec *thread_spec =
176 if (thread_spec)
177 return thread_spec->GetQueueName();
178 else
179 return nullptr;
180}
181
183 if (m_options_up != nullptr && m_options_up->HasCallback())
184 return m_options_up->InvokeCallback(context, m_owner.GetID(), GetID());
185 else
186 return m_owner.InvokeCallback(context, GetID());
187}
188
190 if (m_options_up != nullptr && m_options_up->HasCallback())
191 return m_options_up->IsCallbackSynchronous();
192 else
194}
195
197 void *baton, bool is_synchronous) {
198 // The default "Baton" class will keep a copy of "baton" and won't free or
199 // delete it when it goes out of scope.
201 callback, std::make_shared<UntypedBaton>(baton), is_synchronous);
202 SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged);
203}
204
206 const BatonSP &baton_sp,
207 bool is_synchronous) {
208 GetLocationOptions().SetCallback(callback, baton_sp, is_synchronous);
209 SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged);
210}
211
214}
215
216void BreakpointLocation::SetCondition(const char *condition) {
217 GetLocationOptions().SetCondition(condition);
218 SendBreakpointLocationChangedEvent(eBreakpointEventTypeConditionChanged);
219}
220
221const char *BreakpointLocation::GetConditionText(size_t *hash) const {
223 .GetConditionText(hash);
224}
225
227 Status &error) {
229
230 std::lock_guard<std::mutex> guard(m_condition_mutex);
231
232 size_t condition_hash;
233 const char *condition_text = GetConditionText(&condition_hash);
234
235 if (!condition_text) {
236 m_user_expression_sp.reset();
237 return false;
238 }
239
240 error.Clear();
241
242 DiagnosticManager diagnostics;
243
244 if (condition_hash != m_condition_hash || !m_user_expression_sp ||
245 !m_user_expression_sp->IsParseCacheable() ||
246 !m_user_expression_sp->MatchesContext(exe_ctx)) {
248 // See if we can figure out the language from the frame, otherwise use the
249 // default language:
251 if (comp_unit)
252 language = comp_unit->GetLanguage();
253
254 m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage(
255 condition_text, llvm::StringRef(), language, Expression::eResultTypeAny,
256 EvaluateExpressionOptions(), nullptr, error));
257 if (error.Fail()) {
258 LLDB_LOGF(log, "Error getting condition expression: %s.",
259 error.AsCString());
260 m_user_expression_sp.reset();
261 return true;
262 }
263
264 if (!m_user_expression_sp->Parse(diagnostics, exe_ctx,
266 false)) {
267 error.SetErrorStringWithFormat(
268 "Couldn't parse conditional expression:\n%s",
269 diagnostics.GetString().c_str());
270 m_user_expression_sp.reset();
271 return true;
272 }
273
274 m_condition_hash = condition_hash;
275 }
276
277 // We need to make sure the user sees any parse errors in their condition, so
278 // we'll hook the constructor errors up to the debugger's Async I/O.
279
280 ValueObjectSP result_value_sp;
281
283 options.SetUnwindOnError(true);
284 options.SetIgnoreBreakpoints(true);
285 options.SetTryAllThreads(true);
287 true); // Don't generate a user variable for condition expressions.
288
289 Status expr_error;
290
291 diagnostics.Clear();
292
293 ExpressionVariableSP result_variable_sp;
294
295 ExpressionResults result_code = m_user_expression_sp->Execute(
296 diagnostics, exe_ctx, options, m_user_expression_sp, result_variable_sp);
297
298 bool ret;
299
300 if (result_code == eExpressionCompleted) {
301 if (!result_variable_sp) {
302 error.SetErrorString("Expression did not return a result");
303 return false;
304 }
305
306 result_value_sp = result_variable_sp->GetValueObject();
307
308 if (result_value_sp) {
309 ret = result_value_sp->IsLogicalTrue(error);
310 if (log) {
311 if (error.Success()) {
312 LLDB_LOGF(log, "Condition successfully evaluated, result is %s.\n",
313 ret ? "true" : "false");
314 } else {
315 error.SetErrorString(
316 "Failed to get an integer result from the expression");
317 ret = false;
318 }
319 }
320 } else {
321 ret = false;
322 error.SetErrorString("Failed to get any result from the expression");
323 }
324 } else {
325 ret = false;
326 error.SetErrorStringWithFormat("Couldn't execute expression:\n%s",
327 diagnostics.GetString().c_str());
328 }
329
330 return ret;
331}
332
336}
337
340 SendBreakpointLocationChangedEvent(eBreakpointEventTypeIgnoreChanged);
341}
342
344 if (m_options_up != nullptr) {
345 uint32_t loc_ignore = m_options_up->GetIgnoreCount();
346 if (loc_ignore != 0)
347 m_options_up->SetIgnoreCount(loc_ignore - 1);
348 }
349}
350
352 uint32_t owner_ignore = GetBreakpoint().GetIgnoreCount();
353 uint32_t loc_ignore = 0;
354 if (m_options_up != nullptr)
355 loc_ignore = m_options_up->GetIgnoreCount();
356
357 if (loc_ignore != 0 || owner_ignore != 0) {
359 DecrementIgnoreCount(); // Have to decrement our owners' ignore count,
360 // since it won't get a chance to.
361 return false;
362 }
363 return true;
364}
365
367 // If we make the copy we don't copy the callbacks because that is
368 // potentially expensive and we don't want to do that for the simple case
369 // where someone is just disabling the location.
370 if (m_options_up == nullptr)
371 m_options_up = std::make_unique<BreakpointOptions>(false);
372
373 return *m_options_up;
374}
375
377 return thread.MatchesSpec(
379 .GetThreadSpecNoCreate());
380}
381
382// RETURNS - true if we should stop at this breakpoint, false if we
383// should continue. Note, we don't check the thread spec for the breakpoint
384// here, since if the breakpoint is not for this thread, then the event won't
385// even get reported, so the check is redundant.
386
388 bool should_stop = true;
390
391 // Do this first, if a location is disabled, it shouldn't increment its hit
392 // count.
393 if (!IsEnabled())
394 return false;
395
396 // We only run synchronous callbacks in ShouldStop:
397 context->is_synchronous = true;
398 should_stop = InvokeCallback(context);
399
400 if (log) {
401 StreamString s;
403 LLDB_LOGF(log, "Hit breakpoint location: %s, %s.\n", s.GetData(),
404 should_stop ? "stopping" : "continuing");
405 }
406
407 return should_stop;
408}
409
411 if (IsEnabled()) {
412 // Step our hit count, and also step the hit count of the owner.
415 }
416}
417
419 if (IsEnabled()) {
420 // Step our hit count, and also step the hit count of the owner.
423 }
424}
425
427 return m_bp_site_sp.get() != nullptr;
428}
429
431 return m_bp_site_sp;
432}
433
435 if (m_bp_site_sp)
436 return true;
437
438 Process *process = m_owner.GetTarget().GetProcessSP().get();
439 if (process == nullptr)
440 return false;
441
442 lldb::break_id_t new_id =
443 process->CreateBreakpointSite(shared_from_this(), m_owner.IsHardware());
444
445 if (new_id == LLDB_INVALID_BREAK_ID) {
447 if (log)
448 log->Warning("Failed to add breakpoint site at 0x%" PRIx64,
450 }
451
452 return IsResolved();
453}
454
456 m_bp_site_sp = bp_site_sp;
457 SendBreakpointLocationChangedEvent(eBreakpointEventTypeLocationsResolved);
458 return true;
459}
460
462 if (m_bp_site_sp.get()) {
463 ProcessSP process_sp(m_owner.GetTarget().GetProcessSP());
464 // If the process exists, get it to remove the owner, it will remove the
465 // physical implementation of the breakpoint as well if there are no more
466 // owners. Otherwise just remove this owner.
467 if (process_sp)
468 process_sp->RemoveConstituentFromBreakpointSite(GetBreakpoint().GetID(),
470 else
471 m_bp_site_sp->RemoveConstituent(GetBreakpoint().GetID(), GetID());
472
473 m_bp_site_sp.reset();
474 return true;
475 }
476 return false;
477}
478
481 SymbolContext sc;
482
483 // If the description level is "initial" then the breakpoint is printing out
484 // our initial state, and we should let it decide how it wants to print our
485 // label.
486 if (level != eDescriptionLevelInitial) {
487 s->Indent();
489 }
490
491 if (level == lldb::eDescriptionLevelBrief)
492 return;
493
494 if (level != eDescriptionLevelInitial)
495 s->PutCString(": ");
496
498 s->IndentMore();
499
502
503 if (level == lldb::eDescriptionLevelFull ||
504 level == eDescriptionLevelInitial) {
505 if (IsReExported())
506 s->PutCString("re-exported target = ");
507 else
508 s->PutCString("where = ");
510 false, true, false, true, true, true);
511 } else {
512 if (sc.module_sp) {
513 s->EOL();
514 s->Indent("module = ");
515 sc.module_sp->GetFileSpec().Dump(s->AsRawOstream());
516 }
517
518 if (sc.comp_unit != nullptr) {
519 s->EOL();
520 s->Indent("compile unit = ");
522
523 if (sc.function != nullptr) {
524 s->EOL();
525 s->Indent("function = ");
526 s->PutCString(sc.function->GetName().AsCString("<unknown>"));
527 if (ConstString mangled_name =
529 s->EOL();
530 s->Indent("mangled function = ");
531 s->PutCString(mangled_name.AsCString());
532 }
533 }
534
535 if (sc.line_entry.line > 0) {
536 s->EOL();
537 s->Indent("location = ");
538 sc.line_entry.DumpStopContext(s, true);
539 }
540
541 } else {
542 // If we don't have a comp unit, see if we have a symbol we can print.
543 if (sc.symbol) {
544 s->EOL();
545 if (IsReExported())
546 s->Indent("re-exported target = ");
547 else
548 s->Indent("symbol = ");
549 s->PutCString(sc.symbol->GetName().AsCString("<unknown>"));
550 }
551 }
552 }
553 }
554
555 if (level == lldb::eDescriptionLevelVerbose) {
556 s->EOL();
557 s->Indent();
558 }
559
561 (level == eDescriptionLevelFull || level == eDescriptionLevelInitial))
562 s->Printf(", ");
563 s->Printf("address = ");
564
565 ExecutionContextScope *exe_scope = nullptr;
566 Target *target = &m_owner.GetTarget();
567 if (target)
568 exe_scope = target->GetProcessSP().get();
569 if (exe_scope == nullptr)
570 exe_scope = target;
571
572 if (level == eDescriptionLevelInitial)
575 else
578
579 if (IsIndirect() && m_bp_site_sp) {
580 Address resolved_address;
581 resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target);
582 Symbol *resolved_symbol = resolved_address.CalculateSymbolContextSymbol();
583 if (resolved_symbol) {
584 if (level == eDescriptionLevelFull || level == eDescriptionLevelInitial)
585 s->Printf(", ");
586 else if (level == lldb::eDescriptionLevelVerbose) {
587 s->EOL();
588 s->Indent();
589 }
590 s->Printf("indirect target = %s",
591 resolved_symbol->GetName().GetCString());
592 }
593 }
594
595 bool is_resolved = IsResolved();
596 bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
597
598 if (level == lldb::eDescriptionLevelVerbose) {
599 s->EOL();
600 s->Indent();
601 s->Printf("resolved = %s\n", is_resolved ? "true" : "false");
602 s->Indent();
603 s->Printf("hardware = %s\n", is_hardware ? "true" : "false");
604 s->Indent();
605 s->Printf("hit count = %-4u\n", GetHitCount());
606
607 if (m_options_up) {
608 s->Indent();
609 m_options_up->GetDescription(s, level);
610 s->EOL();
611 }
612 s->IndentLess();
613 } else if (level != eDescriptionLevelInitial) {
614 s->Printf(", %sresolved, %shit count = %u ", (is_resolved ? "" : "un"),
615 (is_hardware ? "hardware, " : ""), GetHitCount());
616 if (m_options_up) {
617 m_options_up->GetDescription(s, level);
618 }
619 }
620}
621
623 if (s == nullptr)
624 return;
625
626 bool is_resolved = IsResolved();
627 bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
628
631 ->GetTID();
632 s->Printf("BreakpointLocation %u: tid = %4.4" PRIx64
633 " load addr = 0x%8.8" PRIx64 " state = %s type = %s breakpoint "
634 "hit_count = %-4u ignore_count = %-4u",
635 GetID(), tid,
637 (m_options_up ? m_options_up->IsEnabled() : m_owner.IsEnabled())
638 ? "enabled "
639 : "disabled",
640 is_hardware ? "hardware" : "software", GetHitCount(),
642 .GetIgnoreCount());
643}
644
646 lldb::BreakpointEventType eventKind) {
649 auto data_sp = std::make_shared<Breakpoint::BreakpointEventData>(
650 eventKind, m_owner.shared_from_this());
651 data_sp->GetBreakpointLocationCollection().Add(shared_from_this());
653 data_sp);
654 }
655}
656
658 m_address = swap_from->m_address;
660 swap_from->m_should_resolve_indirect_functions;
661 m_is_reexported = swap_from->m_is_reexported;
662 m_is_indirect = swap_from->m_is_indirect;
663 m_user_expression_sp.reset();
664}
665
667 if (thread_id != LLDB_INVALID_THREAD_ID)
668 GetLocationOptions().SetThreadID(thread_id);
669 else {
670 // If we're resetting this to an invalid thread id, then don't make an
671 // options pointer just to do that.
672 if (m_options_up != nullptr)
673 m_options_up->SetThreadID(thread_id);
674 }
675}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:366
A section + offset based address class.
Definition: Address.h:62
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:1047
uint32_t CalculateSymbolContext(SymbolContext *sc, lldb::SymbolContextItem resolve_scope=lldb::eSymbolContextEverything) const
Reconstruct a symbol context from an address.
Definition: Address.cpp:832
lldb::addr_t GetOpcodeLoadAddress(Target *target, AddressClass addr_class=AddressClass::eInvalid) const
Get the load address as an opcode load address.
Definition: Address.cpp:370
@ DumpStyleFileAddress
Display as the file address (if any).
Definition: Address.h:87
@ DumpStyleModuleWithFileAddress
Display as the file address with the module name prepended (if any).
Definition: Address.h:93
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:99
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX, bool all_ranges=false, std::optional< Stream::HighlightSettings > settings=std::nullopt) const
Dump a description of this object to a Stream.
Definition: Address.cpp:408
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:342
CompileUnit * CalculateSymbolContextCompileUnit() const
Definition: Address.cpp:858
Symbol * CalculateSymbolContextSymbol() const
Definition: Address.cpp:900
static void GetCanonicalReference(Stream *s, lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
Takes a breakpoint ID and the breakpoint location id and returns a string containing the canonical de...
size_t m_condition_hash
For testing whether the condition source code changed.
void SwapLocation(lldb::BreakpointLocationSP swap_from)
bool IsIndirect()
Returns whether the address set in the breakpoint site for this location was found by resolving an in...
void SetCondition(const char *condition)
Set the breakpoint location's condition.
uint32_t GetHitCount() const
Return the current Hit Count.
std::mutex m_condition_mutex
Guards parsing and evaluation of the condition, which could be evaluated by multiple processes.
StoppointHitCounter m_hit_counter
Number of times this breakpoint location has been hit.
lldb::BreakpointSiteSP m_bp_site_sp
Our breakpoint site (it may be shared by more than one location.)
Breakpoint & m_owner
The breakpoint that produced this object.
bool SetBreakpointSite(lldb::BreakpointSiteSP &bp_site_sp)
Set the breakpoint site for this location to bp_site_sp.
void SetIgnoreCount(uint32_t n)
Set the breakpoint to ignore the next count breakpoint hits.
void SetThreadIDInternal(lldb::tid_t thread_id)
Updates the thread ID internally.
void SetQueueName(const char *queue_name)
bool IsReExported()
Returns whether the address set in the breakpoint location was re-routed to the target of a re-export...
lldb::addr_t GetLoadAddress() const
Gets the load address for this breakpoint location.
BreakpointOptions & GetLocationOptions()
Use this to set location specific breakpoint options.
bool InvokeCallback(StoppointCallbackContext *context)
Invoke the callback action when the breakpoint is hit.
bool ShouldStop(StoppointCallbackContext *context)
Determines whether we should stop due to a hit at this breakpoint location.
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Print a description of this breakpoint location to the stream s.
Address m_address
The address defining this location.
bool IsEnabled() const
Check the Enable/Disable state.
bool IgnoreCountShouldStop()
BreakpointLocation::IgnoreCountShouldStop can only be called once per stop.
bool ResolveBreakpointSite()
Try to resolve the breakpoint site for this location.
bool IsResolved() const
Return whether this breakpoint location has a breakpoint site.
lldb::break_id_t GetID() const
Returns the breakpoint location ID.
const char * GetConditionText(size_t *hash=nullptr) const
Return a pointer to the text of the condition expression.
void SetEnabled(bool enabled)
If enabled is true, enable the breakpoint, if false disable it.
void Dump(Stream *s) const
Standard "Dump" method. At present it does nothing.
bool IsCallbackSynchronous()
Report whether the callback for this location is synchronous or not.
bool ClearBreakpointSite()
Clear this breakpoint location's breakpoint site - for instance when disabling the breakpoint.
BreakpointLocation(lldb::break_id_t bid, Breakpoint &owner, const Address &addr, lldb::tid_t tid, bool hardware, bool check_for_resolver=true)
Constructor.
void SendBreakpointLocationChangedEvent(lldb::BreakpointEventType eventKind)
void SetAutoContinue(bool auto_continue)
If auto_continue is true, set the breakpoint to continue when hit.
void SetThreadID(lldb::tid_t thread_id)
Set the valid thread to be checked when the breakpoint is hit.
lldb::UserExpressionSP m_user_expression_sp
The compiled expression to use in testing our condition.
void SetCallback(BreakpointHitCallback callback, const lldb::BatonSP &callback_baton_sp, bool is_synchronous)
Set the callback action invoked when the breakpoint is hit.
uint32_t GetIgnoreCount() const
Return the current Ignore Count.
bool ConditionSaysStop(ExecutionContext &exe_ctx, Status &error)
std::unique_ptr< BreakpointOptions > m_options_up
Breakpoint options pointer, nullptr if we're using our breakpoint's options.
Address & GetAddress()
Gets the Address for this breakpoint location.
bool IsAutoContinue() const
Check the AutoContinue state.
void SetThreadName(const char *thread_name)
Breakpoint & GetBreakpoint()
Gets the Breakpoint that created this breakpoint location.
const BreakpointOptions & GetOptionsSpecifyingKind(BreakpointOptions::OptionKind kind) const
Use this to access breakpoint options from this breakpoint location.
lldb::BreakpointSiteSP GetBreakpointSite() const
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
bool IsCallbackSynchronous() const
Used in InvokeCallback to tell whether it is the right time to run this kind of callback.
void ClearCallback()
Remove the callback from this option set.
void SetIgnoreCount(uint32_t n)
Set the breakpoint to ignore the next count breakpoint hits.
void SetEnabled(bool enabled)
If enable is true, enable the breakpoint, if false disable it.
void SetCondition(const char *condition)
Set the breakpoint option's condition.
uint32_t GetIgnoreCount() const
Return the current Ignore Count.
ThreadSpec * GetThreadSpec()
Returns a pointer to the ThreadSpec for this option, creating it.
const ThreadSpec * GetThreadSpecNoCreate() const
Return the current thread spec for this option.
void SetAutoContinue(bool auto_continue)
Set the auto-continue state.
void SetThreadID(lldb::tid_t thread_id)
const char * GetConditionText(size_t *hash=nullptr) const
Return a pointer to the text of the condition expression.
void SetCallback(BreakpointHitCallback callback, const lldb::BatonSP &baton_sp, bool synchronous=false)
Adds a callback to the breakpoint option set.
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:81
bool IsAutoContinue() const
Check the AutoContinue state.
Definition: Breakpoint.cpp:330
bool InvokeCallback(StoppointCallbackContext *context, lldb::break_id_t bp_loc_id)
Invoke the callback action when the breakpoint is hit.
Definition: Breakpoint.cpp:428
StoppointHitCounter m_hit_counter
Number of times this breakpoint has been hit.
Definition: Breakpoint.h:666
uint32_t GetIgnoreCount() const
Return the current ignore count/.
Definition: Breakpoint.cpp:315
bool IsEnabled() override
Check the Enable/Disable state.
Definition: Breakpoint.cpp:299
BreakpointOptions & GetOptions()
Returns the BreakpointOptions structure set at the breakpoint level.
Definition: Breakpoint.cpp:433
bool IsHardware() const
Definition: Breakpoint.h:520
Target & GetTarget()
Accessor for the breakpoint Target.
Definition: Breakpoint.h:463
bool IsInternal() const
Tell whether this breakpoint is an "internal" breakpoint.
Definition: Breakpoint.cpp:249
bool EventTypeHasListeners(uint32_t event_type)
Definition: Broadcaster.h:251
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
Definition: Broadcaster.h:168
A class that describes a compilation unit.
Definition: CompileUnit.h:43
const FileSpec & GetPrimaryFile() const
Return the primary source spec associated with this compile unit.
Definition: CompileUnit.h:232
lldb::LanguageType GetLanguage()
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
void Dump(Stream *s, const char *value_if_empty=nullptr) const
Dump the object description to a stream.
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
std::string GetString(char separator='\n')
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:348
void SetTryAllThreads(bool try_others=true)
Definition: Target.h:381
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:352
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:240
ConstString GetName() const
Definition: Function.cpp:693
const Mangled & GetMangled() const
Definition: Function.h:528
void void void void void Warning(const char *fmt,...) __attribute__((format(printf
Definition: Log.cpp:201
ConstString & GetMangledName()
Mangled name get accessor.
Definition: Mangled.h:145
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
lldb::break_id_t CreateBreakpointSite(const lldb::BreakpointLocationSP &owner, bool use_hardware)
Definition: Process.cpp:1663
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
void Decrement(uint32_t difference=1)
void Increment(uint32_t difference=1)
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
const char * GetData() const
Definition: StreamString.h:45
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:401
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:157
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:198
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:195
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
Function * function
The Function for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
CompileUnit * comp_unit
The CompileUnit for a given query.
bool DumpStopContext(Stream *s, ExecutionContextScope *exe_scope, const Address &so_addr, bool show_fullpaths, bool show_module, bool show_inlined_frames, bool show_function_arguments, bool show_function_name, bool show_function_display_name=false, std::optional< Stream::HighlightSettings > settings=std::nullopt) const
Dump the stop context in this object to a Stream.
Symbol * symbol
The Symbol for a given query.
LineEntry line_entry
The LineEntry for a given query.
bool IsIndirect() const
Definition: Symbol.cpp:223
ConstString GetName() const
Definition: Symbol.cpp:548
Symbol * CalculateSymbolContextSymbol() override
Definition: Symbol.cpp:451
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:222
@ eBroadcastBitBreakpointChanged
Definition: Target.h:506
void SetIndex(uint32_t index)
Definition: ThreadSpec.h:45
void SetName(llvm::StringRef name)
Definition: ThreadSpec.h:49
uint32_t GetIndex() const
Definition: ThreadSpec.h:55
const char * GetName() const
Definition: ThreadSpec.cpp:68
void SetQueueName(llvm::StringRef queue_name)
Definition: ThreadSpec.h:51
const char * GetQueueName() const
Definition: ThreadSpec.cpp:72
lldb::tid_t GetTID() const
Definition: ThreadSpec.h:57
virtual bool MatchesSpec(const ThreadSpec *spec)
Definition: Thread.cpp:1066
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:90
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
std::function< bool(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)> BreakpointHitCallback
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
Definition: lldb-forward.h:321
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
Definition: lldb-forward.h:322
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelBrief
@ eDescriptionLevelInitial
@ eDescriptionLevelFull
@ eDescriptionLevelVerbose
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:480
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:349
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
ExpressionResults
The results of expression evaluation.
@ eExpressionCompleted
int32_t break_id_t
Definition: lldb-types.h:86
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:387
std::shared_ptr< lldb_private::Baton > BatonSP
Definition: lldb-forward.h:317
uint64_t addr_t
Definition: lldb-types.h:80
uint64_t tid_t
Definition: lldb-types.h:84
uint32_t line
The source line number, or LLDB_INVALID_LINE_NUMBER if there is no line number information.
Definition: LineEntry.h:147
bool DumpStopContext(Stream *s, bool show_fullpaths) const
Dumps information specific to a process that stops at this line entry to the supplied stream s.
Definition: LineEntry.cpp:39