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 
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/SBStructuredData.h"
16 #include "lldb/API/SBTarget.h"
17 
18 #include "lldb/Breakpoint/BreakpointName.h"
19 #include "lldb/Breakpoint/StoppointCallbackContext.h"
20 #include "lldb/Core/Debugger.h"
21 #include "lldb/Core/StructuredDataImpl.h"
22 #include "lldb/Interpreter/CommandInterpreter.h"
23 #include "lldb/Interpreter/ScriptInterpreter.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Target/ThreadSpec.h"
26 #include "lldb/Utility/Stream.h"
27 
28 #include "SBBreakpointOptionCommon.h"
29 
30 using namespace lldb;
31 using namespace lldb_private;
32 
33 namespace lldb
34 {
35 class SBBreakpointNameImpl {
36 public:
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 
67   lldb_private::BreakpointName *GetBreakpointName() const;
68 
69 private:
70   TargetWP m_target_wp;
71   std::string m_name;
72 };
73 
74 SBBreakpointNameImpl::SBBreakpointNameImpl(SBTarget &sb_target,
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 
90 bool SBBreakpointNameImpl::operator==(const SBBreakpointNameImpl &rhs) {
91   return m_name == rhs.m_name && m_target_wp.lock() == rhs.m_target_wp.lock();
92 }
93 
94 bool SBBreakpointNameImpl::operator!=(const SBBreakpointNameImpl &rhs) {
95   return m_name != rhs.m_name || m_target_wp.lock() != rhs.m_target_wp.lock();
96 }
97 
98 lldb_private::BreakpointName *SBBreakpointNameImpl::GetBreakpointName() const {
99   if (!IsValid())
100     return nullptr;
101   TargetSP target_sp = GetTarget();
102   if (!target_sp)
103     return nullptr;
104   Status error;
105   return target_sp->FindBreakpointName(ConstString(m_name), true, error);
106 }
107 
108 } // namespace lldb
109 
110 SBBreakpointName::SBBreakpointName() {
111   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointName);
112 }
113 
114 SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) {
115   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (lldb::SBTarget &, const char *),
116                           sb_target, name);
117 
118   m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name);
119   // Call FindBreakpointName here to make sure the name is valid, reset if not:
120   BreakpointName *bp_name = GetBreakpointName();
121   if (!bp_name)
122     m_impl_up.reset();
123 }
124 
125 SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) {
126   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName,
127                           (lldb::SBBreakpoint &, const char *), sb_bkpt, name);
128 
129   if (!sb_bkpt.IsValid()) {
130     m_impl_up.reset();
131     return;
132   }
133   BreakpointSP bkpt_sp = sb_bkpt.GetSP();
134   Target &target = bkpt_sp->GetTarget();
135 
136   m_impl_up =
137       std::make_unique<SBBreakpointNameImpl>(target.shared_from_this(), name);
138 
139   // Call FindBreakpointName here to make sure the name is valid, reset if not:
140   BreakpointName *bp_name = GetBreakpointName();
141   if (!bp_name) {
142     m_impl_up.reset();
143     return;
144   }
145 
146   // Now copy over the breakpoint's options:
147   target.ConfigureBreakpointName(*bp_name, *bkpt_sp->GetOptions(),
148                                  BreakpointName::Permissions());
149 }
150 
151 SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) {
152   LLDB_RECORD_CONSTRUCTOR(SBBreakpointName, (const lldb::SBBreakpointName &),
153                           rhs);
154 
155   if (!rhs.m_impl_up)
156     return;
157   else
158     m_impl_up = std::make_unique<SBBreakpointNameImpl>(
159         rhs.m_impl_up->GetTarget(), rhs.m_impl_up->GetName());
160 }
161 
162 SBBreakpointName::~SBBreakpointName() = default;
163 
164 const SBBreakpointName &SBBreakpointName::
165 operator=(const SBBreakpointName &rhs) {
166   LLDB_RECORD_METHOD(
167       const lldb::SBBreakpointName &,
168       SBBreakpointName, operator=,(const lldb::SBBreakpointName &), rhs);
169 
170   if (!rhs.m_impl_up) {
171     m_impl_up.reset();
172     return LLDB_RECORD_RESULT(*this);
173   }
174 
175   m_impl_up = std::make_unique<SBBreakpointNameImpl>(rhs.m_impl_up->GetTarget(),
176                                                      rhs.m_impl_up->GetName());
177   return LLDB_RECORD_RESULT(*this);
178 }
179 
180 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
181   LLDB_RECORD_METHOD(
182       bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &), rhs);
183 
184   return *m_impl_up == *rhs.m_impl_up;
185 }
186 
187 bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
188   LLDB_RECORD_METHOD(
189       bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
190 
191   return *m_impl_up != *rhs.m_impl_up;
192 }
193 
194 bool SBBreakpointName::IsValid() const {
195   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
196   return this->operator bool();
197 }
198 SBBreakpointName::operator bool() const {
199   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool);
200 
201   if (!m_impl_up)
202     return false;
203   return m_impl_up->IsValid();
204 }
205 
206 const char *SBBreakpointName::GetName() const {
207   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);
208 
209   if (!m_impl_up)
210     return "<Invalid Breakpoint Name Object>";
211   return m_impl_up->GetName();
212 }
213 
214 void SBBreakpointName::SetEnabled(bool enable) {
215   LLDB_RECORD_METHOD(void, SBBreakpointName, SetEnabled, (bool), enable);
216 
217   BreakpointName *bp_name = GetBreakpointName();
218   if (!bp_name)
219     return;
220 
221   std::lock_guard<std::recursive_mutex> guard(
222         m_impl_up->GetTarget()->GetAPIMutex());
223 
224   bp_name->GetOptions().SetEnabled(enable);
225 }
226 
227 void SBBreakpointName::UpdateName(BreakpointName &bp_name) {
228   if (!IsValid())
229     return;
230 
231   TargetSP target_sp = m_impl_up->GetTarget();
232   if (!target_sp)
233     return;
234   target_sp->ApplyNameToBreakpoints(bp_name);
235 
236 }
237 
238 bool SBBreakpointName::IsEnabled() {
239   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, IsEnabled);
240 
241   BreakpointName *bp_name = GetBreakpointName();
242   if (!bp_name)
243     return false;
244 
245   std::lock_guard<std::recursive_mutex> guard(
246         m_impl_up->GetTarget()->GetAPIMutex());
247 
248   return bp_name->GetOptions().IsEnabled();
249 }
250 
251 void SBBreakpointName::SetOneShot(bool one_shot) {
252   LLDB_RECORD_METHOD(void, SBBreakpointName, SetOneShot, (bool), one_shot);
253 
254   BreakpointName *bp_name = GetBreakpointName();
255   if (!bp_name)
256     return;
257 
258   std::lock_guard<std::recursive_mutex> guard(
259         m_impl_up->GetTarget()->GetAPIMutex());
260 
261   bp_name->GetOptions().SetOneShot(one_shot);
262   UpdateName(*bp_name);
263 }
264 
265 bool SBBreakpointName::IsOneShot() const {
266   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsOneShot);
267 
268   const BreakpointName *bp_name = GetBreakpointName();
269   if (!bp_name)
270     return false;
271 
272   std::lock_guard<std::recursive_mutex> guard(
273         m_impl_up->GetTarget()->GetAPIMutex());
274 
275   return bp_name->GetOptions().IsOneShot();
276 }
277 
278 void SBBreakpointName::SetIgnoreCount(uint32_t count) {
279   LLDB_RECORD_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t), count);
280 
281   BreakpointName *bp_name = GetBreakpointName();
282   if (!bp_name)
283     return;
284 
285   std::lock_guard<std::recursive_mutex> guard(
286         m_impl_up->GetTarget()->GetAPIMutex());
287 
288   bp_name->GetOptions().SetIgnoreCount(count);
289   UpdateName(*bp_name);
290 }
291 
292 uint32_t SBBreakpointName::GetIgnoreCount() const {
293   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetIgnoreCount);
294 
295   BreakpointName *bp_name = GetBreakpointName();
296   if (!bp_name)
297     return false;
298 
299   std::lock_guard<std::recursive_mutex> guard(
300         m_impl_up->GetTarget()->GetAPIMutex());
301 
302   return bp_name->GetOptions().GetIgnoreCount();
303 }
304 
305 void SBBreakpointName::SetCondition(const char *condition) {
306   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCondition, (const char *),
307                      condition);
308 
309   BreakpointName *bp_name = GetBreakpointName();
310   if (!bp_name)
311     return;
312 
313   std::lock_guard<std::recursive_mutex> guard(
314         m_impl_up->GetTarget()->GetAPIMutex());
315 
316   bp_name->GetOptions().SetCondition(condition);
317   UpdateName(*bp_name);
318 }
319 
320 const char *SBBreakpointName::GetCondition() {
321   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointName, GetCondition);
322 
323   BreakpointName *bp_name = GetBreakpointName();
324   if (!bp_name)
325     return nullptr;
326 
327   std::lock_guard<std::recursive_mutex> guard(
328         m_impl_up->GetTarget()->GetAPIMutex());
329 
330   return bp_name->GetOptions().GetConditionText();
331 }
332 
333 void SBBreakpointName::SetAutoContinue(bool auto_continue) {
334   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAutoContinue, (bool),
335                      auto_continue);
336 
337   BreakpointName *bp_name = GetBreakpointName();
338   if (!bp_name)
339     return;
340 
341   std::lock_guard<std::recursive_mutex> guard(
342         m_impl_up->GetTarget()->GetAPIMutex());
343 
344   bp_name->GetOptions().SetAutoContinue(auto_continue);
345   UpdateName(*bp_name);
346 }
347 
348 bool SBBreakpointName::GetAutoContinue() {
349   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAutoContinue);
350 
351   BreakpointName *bp_name = GetBreakpointName();
352   if (!bp_name)
353     return false;
354 
355   std::lock_guard<std::recursive_mutex> guard(
356         m_impl_up->GetTarget()->GetAPIMutex());
357 
358   return bp_name->GetOptions().IsAutoContinue();
359 }
360 
361 void SBBreakpointName::SetThreadID(tid_t tid) {
362   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t), tid);
363 
364   BreakpointName *bp_name = GetBreakpointName();
365   if (!bp_name)
366     return;
367 
368   std::lock_guard<std::recursive_mutex> guard(
369         m_impl_up->GetTarget()->GetAPIMutex());
370 
371   bp_name->GetOptions().SetThreadID(tid);
372   UpdateName(*bp_name);
373 }
374 
375 tid_t SBBreakpointName::GetThreadID() {
376   LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointName, GetThreadID);
377 
378   BreakpointName *bp_name = GetBreakpointName();
379   if (!bp_name)
380     return LLDB_INVALID_THREAD_ID;
381 
382   std::lock_guard<std::recursive_mutex> guard(
383         m_impl_up->GetTarget()->GetAPIMutex());
384 
385   return bp_name->GetOptions().GetThreadSpec()->GetTID();
386 }
387 
388 void SBBreakpointName::SetThreadIndex(uint32_t index) {
389   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t), index);
390 
391   BreakpointName *bp_name = GetBreakpointName();
392   if (!bp_name)
393     return;
394 
395   std::lock_guard<std::recursive_mutex> guard(
396         m_impl_up->GetTarget()->GetAPIMutex());
397 
398   bp_name->GetOptions().GetThreadSpec()->SetIndex(index);
399   UpdateName(*bp_name);
400 }
401 
402 uint32_t SBBreakpointName::GetThreadIndex() const {
403   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointName, GetThreadIndex);
404 
405   BreakpointName *bp_name = GetBreakpointName();
406   if (!bp_name)
407     return LLDB_INVALID_THREAD_ID;
408 
409   std::lock_guard<std::recursive_mutex> guard(
410         m_impl_up->GetTarget()->GetAPIMutex());
411 
412   return bp_name->GetOptions().GetThreadSpec()->GetIndex();
413 }
414 
415 void SBBreakpointName::SetThreadName(const char *thread_name) {
416   LLDB_RECORD_METHOD(void, SBBreakpointName, SetThreadName, (const char *),
417                      thread_name);
418 
419   BreakpointName *bp_name = GetBreakpointName();
420   if (!bp_name)
421     return;
422 
423   std::lock_guard<std::recursive_mutex> guard(
424         m_impl_up->GetTarget()->GetAPIMutex());
425 
426   bp_name->GetOptions().GetThreadSpec()->SetName(thread_name);
427   UpdateName(*bp_name);
428 }
429 
430 const char *SBBreakpointName::GetThreadName() const {
431   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
432                                    GetThreadName);
433 
434   BreakpointName *bp_name = GetBreakpointName();
435   if (!bp_name)
436     return nullptr;
437 
438   std::lock_guard<std::recursive_mutex> guard(
439         m_impl_up->GetTarget()->GetAPIMutex());
440 
441   return bp_name->GetOptions().GetThreadSpec()->GetName();
442 }
443 
444 void SBBreakpointName::SetQueueName(const char *queue_name) {
445   LLDB_RECORD_METHOD(void, SBBreakpointName, SetQueueName, (const char *),
446                      queue_name);
447 
448   BreakpointName *bp_name = GetBreakpointName();
449   if (!bp_name)
450     return;
451 
452   std::lock_guard<std::recursive_mutex> guard(
453         m_impl_up->GetTarget()->GetAPIMutex());
454 
455   bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
456   UpdateName(*bp_name);
457 }
458 
459 const char *SBBreakpointName::GetQueueName() const {
460   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
461                                    GetQueueName);
462 
463   BreakpointName *bp_name = GetBreakpointName();
464   if (!bp_name)
465     return nullptr;
466 
467   std::lock_guard<std::recursive_mutex> guard(
468         m_impl_up->GetTarget()->GetAPIMutex());
469 
470   return bp_name->GetOptions().GetThreadSpec()->GetQueueName();
471 }
472 
473 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) {
474   LLDB_RECORD_METHOD(void, SBBreakpointName, SetCommandLineCommands,
475                      (lldb::SBStringList &), commands);
476 
477   BreakpointName *bp_name = GetBreakpointName();
478   if (!bp_name)
479     return;
480   if (commands.GetSize() == 0)
481     return;
482 
483 
484   std::lock_guard<std::recursive_mutex> guard(
485         m_impl_up->GetTarget()->GetAPIMutex());
486   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
487       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
488 
489   bp_name->GetOptions().SetCommandDataCallback(cmd_data_up);
490   UpdateName(*bp_name);
491 }
492 
493 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
494   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
495                      (lldb::SBStringList &), commands);
496 
497   BreakpointName *bp_name = GetBreakpointName();
498   if (!bp_name)
499     return false;
500 
501   StringList command_list;
502   bool has_commands =
503       bp_name->GetOptions().GetCommandLineCallbacks(command_list);
504   if (has_commands)
505     commands.AppendList(command_list);
506   return has_commands;
507 }
508 
509 const char *SBBreakpointName::GetHelpString() const {
510   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName,
511                                    GetHelpString);
512 
513   BreakpointName *bp_name = GetBreakpointName();
514   if (!bp_name)
515     return "";
516 
517   return bp_name->GetHelp();
518 }
519 
520 void SBBreakpointName::SetHelpString(const char *help_string) {
521   LLDB_RECORD_METHOD(void, SBBreakpointName, SetHelpString, (const char *),
522                      help_string);
523 
524   BreakpointName *bp_name = GetBreakpointName();
525   if (!bp_name)
526     return;
527 
528 
529   std::lock_guard<std::recursive_mutex> guard(
530         m_impl_up->GetTarget()->GetAPIMutex());
531   bp_name->SetHelp(help_string);
532 }
533 
534 bool SBBreakpointName::GetDescription(SBStream &s) {
535   LLDB_RECORD_METHOD(bool, SBBreakpointName, GetDescription, (lldb::SBStream &),
536                      s);
537 
538   BreakpointName *bp_name = GetBreakpointName();
539   if (!bp_name)
540   {
541     s.Printf("No value");
542     return false;
543   }
544 
545   std::lock_guard<std::recursive_mutex> guard(
546         m_impl_up->GetTarget()->GetAPIMutex());
547   bp_name->GetDescription(s.get(), eDescriptionLevelFull);
548   return true;
549 }
550 
551 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
552                                    void *baton) {
553   LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback,
554                     (lldb::SBBreakpointHitCallback, void *), callback, baton);
555 
556   BreakpointName *bp_name = GetBreakpointName();
557   if (!bp_name)
558     return;
559   std::lock_guard<std::recursive_mutex> guard(
560         m_impl_up->GetTarget()->GetAPIMutex());
561 
562   BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
563   bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton
564                                        ::PrivateBreakpointHitCallback,
565                                     baton_sp,
566                                     false);
567   UpdateName(*bp_name);
568 }
569 
570 void SBBreakpointName::SetScriptCallbackFunction(
571   const char *callback_function_name) {
572 LLDB_RECORD_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
573                    (const char *), callback_function_name);
574   SBStructuredData empty_args;
575   SetScriptCallbackFunction(callback_function_name, empty_args);
576 }
577 
578 SBError SBBreakpointName::SetScriptCallbackFunction(
579     const char *callback_function_name,
580     SBStructuredData &extra_args) {
581   LLDB_RECORD_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
582                      (const char *, SBStructuredData &),
583                      callback_function_name, extra_args);
584   SBError sb_error;
585   BreakpointName *bp_name = GetBreakpointName();
586   if (!bp_name) {
587     sb_error.SetErrorString("unrecognized breakpoint name");
588     return LLDB_RECORD_RESULT(sb_error);
589   }
590 
591   std::lock_guard<std::recursive_mutex> guard(
592         m_impl_up->GetTarget()->GetAPIMutex());
593 
594   BreakpointOptions &bp_options = bp_name->GetOptions();
595   Status error;
596   error = m_impl_up->GetTarget()
597       ->GetDebugger()
598       .GetScriptInterpreter()
599       ->SetBreakpointCommandCallbackFunction(&bp_options,
600                                              callback_function_name,
601                                              extra_args.m_impl_up
602                                                  ->GetObjectSP());
603   sb_error.SetError(error);
604   UpdateName(*bp_name);
605   return LLDB_RECORD_RESULT(sb_error);
606 }
607 
608 SBError
609 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
610   LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
611                      (const char *), callback_body_text);
612 
613   SBError sb_error;
614   BreakpointName *bp_name = GetBreakpointName();
615   if (!bp_name)
616     return LLDB_RECORD_RESULT(sb_error);
617 
618   std::lock_guard<std::recursive_mutex> guard(
619         m_impl_up->GetTarget()->GetAPIMutex());
620 
621   BreakpointOptions &bp_options = bp_name->GetOptions();
622   Status error =
623       m_impl_up->GetTarget()
624           ->GetDebugger()
625           .GetScriptInterpreter()
626           ->SetBreakpointCommandCallback(&bp_options, callback_body_text);
627   sb_error.SetError(error);
628   if (!sb_error.Fail())
629     UpdateName(*bp_name);
630 
631   return LLDB_RECORD_RESULT(sb_error);
632 }
633 
634 bool SBBreakpointName::GetAllowList() const {
635   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList);
636 
637   BreakpointName *bp_name = GetBreakpointName();
638   if (!bp_name)
639     return false;
640   return bp_name->GetPermissions().GetAllowList();
641 }
642 
643 void SBBreakpointName::SetAllowList(bool value) {
644   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value);
645 
646 
647   BreakpointName *bp_name = GetBreakpointName();
648   if (!bp_name)
649     return;
650   bp_name->GetPermissions().SetAllowList(value);
651 }
652 
653 bool SBBreakpointName::GetAllowDelete() {
654   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete);
655 
656   BreakpointName *bp_name = GetBreakpointName();
657   if (!bp_name)
658     return false;
659   return bp_name->GetPermissions().GetAllowDelete();
660 }
661 
662 void SBBreakpointName::SetAllowDelete(bool value) {
663   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value);
664 
665 
666   BreakpointName *bp_name = GetBreakpointName();
667   if (!bp_name)
668     return;
669   bp_name->GetPermissions().SetAllowDelete(value);
670 }
671 
672 bool SBBreakpointName::GetAllowDisable() {
673   LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable);
674 
675   BreakpointName *bp_name = GetBreakpointName();
676   if (!bp_name)
677     return false;
678   return bp_name->GetPermissions().GetAllowDisable();
679 }
680 
681 void SBBreakpointName::SetAllowDisable(bool value) {
682   LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value);
683 
684   BreakpointName *bp_name = GetBreakpointName();
685   if (!bp_name)
686     return;
687   bp_name->GetPermissions().SetAllowDisable(value);
688 }
689 
690 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
691 {
692   if (!IsValid())
693     return nullptr;
694   return m_impl_up->GetBreakpointName();
695 }
696 
697 
698 namespace lldb_private {
699 namespace repro {
700 
701 template <>
702 void RegisterMethods<SBBreakpointName>(Registry &R) {
703   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ());
704   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
705                             (lldb::SBTarget &, const char *));
706   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
707                             (lldb::SBBreakpoint &, const char *));
708   LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName,
709                             (const lldb::SBBreakpointName &));
710   LLDB_REGISTER_METHOD(
711       const lldb::SBBreakpointName &,
712       SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
713   LLDB_REGISTER_METHOD(
714       bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
715   LLDB_REGISTER_METHOD(
716       bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
717   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
718   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
719   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
720   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
721   LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
722   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
723   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
724   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
725   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
726   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
727   LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ());
728   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool));
729   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ());
730   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t));
731   LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ());
732   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t));
733   LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ());
734   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *));
735   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName,
736                              ());
737   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *));
738   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName,
739                              ());
740   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands,
741                        (lldb::SBStringList &));
742   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands,
743                        (lldb::SBStringList &));
744   LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString,
745                              ());
746   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *));
747   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription,
748                        (lldb::SBStream &));
749   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction,
750                        (const char *));
751   LLDB_REGISTER_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction,
752                        (const char *, SBStructuredData &));
753   LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody,
754                        (const char *));
755   LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ());
756   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool));
757   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ());
758   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool));
759   LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ());
760   LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool));
761 }
762 
763 }
764 }
765