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: 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 = 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 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 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:: 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 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 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 194 bool SBBreakpointName::IsValid() const { 195 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid); 196 return this->operator bool(); 197 } 198 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 206 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 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 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 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 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 265 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 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 292 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 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 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 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 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 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 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 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 402 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 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 430 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 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 459 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 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 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 509 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 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 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 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 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 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(&bp_options, 600 callback_function_name, 601 extra_args.m_impl_up 602 ->GetObjectSP()); 603 sb_error.SetError(error); 604 UpdateName(*bp_name); 605 return LLDB_RECORD_RESULT(sb_error); 606 } 607 608 SBError 609 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { 610 LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, 611 (const char *), callback_body_text); 612 613 SBError sb_error; 614 BreakpointName *bp_name = GetBreakpointName(); 615 if (!bp_name) 616 return LLDB_RECORD_RESULT(sb_error); 617 618 std::lock_guard<std::recursive_mutex> guard( 619 m_impl_up->GetTarget()->GetAPIMutex()); 620 621 BreakpointOptions &bp_options = bp_name->GetOptions(); 622 Status error = 623 m_impl_up->GetTarget() 624 ->GetDebugger() 625 .GetScriptInterpreter() 626 ->SetBreakpointCommandCallback(&bp_options, callback_body_text); 627 sb_error.SetError(error); 628 if (!sb_error.Fail()) 629 UpdateName(*bp_name); 630 631 return LLDB_RECORD_RESULT(sb_error); 632 } 633 634 bool SBBreakpointName::GetAllowList() const { 635 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, GetAllowList); 636 637 BreakpointName *bp_name = GetBreakpointName(); 638 if (!bp_name) 639 return false; 640 return bp_name->GetPermissions().GetAllowList(); 641 } 642 643 void SBBreakpointName::SetAllowList(bool value) { 644 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowList, (bool), value); 645 646 647 BreakpointName *bp_name = GetBreakpointName(); 648 if (!bp_name) 649 return; 650 bp_name->GetPermissions().SetAllowList(value); 651 } 652 653 bool SBBreakpointName::GetAllowDelete() { 654 LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDelete); 655 656 BreakpointName *bp_name = GetBreakpointName(); 657 if (!bp_name) 658 return false; 659 return bp_name->GetPermissions().GetAllowDelete(); 660 } 661 662 void SBBreakpointName::SetAllowDelete(bool value) { 663 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDelete, (bool), value); 664 665 666 BreakpointName *bp_name = GetBreakpointName(); 667 if (!bp_name) 668 return; 669 bp_name->GetPermissions().SetAllowDelete(value); 670 } 671 672 bool SBBreakpointName::GetAllowDisable() { 673 LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointName, GetAllowDisable); 674 675 BreakpointName *bp_name = GetBreakpointName(); 676 if (!bp_name) 677 return false; 678 return bp_name->GetPermissions().GetAllowDisable(); 679 } 680 681 void SBBreakpointName::SetAllowDisable(bool value) { 682 LLDB_RECORD_METHOD(void, SBBreakpointName, SetAllowDisable, (bool), value); 683 684 BreakpointName *bp_name = GetBreakpointName(); 685 if (!bp_name) 686 return; 687 bp_name->GetPermissions().SetAllowDisable(value); 688 } 689 690 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const 691 { 692 if (!IsValid()) 693 return nullptr; 694 return m_impl_up->GetBreakpointName(); 695 } 696 697 698 namespace lldb_private { 699 namespace repro { 700 701 template <> 702 void RegisterMethods<SBBreakpointName>(Registry &R) { 703 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, ()); 704 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, 705 (lldb::SBTarget &, const char *)); 706 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, 707 (lldb::SBBreakpoint &, const char *)); 708 LLDB_REGISTER_CONSTRUCTOR(SBBreakpointName, 709 (const lldb::SBBreakpointName &)); 710 LLDB_REGISTER_METHOD( 711 const lldb::SBBreakpointName &, 712 SBBreakpointName, operator=,(const lldb::SBBreakpointName &)); 713 LLDB_REGISTER_METHOD( 714 bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &)); 715 LLDB_REGISTER_METHOD( 716 bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &)); 717 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ()); 718 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ()); 719 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ()); 720 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool)); 721 LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ()); 722 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool)); 723 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ()); 724 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t)); 725 LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ()); 726 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *)); 727 LLDB_REGISTER_METHOD(const char *, SBBreakpointName, GetCondition, ()); 728 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAutoContinue, (bool)); 729 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAutoContinue, ()); 730 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadID, (lldb::tid_t)); 731 LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointName, GetThreadID, ()); 732 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadIndex, (uint32_t)); 733 LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetThreadIndex, ()); 734 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetThreadName, (const char *)); 735 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetThreadName, 736 ()); 737 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetQueueName, (const char *)); 738 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetQueueName, 739 ()); 740 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCommandLineCommands, 741 (lldb::SBStringList &)); 742 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetCommandLineCommands, 743 (lldb::SBStringList &)); 744 LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetHelpString, 745 ()); 746 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetHelpString, (const char *)); 747 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetDescription, 748 (lldb::SBStream &)); 749 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetScriptCallbackFunction, 750 (const char *)); 751 LLDB_REGISTER_METHOD(SBError, SBBreakpointName, SetScriptCallbackFunction, 752 (const char *, SBStructuredData &)); 753 LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointName, SetScriptCallbackBody, 754 (const char *)); 755 LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, GetAllowList, ()); 756 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowList, (bool)); 757 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDelete, ()); 758 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDelete, (bool)); 759 LLDB_REGISTER_METHOD(bool, SBBreakpointName, GetAllowDisable, ()); 760 LLDB_REGISTER_METHOD(void, SBBreakpointName, SetAllowDisable, (bool)); 761 } 762 763 } 764 } 765