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