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