1 //===-- SBBreakpointName.cpp ----------------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/API/SBBreakpointName.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBDebugger.h"
12 #include "lldb/API/SBError.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/API/SBStringList.h"
15 #include "lldb/API/SBTarget.h"
17 #include "lldb/Breakpoint/BreakpointName.h"
18 #include "lldb/Breakpoint/StoppointCallbackContext.h"
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/Interpreter/CommandInterpreter.h"
21 #include "lldb/Interpreter/ScriptInterpreter.h"
22 #include "lldb/Target/Target.h"
23 #include "lldb/Target/ThreadSpec.h"
24 #include "lldb/Utility/Stream.h"
26 #include "SBBreakpointOptionCommon.h"
29 using namespace lldb_private;
33 class SBBreakpointNameImpl {
35 SBBreakpointNameImpl(TargetSP target_sp, const char *name) {
36 if (!name || name[0] == '\0')
43 m_target_wp = target_sp;
46 SBBreakpointNameImpl(SBTarget &sb_target, const char *name);
47 bool operator==(const SBBreakpointNameImpl &rhs);
48 bool operator!=(const SBBreakpointNameImpl &rhs);
50 // For now we take a simple approach and only keep the name, and relook up
51 // the location when we need it.
53 TargetSP GetTarget() const {
54 return m_target_wp.lock();
57 const char *GetName() const {
58 return m_name.c_str();
61 bool IsValid() const {
62 return !m_name.empty() && m_target_wp.lock();
65 lldb_private::BreakpointName *GetBreakpointName() const;
72 SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target,
74 if (!name || name[0] == '\0')
78 if (!sb_target.IsValid())
81 TargetSP target_sp = sb_target.GetSP();
85 m_target_wp = target_sp;
88 bool SBBreakpointNameImpl::operator==(const SBBreakpointNameImpl &rhs) {
89 return m_name == rhs.m_name && m_target_wp.lock() == rhs.m_target_wp.lock();
92 bool SBBreakpointNameImpl::operator!=(const SBBreakpointNameImpl &rhs) {
93 return m_name != rhs.m_name || m_target_wp.lock() != rhs.m_target_wp.lock();
96 lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
99 TargetSP target_sp = GetTarget();
103 return target_sp->FindBreakpointName(ConstString(m_name), true, error);
108 SBBreakpointName::SBBreakpointName() {
109 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
112 SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
113 LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
116 m_impl_up.reset(new SBBreakpointNameImpl(sb_target, name));
117 // Call FindBreakpointName here to make sure the name is valid, reset if not:
118 BreakpointName *bp_name = GetBreakpointName();
123 SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
124 LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
125 (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
127 if (!sb_bkpt.IsValid()) {
131 BreakpointSP bkpt_sp = sb_bkpt.GetSP();
132 Target &target = bkpt_sp->GetTarget();
134 m_impl_up.reset(new SBBreakpointNameImpl(target.shared_from_this(), name));
136 // Call FindBreakpointName here to make sure the name is valid, reset if not:
137 BreakpointName *bp_name = GetBreakpointName();
143 // Now copy over the breakpoint's options:
144 target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(),
145 BreakpointName::Permissions());
148 SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
149 LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
155 m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
156 rhs.m_impl_up->GetName()));
159 SBBreakpointName::~SBBreakpointName() = default;
161 const SBBreakpointName &SBBreakpointName::
162 operator=(const SBBreakpointName &rhs) {
164 const lldb::SBBreakpointName &,
165 SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
167 if (!rhs.m_impl_up) {
169 return LLDB_RECORD_RESULT(*this);
172 m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
173 rhs.m_impl_up->GetName()));
174 return LLDB_RECORD_RESULT(*this);
177 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
179 bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
181 return *m_impl_up == *rhs.m_impl_up;
184 bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
186 bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
188 return *m_impl_up != *rhs.m_impl_up;
191 bool SBBreakpointName::IsValid() const {
192 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
193 return this->operator bool();
195 SBBreakpointName::operator bool() const {
196 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool);
200 return m_impl_up->IsValid();
203 const char *SBBreakpointName::GetName() const {
204 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
207 return "<Invalid Breakpoint Name Object>";
208 return m_impl_up->GetName();
211 void SBBreakpointName::SetEnabled(bool enable) {
212 LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
214 BreakpointName *bp_name = GetBreakpointName();
218 std::lock_guard<std::recursive_mutex> guard(
219 m_impl_up->GetTarget()->GetAPIMutex());
221 bp_name->GetOptions().SetEnabled(enable);
224 void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
228 TargetSP target_sp = m_impl_up->GetTarget();
231 target_sp->ApplyNameToBreakpoints(bp_name);
235 bool SBBreakpointName::IsEnabled() {
236 LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
238 BreakpointName *bp_name = GetBreakpointName();
242 std::lock_guard<std::recursive_mutex> guard(
243 m_impl_up->GetTarget()->GetAPIMutex());
245 return bp_name->GetOptions().IsEnabled();
248 void SBBreakpointName::SetOneShot(bool one_shot) {
249 LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
251 BreakpointName *bp_name = GetBreakpointName();
255 std::lock_guard<std::recursive_mutex> guard(
256 m_impl_up->GetTarget()->GetAPIMutex());
258 bp_name->GetOptions().SetOneShot(one_shot);
259 UpdateName(*bp_name);
262 bool SBBreakpointName::IsOneShot() const {
263 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
265 const BreakpointName *bp_name = GetBreakpointName();
269 std::lock_guard<std::recursive_mutex> guard(
270 m_impl_up->GetTarget()->GetAPIMutex());
272 return bp_name->GetOptions().IsOneShot();
275 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
276 LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
278 BreakpointName *bp_name = GetBreakpointName();
282 std::lock_guard<std::recursive_mutex> guard(
283 m_impl_up->GetTarget()->GetAPIMutex());
285 bp_name->GetOptions().SetIgnoreCount(count);
286 UpdateName(*bp_name);
289 uint32_t SBBreakpointName::GetIgnoreCount() const {
290 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
292 BreakpointName *bp_name = GetBreakpointName();
296 std::lock_guard<std::recursive_mutex> guard(
297 m_impl_up->GetTarget()->GetAPIMutex());
299 return bp_name->GetOptions().GetIgnoreCount();
302 void SBBreakpointName::SetCondition(const char *condition) {
303 LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
306 BreakpointName *bp_name = GetBreakpointName();
310 std::lock_guard<std::recursive_mutex> guard(
311 m_impl_up->GetTarget()->GetAPIMutex());
313 bp_name->GetOptions().SetCondition(condition);
314 UpdateName(*bp_name);
317 const char *SBBreakpointName::GetCondition() {
318 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
320 BreakpointName *bp_name = GetBreakpointName();
324 std::lock_guard<std::recursive_mutex> guard(
325 m_impl_up->GetTarget()->GetAPIMutex());
327 return bp_name->GetOptions().GetConditionText();
330 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
331 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
334 BreakpointName *bp_name = GetBreakpointName();
338 std::lock_guard<std::recursive_mutex> guard(
339 m_impl_up->GetTarget()->GetAPIMutex());
341 bp_name->GetOptions().SetAutoContinue(auto_continue);
342 UpdateName(*bp_name);
345 bool SBBreakpointName::GetAutoContinue() {
346 LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
348 BreakpointName *bp_name = GetBreakpointName();
352 std::lock_guard<std::recursive_mutex> guard(
353 m_impl_up->GetTarget()->GetAPIMutex());
355 return bp_name->GetOptions().IsAutoContinue();
358 void SBBreakpointName::SetThreadID(tid_t tid) {
359 LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
361 BreakpointName *bp_name = GetBreakpointName();
365 std::lock_guard<std::recursive_mutex> guard(
366 m_impl_up->GetTarget()->GetAPIMutex());
368 bp_name->GetOptions().SetThreadID(tid);
369 UpdateName(*bp_name);
372 tid_t SBBreakpointName::GetThreadID() {
373 LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
375 BreakpointName *bp_name = GetBreakpointName();
377 return LLDB_INVALID_THREAD_ID;
379 std::lock_guard<std::recursive_mutex> guard(
380 m_impl_up->GetTarget()->GetAPIMutex());
382 return bp_name->GetOptions().GetThreadSpec()->GetTID();
385 void SBBreakpointName::SetThreadIndex(uint32_t index) {
386 LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
388 BreakpointName *bp_name = GetBreakpointName();
392 std::lock_guard<std::recursive_mutex> guard(
393 m_impl_up->GetTarget()->GetAPIMutex());
395 bp_name->GetOptions().GetThreadSpec()->SetIndex(index);
396 UpdateName(*bp_name);
399 uint32_t SBBreakpointName::GetThreadIndex() const {
400 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
402 BreakpointName *bp_name = GetBreakpointName();
404 return LLDB_INVALID_THREAD_ID;
406 std::lock_guard<std::recursive_mutex> guard(
407 m_impl_up->GetTarget()->GetAPIMutex());
409 return bp_name->GetOptions().GetThreadSpec()->GetIndex();
412 void SBBreakpointName::SetThreadName(const char *thread_name) {
413 LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
416 BreakpointName *bp_name = GetBreakpointName();
420 std::lock_guard<std::recursive_mutex> guard(
421 m_impl_up->GetTarget()->GetAPIMutex());
423 bp_name->GetOptions().GetThreadSpec()->SetName(thread_name);
424 UpdateName(*bp_name);
427 const char *SBBreakpointName::GetThreadName() const {
428 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
431 BreakpointName *bp_name = GetBreakpointName();
435 std::lock_guard<std::recursive_mutex> guard(
436 m_impl_up->GetTarget()->GetAPIMutex());
438 return bp_name->GetOptions().GetThreadSpec()->GetName();
441 void SBBreakpointName::SetQueueName(const char *queue_name) {
442 LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
445 BreakpointName *bp_name = GetBreakpointName();
449 std::lock_guard<std::recursive_mutex> guard(
450 m_impl_up->GetTarget()->GetAPIMutex());
452 bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
453 UpdateName(*bp_name);
456 const char *SBBreakpointName::GetQueueName() const {
457 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
460 BreakpointName *bp_name = GetBreakpointName();
464 std::lock_guard<std::recursive_mutex> guard(
465 m_impl_up->GetTarget()->GetAPIMutex());
467 return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
470 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
471 LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
472 (lldb::SBStringList &), commands);
474 BreakpointName *bp_name = GetBreakpointName();
477 if (commands.GetSize() == 0)
481 std::lock_guard<std::recursive_mutex> guard(
482 m_impl_up->GetTarget()->GetAPIMutex());
483 std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
484 new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
486 bp_name->GetOptions().SetCommandDataCallback(cmd_data_up);
487 UpdateName(*bp_name);
490 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
491 LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
492 (lldb::SBStringList &), commands);
494 BreakpointName *bp_name = GetBreakpointName();
498 StringList command_list;
500 bp_name->GetOptions().GetCommandLineCallbacks(command_list);
502 commands.AppendList(command_list);
506 const char *SBBreakpointName::GetHelpString() const {
507 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
510 BreakpointName *bp_name = GetBreakpointName();
514 return bp_name->GetHelp();
517 void SBBreakpointName::SetHelpString(const char *help_string) {
518 LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
521 BreakpointName *bp_name = GetBreakpointName();
526 std::lock_guard<std::recursive_mutex> guard(
527 m_impl_up->GetTarget()->GetAPIMutex());
528 bp_name->SetHelp(help_string);
531 bool SBBreakpointName::GetDescription(SBStream &s) {
532 LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
535 BreakpointName *bp_name = GetBreakpointName();
538 s.Printf("No value");
542 std::lock_guard<std::recursive_mutex> guard(
543 m_impl_up->GetTarget()->GetAPIMutex());
544 bp_name->GetDescription(s.get(), eDescriptionLevelFull);
548 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
550 LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback,
551 (lldb::SBBreakpointHitCallback, void *), callback, baton);
553 BreakpointName *bp_name = GetBreakpointName();
556 std::lock_guard<std::recursive_mutex> guard(
557 m_impl_up->GetTarget()->GetAPIMutex());
559 BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
560 bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton
561 ::PrivateBreakpointHitCallback,
564 UpdateName(*bp_name);
567 void SBBreakpointName::SetScriptCallbackFunction(
568 const char *callback_function_name) {
569 LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
570 (const char *), callback_function_name);
572 BreakpointName *bp_name = GetBreakpointName();
576 std::lock_guard<std::recursive_mutex> guard(
577 m_impl_up->GetTarget()->GetAPIMutex());
579 BreakpointOptions &bp_options = bp_name->GetOptions();
580 m_impl_up->GetTarget()
582 .GetScriptInterpreter()
583 ->SetBreakpointCommandCallbackFunction(&bp_options,
584 callback_function_name);
585 UpdateName(*bp_name);
589 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
590 LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
591 (const char *), callback_body_text);
594 BreakpointName *bp_name = GetBreakpointName();
596 return LLDB_RECORD_RESULT(sb_error);
598 std::lock_guard<std::recursive_mutex> guard(
599 m_impl_up->GetTarget()->GetAPIMutex());
601 BreakpointOptions &bp_options = bp_name->GetOptions();
603 m_impl_up->GetTarget()
605 .GetScriptInterpreter()
606 ->SetBreakpointCommandCallback(&bp_options, callback_body_text);
607 sb_error.SetError(error);
608 if (!sb_error.Fail())
609 UpdateName(*bp_name);
611 return LLDB_RECORD_RESULT(sb_error);
614 bool SBBreakpointName::GetAllowList() const {
615 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
617 BreakpointName *bp_name = GetBreakpointName();
620 return bp_name->GetPermissions().GetAllowList();
623 void SBBreakpointName::SetAllowList(bool value) {
624 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
627 BreakpointName *bp_name = GetBreakpointName();
630 bp_name->GetPermissions().SetAllowList(value);
633 bool SBBreakpointName::GetAllowDelete() {
634 LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
636 BreakpointName *bp_name = GetBreakpointName();
639 return bp_name->GetPermissions().GetAllowDelete();
642 void SBBreakpointName::SetAllowDelete(bool value) {
643 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
646 BreakpointName *bp_name = GetBreakpointName();
649 bp_name->GetPermissions().SetAllowDelete(value);
652 bool SBBreakpointName::GetAllowDisable() {
653 LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
655 BreakpointName *bp_name = GetBreakpointName();
658 return bp_name->GetPermissions().GetAllowDisable();
661 void SBBreakpointName::SetAllowDisable(bool value) {
662 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
664 BreakpointName *bp_name = GetBreakpointName();
667 bp_name->GetPermissions().SetAllowDisable(value);
670 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
674 return m_impl_up->GetBreakpointName();
678 namespace lldb_private {
682 void RegisterMethods<SBBreakpointName>(Registry &R) {
683 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
684 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
685 (lldb::SBTarget &, const char *));
686 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
687 (lldb::SBBreakpoint &, const char *));
688 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
689 (const lldb::SBBreakpointName &));
690 LLDB_REGISTER_METHOD(
691 const lldb::SBBreakpointName &,
692 SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
693 LLDB_REGISTER_METHOD(
694 bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
695 LLDB_REGISTER_METHOD(
696 bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
697 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
698 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
699 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
700 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
701 LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
702 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
703 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
704 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
705 LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
706 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
707 LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
708 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
709 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
710 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
711 LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
712 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
713 LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
714 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
715 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
717 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
718 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
720 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
721 (lldb::SBStringList &));
722 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
723 (lldb::SBStringList &));
724 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
726 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
727 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
729 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
731 LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
733 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
734 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
735 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
736 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
737 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
738 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));