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