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