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