1 //===-- SBBreakpointName.cpp ----------------------------------------*- C++ -*-===//
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 "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"
16 
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"
25 
26 #include "SBBreakpointOptionCommon.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 namespace lldb
32 {
33 class SBBreakpointNameImpl {
34 public:
35   SBBreakpointNameImpl(TargetSP target_sp, const char *name) {
36     if (!name || name[0] == '\0')
37       return;
38     m_name.assign(name);
39 
40     if (!target_sp)
41       return;
42 
43     m_target_wp = target_sp;
44   }
45 
46   SBBreakpointNameImpl(SBTarget &sb_target, const char *name);
47   bool operator==(const SBBreakpointNameImpl &rhs);
48   bool operator!=(const SBBreakpointNameImpl &rhs);
49 
50   // For now we take a simple approach and only keep the name, and relook up
51   // the location when we need it.
52 
53   TargetSP GetTarget() const {
54     return m_target_wp.lock();
55   }
56 
57   const char *GetName() const {
58     return m_name.c_str();
59   }
60 
61   bool IsValid() const {
62     return !m_name.empty() && m_target_wp.lock();
63   }
64 
65   lldb_private::BreakpointName *GetBreakpointName() const;
66 
67 private:
68   TargetWP m_target_wp;
69   std::string m_name;
70 };
71 
72 SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target,
73                                            const char *name) {
74   if (!name || name[0] == '\0')
75     return;
76   m_name.assign(name);
77 
78   if (!sb_target.IsValid())
79     return;
80 
81   TargetSP target_sp = sb_target.GetSP();
82   if (!target_sp)
83     return;
84 
85   m_target_wp = target_sp;
86 }
87 
88 bool SBBreakpointNameImpl::operator==(const SBBreakpointNameImpl &rhs) {
89   return m_name == rhs.m_name && m_target_wp.lock() == rhs.m_target_wp.lock();
90 }
91 
92 bool SBBreakpointNameImpl::operator!=(const SBBreakpointNameImpl &rhs) {
93   return m_name != rhs.m_name || m_target_wp.lock() != rhs.m_target_wp.lock();
94 }
95 
96 lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
97   if (!IsValid())
98     return nullptr;
99   TargetSP target_sp = GetTarget();
100   if (!target_sp)
101     return nullptr;
102   Status error;
103   return target_sp->FindBreakpointName(ConstString(m_name), true, error);
104 }
105 
106 } // namespace lldb
107 
108 SBBreakpointName::SBBreakpointName() {
109   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
110 }
111 
112 SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
113   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
114                           sb_target, name);
115 
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();
119   if (!bp_name)
120     m_impl_up.reset();
121 }
122 
123 SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
124   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
125                           (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
126 
127   if (!sb_bkpt.IsValid()) {
128     m_impl_up.reset();
129     return;
130   }
131   BreakpointSP bkpt_sp = sb_bkpt.GetSP();
132   Target &target = bkpt_sp->GetTarget();
133 
134   m_impl_up.reset(new SBBreakpointNameImpl(target.shared_from_this(), name));
135 
136   // Call FindBreakpointName here to make sure the name is valid, reset if not:
137   BreakpointName *bp_name = GetBreakpointName();
138   if (!bp_name) {
139     m_impl_up.reset();
140     return;
141   }
142 
143   // Now copy over the breakpoint's options:
144   target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(),
145                                  BreakpointName::Permissions());
146 }
147 
148 SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
149   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
150                           rhs);
151 
152   if (!rhs.m_impl_up)
153     return;
154   else
155     m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
156                                              rhs.m_impl_up->GetName()));
157 }
158 
159 SBBreakpointName::~SBBreakpointName() = default;
160 
161 const SBBreakpointName &SBBreakpointName::
162 operator=(const SBBreakpointName &rhs) {
163   LLDB_RECORD_METHOD(
164       const lldb::SBBreakpointName &,
165       SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
166 
167   if (!rhs.m_impl_up) {
168     m_impl_up.reset();
169     return *this;
170   }
171 
172   m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
173                                            rhs.m_impl_up->GetName()));
174   return *this;
175 }
176 
177 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
178   LLDB_RECORD_METHOD(
179       bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
180 
181   return *m_impl_up == *rhs.m_impl_up;
182 }
183 
184 bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
185   LLDB_RECORD_METHOD(
186       bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
187 
188   return *m_impl_up != *rhs.m_impl_up;
189 }
190 
191 bool SBBreakpointName::IsValid() const {
192   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
193 
194   if (!m_impl_up)
195     return false;
196   return m_impl_up->IsValid();
197 }
198 
199 const char *SBBreakpointName::GetName() const {
200   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
201 
202   if (!m_impl_up)
203     return "<Invalid Breakpoint Name Object>";
204   return m_impl_up->GetName();
205 }
206 
207 void SBBreakpointName::SetEnabled(bool enable) {
208   LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
209 
210   BreakpointName *bp_name = GetBreakpointName();
211   if (!bp_name)
212     return;
213 
214   std::lock_guard<std::recursive_mutex> guard(
215         m_impl_up->GetTarget()->GetAPIMutex());
216 
217   bp_name->GetOptions().SetEnabled(enable);
218 }
219 
220 void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
221   if (!IsValid())
222     return;
223 
224   TargetSP target_sp = m_impl_up->GetTarget();
225   if (!target_sp)
226     return;
227   target_sp->ApplyNameToBreakpoints(bp_name);
228 
229 }
230 
231 bool SBBreakpointName::IsEnabled() {
232   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
233 
234   BreakpointName *bp_name = GetBreakpointName();
235   if (!bp_name)
236     return false;
237 
238   std::lock_guard<std::recursive_mutex> guard(
239         m_impl_up->GetTarget()->GetAPIMutex());
240 
241   return bp_name->GetOptions().IsEnabled();
242 }
243 
244 void SBBreakpointName::SetOneShot(bool one_shot) {
245   LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
246 
247   BreakpointName *bp_name = GetBreakpointName();
248   if (!bp_name)
249     return;
250 
251   std::lock_guard<std::recursive_mutex> guard(
252         m_impl_up->GetTarget()->GetAPIMutex());
253 
254   bp_name->GetOptions().SetOneShot(one_shot);
255   UpdateName(*bp_name);
256 }
257 
258 bool SBBreakpointName::IsOneShot() const {
259   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
260 
261   const BreakpointName *bp_name = GetBreakpointName();
262   if (!bp_name)
263     return false;
264 
265   std::lock_guard<std::recursive_mutex> guard(
266         m_impl_up->GetTarget()->GetAPIMutex());
267 
268   return bp_name->GetOptions().IsOneShot();
269 }
270 
271 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
272   LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
273 
274   BreakpointName *bp_name = GetBreakpointName();
275   if (!bp_name)
276     return;
277 
278   std::lock_guard<std::recursive_mutex> guard(
279         m_impl_up->GetTarget()->GetAPIMutex());
280 
281   bp_name->GetOptions().SetIgnoreCount(count);
282   UpdateName(*bp_name);
283 }
284 
285 uint32_t SBBreakpointName::GetIgnoreCount() const {
286   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
287 
288   BreakpointName *bp_name = GetBreakpointName();
289   if (!bp_name)
290     return false;
291 
292   std::lock_guard<std::recursive_mutex> guard(
293         m_impl_up->GetTarget()->GetAPIMutex());
294 
295   return bp_name->GetOptions().GetIgnoreCount();
296 }
297 
298 void SBBreakpointName::SetCondition(const char *condition) {
299   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
300                      condition);
301 
302   BreakpointName *bp_name = GetBreakpointName();
303   if (!bp_name)
304     return;
305 
306   std::lock_guard<std::recursive_mutex> guard(
307         m_impl_up->GetTarget()->GetAPIMutex());
308 
309   bp_name->GetOptions().SetCondition(condition);
310   UpdateName(*bp_name);
311 }
312 
313 const char *SBBreakpointName::GetCondition() {
314   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
315 
316   BreakpointName *bp_name = GetBreakpointName();
317   if (!bp_name)
318     return nullptr;
319 
320   std::lock_guard<std::recursive_mutex> guard(
321         m_impl_up->GetTarget()->GetAPIMutex());
322 
323   return bp_name->GetOptions().GetConditionText();
324 }
325 
326 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
327   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
328                      auto_continue);
329 
330   BreakpointName *bp_name = GetBreakpointName();
331   if (!bp_name)
332     return;
333 
334   std::lock_guard<std::recursive_mutex> guard(
335         m_impl_up->GetTarget()->GetAPIMutex());
336 
337   bp_name->GetOptions().SetAutoContinue(auto_continue);
338   UpdateName(*bp_name);
339 }
340 
341 bool SBBreakpointName::GetAutoContinue() {
342   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
343 
344   BreakpointName *bp_name = GetBreakpointName();
345   if (!bp_name)
346     return false;
347 
348   std::lock_guard<std::recursive_mutex> guard(
349         m_impl_up->GetTarget()->GetAPIMutex());
350 
351   return bp_name->GetOptions().IsAutoContinue();
352 }
353 
354 void SBBreakpointName::SetThreadID(tid_t tid) {
355   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
356 
357   BreakpointName *bp_name = GetBreakpointName();
358   if (!bp_name)
359     return;
360 
361   std::lock_guard<std::recursive_mutex> guard(
362         m_impl_up->GetTarget()->GetAPIMutex());
363 
364   bp_name->GetOptions().SetThreadID(tid);
365   UpdateName(*bp_name);
366 }
367 
368 tid_t SBBreakpointName::GetThreadID() {
369   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
370 
371   BreakpointName *bp_name = GetBreakpointName();
372   if (!bp_name)
373     return LLDB_INVALID_THREAD_ID;
374 
375   std::lock_guard<std::recursive_mutex> guard(
376         m_impl_up->GetTarget()->GetAPIMutex());
377 
378   return bp_name->GetOptions().GetThreadSpec()->GetTID();
379 }
380 
381 void SBBreakpointName::SetThreadIndex(uint32_t index) {
382   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
383 
384   BreakpointName *bp_name = GetBreakpointName();
385   if (!bp_name)
386     return;
387 
388   std::lock_guard<std::recursive_mutex> guard(
389         m_impl_up->GetTarget()->GetAPIMutex());
390 
391   bp_name->GetOptions().GetThreadSpec()->SetIndex(index);
392   UpdateName(*bp_name);
393 }
394 
395 uint32_t SBBreakpointName::GetThreadIndex() const {
396   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
397 
398   BreakpointName *bp_name = GetBreakpointName();
399   if (!bp_name)
400     return LLDB_INVALID_THREAD_ID;
401 
402   std::lock_guard<std::recursive_mutex> guard(
403         m_impl_up->GetTarget()->GetAPIMutex());
404 
405   return bp_name->GetOptions().GetThreadSpec()->GetIndex();
406 }
407 
408 void SBBreakpointName::SetThreadName(const char *thread_name) {
409   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
410                      thread_name);
411 
412   BreakpointName *bp_name = GetBreakpointName();
413   if (!bp_name)
414     return;
415 
416   std::lock_guard<std::recursive_mutex> guard(
417         m_impl_up->GetTarget()->GetAPIMutex());
418 
419   bp_name->GetOptions().GetThreadSpec()->SetName(thread_name);
420   UpdateName(*bp_name);
421 }
422 
423 const char *SBBreakpointName::GetThreadName() const {
424   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
425                                    GetThreadName);
426 
427   BreakpointName *bp_name = GetBreakpointName();
428   if (!bp_name)
429     return nullptr;
430 
431   std::lock_guard<std::recursive_mutex> guard(
432         m_impl_up->GetTarget()->GetAPIMutex());
433 
434   return bp_name->GetOptions().GetThreadSpec()->GetName();
435 }
436 
437 void SBBreakpointName::SetQueueName(const char *queue_name) {
438   LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
439                      queue_name);
440 
441   BreakpointName *bp_name = GetBreakpointName();
442   if (!bp_name)
443     return;
444 
445   std::lock_guard<std::recursive_mutex> guard(
446         m_impl_up->GetTarget()->GetAPIMutex());
447 
448   bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
449   UpdateName(*bp_name);
450 }
451 
452 const char *SBBreakpointName::GetQueueName() const {
453   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
454                                    GetQueueName);
455 
456   BreakpointName *bp_name = GetBreakpointName();
457   if (!bp_name)
458     return nullptr;
459 
460   std::lock_guard<std::recursive_mutex> guard(
461         m_impl_up->GetTarget()->GetAPIMutex());
462 
463   return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
464 }
465 
466 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
467   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
468                      (lldb::SBStringList &), commands);
469 
470   BreakpointName *bp_name = GetBreakpointName();
471   if (!bp_name)
472     return;
473   if (commands.GetSize() == 0)
474     return;
475 
476 
477   std::lock_guard<std::recursive_mutex> guard(
478         m_impl_up->GetTarget()->GetAPIMutex());
479   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
480       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
481 
482   bp_name->GetOptions().SetCommandDataCallback(cmd_data_up);
483   UpdateName(*bp_name);
484 }
485 
486 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
487   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
488                      (lldb::SBStringList &), commands);
489 
490   BreakpointName *bp_name = GetBreakpointName();
491   if (!bp_name)
492     return false;
493 
494   StringList command_list;
495   bool has_commands =
496       bp_name->GetOptions().GetCommandLineCallbacks(command_list);
497   if (has_commands)
498     commands.AppendList(command_list);
499   return has_commands;
500 }
501 
502 const char *SBBreakpointName::GetHelpString() const {
503   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
504                                    GetHelpString);
505 
506   BreakpointName *bp_name = GetBreakpointName();
507   if (!bp_name)
508     return "";
509 
510   return bp_name->GetHelp();
511 }
512 
513 void SBBreakpointName::SetHelpString(const char *help_string) {
514   LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
515                      help_string);
516 
517   BreakpointName *bp_name = GetBreakpointName();
518   if (!bp_name)
519     return;
520 
521 
522   std::lock_guard<std::recursive_mutex> guard(
523         m_impl_up->GetTarget()->GetAPIMutex());
524   bp_name->SetHelp(help_string);
525 }
526 
527 bool SBBreakpointName::GetDescription(SBStream &s) {
528   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
529                      s);
530 
531   BreakpointName *bp_name = GetBreakpointName();
532   if (!bp_name)
533   {
534     s.Printf("No value");
535     return false;
536   }
537 
538   std::lock_guard<std::recursive_mutex> guard(
539         m_impl_up->GetTarget()->GetAPIMutex());
540   bp_name->GetDescription(s.get(), eDescriptionLevelFull);
541   return true;
542 }
543 
544 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
545                                    void *baton) {
546   BreakpointName *bp_name = GetBreakpointName();
547   if (!bp_name)
548     return;
549   std::lock_guard<std::recursive_mutex> guard(
550         m_impl_up->GetTarget()->GetAPIMutex());
551 
552   BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
553   bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton
554                                        ::PrivateBreakpointHitCallback,
555                                     baton_sp,
556                                     false);
557   UpdateName(*bp_name);
558 }
559 
560 void SBBreakpointName::SetScriptCallbackFunction(
561     const char *callback_function_name) {
562   LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
563                      (const char *), callback_function_name);
564 
565   BreakpointName *bp_name = GetBreakpointName();
566   if (!bp_name)
567     return;
568 
569   std::lock_guard<std::recursive_mutex> guard(
570         m_impl_up->GetTarget()->GetAPIMutex());
571 
572   BreakpointOptions &bp_options = bp_name->GetOptions();
573   m_impl_up->GetTarget()
574       ->GetDebugger()
575       .GetCommandInterpreter()
576       .GetScriptInterpreter()
577       ->SetBreakpointCommandCallbackFunction(&bp_options,
578                                              callback_function_name);
579   UpdateName(*bp_name);
580 }
581 
582 SBError
583 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
584   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
585                      (const char *), callback_body_text);
586 
587   SBError sb_error;
588   BreakpointName *bp_name = GetBreakpointName();
589   if (!bp_name)
590     return LLDB_RECORD_RESULT(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 =
597       m_impl_up->GetTarget()
598           ->GetDebugger()
599           .GetCommandInterpreter()
600           .GetScriptInterpreter()
601           ->SetBreakpointCommandCallback(&bp_options, callback_body_text);
602   sb_error.SetError(error);
603   if (!sb_error.Fail())
604     UpdateName(*bp_name);
605 
606   return LLDB_RECORD_RESULT(sb_error);
607 }
608 
609 bool SBBreakpointName::GetAllowList() const {
610   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
611 
612   BreakpointName *bp_name = GetBreakpointName();
613   if (!bp_name)
614     return false;
615   return bp_name->GetPermissions().GetAllowList();
616 }
617 
618 void SBBreakpointName::SetAllowList(bool value) {
619   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
620 
621 
622   BreakpointName *bp_name = GetBreakpointName();
623   if (!bp_name)
624     return;
625   bp_name->GetPermissions().SetAllowList(value);
626 }
627 
628 bool SBBreakpointName::GetAllowDelete() {
629   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
630 
631   BreakpointName *bp_name = GetBreakpointName();
632   if (!bp_name)
633     return false;
634   return bp_name->GetPermissions().GetAllowDelete();
635 }
636 
637 void SBBreakpointName::SetAllowDelete(bool value) {
638   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
639 
640 
641   BreakpointName *bp_name = GetBreakpointName();
642   if (!bp_name)
643     return;
644   bp_name->GetPermissions().SetAllowDelete(value);
645 }
646 
647 bool SBBreakpointName::GetAllowDisable() {
648   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
649 
650   BreakpointName *bp_name = GetBreakpointName();
651   if (!bp_name)
652     return false;
653   return bp_name->GetPermissions().GetAllowDisable();
654 }
655 
656 void SBBreakpointName::SetAllowDisable(bool value) {
657   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
658 
659   BreakpointName *bp_name = GetBreakpointName();
660   if (!bp_name)
661     return;
662   bp_name->GetPermissions().SetAllowDisable(value);
663 }
664 
665 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
666 {
667   if (!IsValid())
668     return nullptr;
669   return m_impl_up->GetBreakpointName();
670 }
671 
672