lldb/source/API/SBBreakpointName.cpp

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