LLDB mainline
SBBreakpointName.cpp
Go to the documentation of this file.
1//===-- SBBreakpointName.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
10#include "lldb/API/SBDebugger.h"
11#include "lldb/API/SBError.h"
12#include "lldb/API/SBStream.h"
15#include "lldb/API/SBTarget.h"
17
20#include "lldb/Core/Debugger.h"
24#include "lldb/Target/Target.h"
26#include "lldb/Utility/Stream.h"
27
29
30using namespace lldb;
31using namespace lldb_private;
32
33namespace lldb
34{
36public:
37 SBBreakpointNameImpl(TargetSP target_sp, const char *name) {
38 if (!name || name[0] == '\0')
39 return;
40 m_name.assign(name);
41
42 if (!target_sp)
43 return;
44
45 m_target_wp = target_sp;
46 }
47
48 SBBreakpointNameImpl(SBTarget &sb_target, const char *name);
49 bool operator==(const SBBreakpointNameImpl &rhs);
50 bool operator!=(const SBBreakpointNameImpl &rhs);
51
52 // For now we take a simple approach and only keep the name, and relook up
53 // the location when we need it.
54
55 TargetSP GetTarget() const {
56 return m_target_wp.lock();
57 }
58
59 const char *GetName() const {
60 return m_name.c_str();
61 }
62
63 bool IsValid() const {
64 return !m_name.empty() && m_target_wp.lock();
65 }
66
68
69private:
70 TargetWP m_target_wp;
71 std::string m_name;
72};
73
75 const char *name) {
76 if (!name || name[0] == '\0')
77 return;
78 m_name.assign(name);
79
80 if (!sb_target.IsValid())
81 return;
82
83 TargetSP target_sp = sb_target.GetSP();
84 if (!target_sp)
85 return;
86
87 m_target_wp = target_sp;
88}
89
91 return m_name == rhs.m_name && m_target_wp.lock() == rhs.m_target_wp.lock();
92}
93
95 return m_name != rhs.m_name || m_target_wp.lock() != rhs.m_target_wp.lock();
96}
97
99 if (!IsValid())
100 return nullptr;
101 TargetSP target_sp = GetTarget();
102 if (!target_sp)
103 return nullptr;
105 return target_sp->FindBreakpointName(ConstString(m_name), true, error);
106}
107
108} // namespace lldb
109
111
112SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
113 LLDB_INSTRUMENT_VA(this, sb_target, name);
114
115 m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name);
116 // Call FindBreakpointName here to make sure the name is valid, reset if not:
118 if (!bp_name)
119 m_impl_up.reset();
120}
121
123 LLDB_INSTRUMENT_VA(this, sb_bkpt, name);
124
125 if (!sb_bkpt.IsValid()) {
126 m_impl_up.reset();
127 return;
128 }
129 BreakpointSP bkpt_sp = sb_bkpt.GetSP();
130 Target &target = bkpt_sp->GetTarget();
131
132 m_impl_up =
133 std::make_unique<SBBreakpointNameImpl>(target.shared_from_this(), name);
134
135 // Call FindBreakpointName here to make sure the name is valid, reset if not:
137 if (!bp_name) {
138 m_impl_up.reset();
139 return;
140 }
141
142 // Now copy over the breakpoint's options:
143 target.ConfigureBreakpointName(*bp_name, bkpt_sp->GetOptions(),
145}
146
148 LLDB_INSTRUMENT_VA(this, rhs);
149
150 if (!rhs.m_impl_up)
151 return;
152 else
153 m_impl_up = std::make_unique<SBBreakpointNameImpl>(
154 rhs.m_impl_up->GetTarget(), rhs.m_impl_up->GetName());
155}
156
158
160operator=(const SBBreakpointName &rhs) {
161 LLDB_INSTRUMENT_VA(this, rhs);
162
163 if (!rhs.m_impl_up) {
164 m_impl_up.reset();
165 return *this;
166 }
167
168 m_impl_up = std::make_unique<SBBreakpointNameImpl>(rhs.m_impl_up->GetTarget(),
169 rhs.m_impl_up->GetName());
170 return *this;
171}
172
174 LLDB_INSTRUMENT_VA(this, rhs);
175
176 return *m_impl_up == *rhs.m_impl_up;
177}
178
180 LLDB_INSTRUMENT_VA(this, rhs);
181
182 return *m_impl_up != *rhs.m_impl_up;
183}
184
186 LLDB_INSTRUMENT_VA(this);
187 return this->operator bool();
188}
189SBBreakpointName::operator bool() const {
190 LLDB_INSTRUMENT_VA(this);
191
192 if (!m_impl_up)
193 return false;
194 return m_impl_up->IsValid();
195}
196
197const char *SBBreakpointName::GetName() const {
198 LLDB_INSTRUMENT_VA(this);
199
200 if (!m_impl_up)
201 return "<Invalid Breakpoint Name Object>";
202 return m_impl_up->GetName();
203}
204
206 LLDB_INSTRUMENT_VA(this, enable);
207
209 if (!bp_name)
210 return;
211
212 std::lock_guard<std::recursive_mutex> guard(
213 m_impl_up->GetTarget()->GetAPIMutex());
214
215 bp_name->GetOptions().SetEnabled(enable);
216}
217
219 if (!IsValid())
220 return;
221
222 TargetSP target_sp = m_impl_up->GetTarget();
223 if (!target_sp)
224 return;
225 target_sp->ApplyNameToBreakpoints(bp_name);
226
227}
228
230 LLDB_INSTRUMENT_VA(this);
231
233 if (!bp_name)
234 return false;
235
236 std::lock_guard<std::recursive_mutex> guard(
237 m_impl_up->GetTarget()->GetAPIMutex());
238
239 return bp_name->GetOptions().IsEnabled();
240}
241
242void SBBreakpointName::SetOneShot(bool one_shot) {
243 LLDB_INSTRUMENT_VA(this, one_shot);
244
246 if (!bp_name)
247 return;
248
249 std::lock_guard<std::recursive_mutex> guard(
250 m_impl_up->GetTarget()->GetAPIMutex());
251
252 bp_name->GetOptions().SetOneShot(one_shot);
253 UpdateName(*bp_name);
254}
255
257 LLDB_INSTRUMENT_VA(this);
258
259 const BreakpointName *bp_name = GetBreakpointName();
260 if (!bp_name)
261 return false;
262
263 std::lock_guard<std::recursive_mutex> guard(
264 m_impl_up->GetTarget()->GetAPIMutex());
265
266 return bp_name->GetOptions().IsOneShot();
267}
268
270 LLDB_INSTRUMENT_VA(this, count);
271
273 if (!bp_name)
274 return;
275
276 std::lock_guard<std::recursive_mutex> guard(
277 m_impl_up->GetTarget()->GetAPIMutex());
278
279 bp_name->GetOptions().SetIgnoreCount(count);
280 UpdateName(*bp_name);
281}
282
284 LLDB_INSTRUMENT_VA(this);
285
287 if (!bp_name)
288 return false;
289
290 std::lock_guard<std::recursive_mutex> guard(
291 m_impl_up->GetTarget()->GetAPIMutex());
292
293 return bp_name->GetOptions().GetIgnoreCount();
294}
295
296void SBBreakpointName::SetCondition(const char *condition) {
297 LLDB_INSTRUMENT_VA(this, condition);
298
300 if (!bp_name)
301 return;
302
303 std::lock_guard<std::recursive_mutex> guard(
304 m_impl_up->GetTarget()->GetAPIMutex());
305
306 bp_name->GetOptions().SetCondition(condition);
307 UpdateName(*bp_name);
308}
309
311 LLDB_INSTRUMENT_VA(this);
312
314 if (!bp_name)
315 return nullptr;
316
317 std::lock_guard<std::recursive_mutex> guard(
318 m_impl_up->GetTarget()->GetAPIMutex());
319
320 return bp_name->GetOptions().GetConditionText();
321}
322
323void SBBreakpointName::SetAutoContinue(bool auto_continue) {
324 LLDB_INSTRUMENT_VA(this, auto_continue);
325
327 if (!bp_name)
328 return;
329
330 std::lock_guard<std::recursive_mutex> guard(
331 m_impl_up->GetTarget()->GetAPIMutex());
332
333 bp_name->GetOptions().SetAutoContinue(auto_continue);
334 UpdateName(*bp_name);
335}
336
338 LLDB_INSTRUMENT_VA(this);
339
341 if (!bp_name)
342 return false;
343
344 std::lock_guard<std::recursive_mutex> guard(
345 m_impl_up->GetTarget()->GetAPIMutex());
346
347 return bp_name->GetOptions().IsAutoContinue();
348}
349
351 LLDB_INSTRUMENT_VA(this, tid);
352
354 if (!bp_name)
355 return;
356
357 std::lock_guard<std::recursive_mutex> guard(
358 m_impl_up->GetTarget()->GetAPIMutex());
359
360 bp_name->GetOptions().SetThreadID(tid);
361 UpdateName(*bp_name);
362}
363
365 LLDB_INSTRUMENT_VA(this);
366
368 if (!bp_name)
370
371 std::lock_guard<std::recursive_mutex> guard(
372 m_impl_up->GetTarget()->GetAPIMutex());
373
374 return bp_name->GetOptions().GetThreadSpec()->GetTID();
375}
376
378 LLDB_INSTRUMENT_VA(this, index);
379
381 if (!bp_name)
382 return;
383
384 std::lock_guard<std::recursive_mutex> guard(
385 m_impl_up->GetTarget()->GetAPIMutex());
386
387 bp_name->GetOptions().GetThreadSpec()->SetIndex(index);
388 UpdateName(*bp_name);
389}
390
392 LLDB_INSTRUMENT_VA(this);
393
395 if (!bp_name)
397
398 std::lock_guard<std::recursive_mutex> guard(
399 m_impl_up->GetTarget()->GetAPIMutex());
400
401 return bp_name->GetOptions().GetThreadSpec()->GetIndex();
402}
403
404void SBBreakpointName::SetThreadName(const char *thread_name) {
405 LLDB_INSTRUMENT_VA(this, thread_name);
406
408 if (!bp_name)
409 return;
410
411 std::lock_guard<std::recursive_mutex> guard(
412 m_impl_up->GetTarget()->GetAPIMutex());
413
414 bp_name->GetOptions().GetThreadSpec()->SetName(thread_name);
415 UpdateName(*bp_name);
416}
417
419 LLDB_INSTRUMENT_VA(this);
420
422 if (!bp_name)
423 return nullptr;
424
425 std::lock_guard<std::recursive_mutex> guard(
426 m_impl_up->GetTarget()->GetAPIMutex());
427
428 return bp_name->GetOptions().GetThreadSpec()->GetName();
429}
430
431void SBBreakpointName::SetQueueName(const char *queue_name) {
432 LLDB_INSTRUMENT_VA(this, queue_name);
433
435 if (!bp_name)
436 return;
437
438 std::lock_guard<std::recursive_mutex> guard(
439 m_impl_up->GetTarget()->GetAPIMutex());
440
441 bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
442 UpdateName(*bp_name);
443}
444
446 LLDB_INSTRUMENT_VA(this);
447
449 if (!bp_name)
450 return nullptr;
451
452 std::lock_guard<std::recursive_mutex> guard(
453 m_impl_up->GetTarget()->GetAPIMutex());
454
455 return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
456}
457
459 LLDB_INSTRUMENT_VA(this, commands);
460
462 if (!bp_name)
463 return;
464 if (commands.GetSize() == 0)
465 return;
466
467
468 std::lock_guard<std::recursive_mutex> guard(
469 m_impl_up->GetTarget()->GetAPIMutex());
470 std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
472
473 bp_name->GetOptions().SetCommandDataCallback(cmd_data_up);
474 UpdateName(*bp_name);
475}
476
478 LLDB_INSTRUMENT_VA(this, commands);
479
481 if (!bp_name)
482 return false;
483
484 StringList command_list;
485 bool has_commands =
486 bp_name->GetOptions().GetCommandLineCallbacks(command_list);
487 if (has_commands)
488 commands.AppendList(command_list);
489 return has_commands;
490}
491
493 LLDB_INSTRUMENT_VA(this);
494
496 if (!bp_name)
497 return "";
498
499 return bp_name->GetHelp();
500}
501
502void SBBreakpointName::SetHelpString(const char *help_string) {
503 LLDB_INSTRUMENT_VA(this, help_string);
504
506 if (!bp_name)
507 return;
508
509
510 std::lock_guard<std::recursive_mutex> guard(
511 m_impl_up->GetTarget()->GetAPIMutex());
512 bp_name->SetHelp(help_string);
513}
514
516 LLDB_INSTRUMENT_VA(this, s);
517
519 if (!bp_name)
520 {
521 s.Printf("No value");
522 return false;
523 }
524
525 std::lock_guard<std::recursive_mutex> guard(
526 m_impl_up->GetTarget()->GetAPIMutex());
528 return true;
529}
530
532 void *baton) {
533 LLDB_INSTRUMENT_VA(this, callback, baton);
534
536 if (!bp_name)
537 return;
538 std::lock_guard<std::recursive_mutex> guard(
539 m_impl_up->GetTarget()->GetAPIMutex());
540
541 BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
543 ::PrivateBreakpointHitCallback,
544 baton_sp,
545 false);
546 UpdateName(*bp_name);
547}
548
550 const char *callback_function_name) {
551 LLDB_INSTRUMENT_VA(this, callback_function_name);
552 SBStructuredData empty_args;
553 SetScriptCallbackFunction(callback_function_name, empty_args);
554}
555
557 const char *callback_function_name,
558 SBStructuredData &extra_args) {
559 LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
560 SBError sb_error;
562 if (!bp_name) {
563 sb_error.SetErrorString("unrecognized breakpoint name");
564 return sb_error;
565 }
566
567 std::lock_guard<std::recursive_mutex> guard(
568 m_impl_up->GetTarget()->GetAPIMutex());
569
570 BreakpointOptions &bp_options = bp_name->GetOptions();
572 error = m_impl_up->GetTarget()
573 ->GetDebugger()
574 .GetScriptInterpreter()
575 ->SetBreakpointCommandCallbackFunction(
576 bp_options, callback_function_name,
577 extra_args.m_impl_up->GetObjectSP());
578 sb_error.SetError(error);
579 UpdateName(*bp_name);
580 return sb_error;
581}
582
584SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
585 LLDB_INSTRUMENT_VA(this, callback_body_text);
586
587 SBError sb_error;
589 if (!bp_name)
590 return sb_error;
591
592 std::lock_guard<std::recursive_mutex> guard(
593 m_impl_up->GetTarget()->GetAPIMutex());
594
595 BreakpointOptions &bp_options = bp_name->GetOptions();
596 Status error = m_impl_up->GetTarget()
597 ->GetDebugger()
598 .GetScriptInterpreter()
599 ->SetBreakpointCommandCallback(
600 bp_options, callback_body_text, /*is_callback=*/false);
601 sb_error.SetError(error);
602 if (!sb_error.Fail())
603 UpdateName(*bp_name);
604
605 return sb_error;
606}
607
609 LLDB_INSTRUMENT_VA(this);
610
612 if (!bp_name)
613 return false;
614 return bp_name->GetPermissions().GetAllowList();
615}
616
618 LLDB_INSTRUMENT_VA(this, value);
619
621 if (!bp_name)
622 return;
623 bp_name->GetPermissions().SetAllowList(value);
624}
625
627 LLDB_INSTRUMENT_VA(this);
628
630 if (!bp_name)
631 return false;
632 return bp_name->GetPermissions().GetAllowDelete();
633}
634
636 LLDB_INSTRUMENT_VA(this, value);
637
639 if (!bp_name)
640 return;
641 bp_name->GetPermissions().SetAllowDelete(value);
642}
643
645 LLDB_INSTRUMENT_VA(this);
646
648 if (!bp_name)
649 return false;
650 return bp_name->GetPermissions().GetAllowDisable();
651}
652
654 LLDB_INSTRUMENT_VA(this, value);
655
657 if (!bp_name)
658 return;
659 bp_name->GetPermissions().SetAllowDisable(value);
660}
661
663{
664 if (!IsValid())
665 return nullptr;
666 return m_impl_up->GetBreakpointName();
667}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_INSTRUMENT_VA(...)
bool operator==(const SBBreakpointNameImpl &rhs)
bool operator!=(const SBBreakpointNameImpl &rhs)
lldb_private::BreakpointName * GetBreakpointName() const
SBBreakpointNameImpl(TargetSP target_sp, const char *name)
const char * GetName() const
void SetCommandLineCommands(lldb::SBStringList &commands)
const char * GetName() const
void SetQueueName(const char *queue_name)
const char * GetQueueName() const
void SetThreadIndex(uint32_t index)
void SetAutoContinue(bool auto_continue)
bool operator!=(const lldb::SBBreakpointName &rhs)
void SetCondition(const char *condition)
bool GetDescription(lldb::SBStream &description)
const char * GetThreadName() const
void SetThreadName(const char *thread_name)
void SetAllowDisable(bool value)
void SetEnabled(bool enable)
void SetIgnoreCount(uint32_t count)
bool operator==(const lldb::SBBreakpointName &rhs)
std::unique_ptr< SBBreakpointNameImpl > m_impl_up
void SetAllowDelete(bool value)
void SetCallback(SBBreakpointHitCallback callback, void *baton)
SBError SetScriptCallbackBody(const char *script_body_text)
void SetAllowList(bool value)
lldb_private::BreakpointName * GetBreakpointName() const
void SetOneShot(bool one_shot)
uint32_t GetIgnoreCount() const
uint32_t GetThreadIndex() const
void SetHelpString(const char *help_string)
const char * GetHelpString() const
void SetThreadID(lldb::tid_t sb_thread_id)
void UpdateName(lldb_private::BreakpointName &bp_name)
void SetScriptCallbackFunction(const char *callback_function_name)
const lldb::SBBreakpointName & operator=(const lldb::SBBreakpointName &rhs)
bool GetCommandLineCommands(lldb::SBStringList &commands)
bool IsValid() const
lldb::BreakpointSP GetSP() const
void SetErrorString(const char *err_str)
Definition: SBError.cpp:126
void SetError(uint32_t err, lldb::ErrorType type)
Definition: SBError.cpp:100
bool Fail() const
Definition: SBError.cpp:58
lldb_private::Stream * get()
Definition: SBStream.cpp:174
uint32_t GetSize() const
void AppendList(const char **strv, int strc)
StructuredDataImplUP m_impl_up
bool IsValid() const
Definition: SBTarget.cpp:152
lldb::TargetSP GetSP() const
Definition: SBTarget.cpp:577
bool GetDescription(Stream *s, lldb::DescriptionLevel level)
void SetHelp(const char *description)
BreakpointOptions & GetOptions()
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
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.
bool GetCommandLineCallbacks(StringList &command_list)
Returns the command line commands for the callback on this breakpoint.
bool IsOneShot() const
Check the One-shot state.
bool IsEnabled() const
Check the Enable/Disable state.
uint32_t GetIgnoreCount() const
Return the current Ignore Count.
bool IsAutoContinue() const
Check the auto-continue state.
ThreadSpec * GetThreadSpec()
Returns a pointer to the ThreadSpec for this option, creating it.
void SetOneShot(bool one_shot)
If enable is true, enable the breakpoint, if false disable it.
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 SetCommandDataCallback(std::unique_ptr< CommandData > &cmd_data)
Set a callback based on BreakpointOptions::CommandData.
void SetCallback(BreakpointHitCallback callback, const lldb::BatonSP &baton_sp, bool synchronous=false)
Adds a callback to the breakpoint option set.
A uniqued constant string class.
Definition: ConstString.h:39
An error handling class.
Definition: Status.h:44
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
Definition: Target.cpp:758
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
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
@ eScriptLanguageNone
@ eDescriptionLevelFull
bool(* SBBreakpointHitCallback)(void *baton, SBProcess &process, SBThread &thread, lldb::SBBreakpointLocation &location)
Definition: SBDefines.h:110
uint64_t tid_t
Definition: lldb-types.h:86