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 "lldb/API/SBDebugger.h" 11 #include "lldb/API/SBError.h" 12 #include "lldb/API/SBStream.h" 13 #include "lldb/API/SBStringList.h" 14 #include "lldb/API/SBStructuredData.h" 15 #include "lldb/API/SBTarget.h" 16 #include "lldb/Utility/Instrumentation.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() { LLDB_INSTRUMENT_VA(this); } 111 112 SBBreakpointName::SBBreakpointName(SBTarget &sb_target, const char *name) { 113 LLDB_INSTRUMENT_VA(this, sb_target, name); 114 115 m_impl_up = std::make_unique<SBBreakpointNameImpl>(sb_target, name); 116 // Call FindBreakpointName here to make sure the name is valid, reset if not: 117 BreakpointName *bp_name = GetBreakpointName(); 118 if (!bp_name) 119 m_impl_up.reset(); 120 } 121 122 SBBreakpointName::SBBreakpointName(SBBreakpoint &sb_bkpt, const char *name) { 123 LLDB_INSTRUMENT_VA(this, sb_bkpt, name); 124 125 if (!sb_bkpt.IsValid()) { 126 m_impl_up.reset(); 127 return; 128 } 129 BreakpointSP bkpt_sp = sb_bkpt.GetSP(); 130 Target &target = bkpt_sp->GetTarget(); 131 132 m_impl_up = 133 std::make_unique<SBBreakpointNameImpl>(target.shared_from_this(), name); 134 135 // Call FindBreakpointName here to make sure the name is valid, reset if not: 136 BreakpointName *bp_name = GetBreakpointName(); 137 if (!bp_name) { 138 m_impl_up.reset(); 139 return; 140 } 141 142 // Now copy over the breakpoint's options: 143 target.ConfigureBreakpointName(*bp_name, bkpt_sp->GetOptions(), 144 BreakpointName::Permissions()); 145 } 146 147 SBBreakpointName::SBBreakpointName(const SBBreakpointName &rhs) { 148 LLDB_INSTRUMENT_VA(this, rhs); 149 150 if (!rhs.m_impl_up) 151 return; 152 else 153 m_impl_up = std::make_unique<SBBreakpointNameImpl>( 154 rhs.m_impl_up->GetTarget(), rhs.m_impl_up->GetName()); 155 } 156 157 SBBreakpointName::~SBBreakpointName() = default; 158 159 const SBBreakpointName &SBBreakpointName:: 160 operator=(const SBBreakpointName &rhs) { 161 LLDB_INSTRUMENT_VA(this, rhs); 162 163 if (!rhs.m_impl_up) { 164 m_impl_up.reset(); 165 return *this; 166 } 167 168 m_impl_up = std::make_unique<SBBreakpointNameImpl>(rhs.m_impl_up->GetTarget(), 169 rhs.m_impl_up->GetName()); 170 return *this; 171 } 172 173 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) { 174 LLDB_INSTRUMENT_VA(this, rhs); 175 176 return *m_impl_up == *rhs.m_impl_up; 177 } 178 179 bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) { 180 LLDB_INSTRUMENT_VA(this, rhs); 181 182 return *m_impl_up != *rhs.m_impl_up; 183 } 184 185 bool SBBreakpointName::IsValid() const { 186 LLDB_INSTRUMENT_VA(this); 187 return this->operator bool(); 188 } 189 SBBreakpointName::operator bool() const { 190 LLDB_INSTRUMENT_VA(this); 191 192 if (!m_impl_up) 193 return false; 194 return m_impl_up->IsValid(); 195 } 196 197 const char *SBBreakpointName::GetName() const { 198 LLDB_INSTRUMENT_VA(this); 199 200 if (!m_impl_up) 201 return "<Invalid Breakpoint Name Object>"; 202 return ConstString(m_impl_up->GetName()).GetCString(); 203 } 204 205 void SBBreakpointName::SetEnabled(bool enable) { 206 LLDB_INSTRUMENT_VA(this, enable); 207 208 BreakpointName *bp_name = GetBreakpointName(); 209 if (!bp_name) 210 return; 211 212 std::lock_guard<std::recursive_mutex> guard( 213 m_impl_up->GetTarget()->GetAPIMutex()); 214 215 bp_name->GetOptions().SetEnabled(enable); 216 } 217 218 void SBBreakpointName::UpdateName(BreakpointName &bp_name) { 219 if (!IsValid()) 220 return; 221 222 TargetSP target_sp = m_impl_up->GetTarget(); 223 if (!target_sp) 224 return; 225 target_sp->ApplyNameToBreakpoints(bp_name); 226 227 } 228 229 bool SBBreakpointName::IsEnabled() { 230 LLDB_INSTRUMENT_VA(this); 231 232 BreakpointName *bp_name = GetBreakpointName(); 233 if (!bp_name) 234 return false; 235 236 std::lock_guard<std::recursive_mutex> guard( 237 m_impl_up->GetTarget()->GetAPIMutex()); 238 239 return bp_name->GetOptions().IsEnabled(); 240 } 241 242 void SBBreakpointName::SetOneShot(bool one_shot) { 243 LLDB_INSTRUMENT_VA(this, one_shot); 244 245 BreakpointName *bp_name = GetBreakpointName(); 246 if (!bp_name) 247 return; 248 249 std::lock_guard<std::recursive_mutex> guard( 250 m_impl_up->GetTarget()->GetAPIMutex()); 251 252 bp_name->GetOptions().SetOneShot(one_shot); 253 UpdateName(*bp_name); 254 } 255 256 bool SBBreakpointName::IsOneShot() const { 257 LLDB_INSTRUMENT_VA(this); 258 259 const BreakpointName *bp_name = GetBreakpointName(); 260 if (!bp_name) 261 return false; 262 263 std::lock_guard<std::recursive_mutex> guard( 264 m_impl_up->GetTarget()->GetAPIMutex()); 265 266 return bp_name->GetOptions().IsOneShot(); 267 } 268 269 void SBBreakpointName::SetIgnoreCount(uint32_t count) { 270 LLDB_INSTRUMENT_VA(this, count); 271 272 BreakpointName *bp_name = GetBreakpointName(); 273 if (!bp_name) 274 return; 275 276 std::lock_guard<std::recursive_mutex> guard( 277 m_impl_up->GetTarget()->GetAPIMutex()); 278 279 bp_name->GetOptions().SetIgnoreCount(count); 280 UpdateName(*bp_name); 281 } 282 283 uint32_t SBBreakpointName::GetIgnoreCount() const { 284 LLDB_INSTRUMENT_VA(this); 285 286 BreakpointName *bp_name = GetBreakpointName(); 287 if (!bp_name) 288 return false; 289 290 std::lock_guard<std::recursive_mutex> guard( 291 m_impl_up->GetTarget()->GetAPIMutex()); 292 293 return bp_name->GetOptions().GetIgnoreCount(); 294 } 295 296 void SBBreakpointName::SetCondition(const char *condition) { 297 LLDB_INSTRUMENT_VA(this, condition); 298 299 BreakpointName *bp_name = GetBreakpointName(); 300 if (!bp_name) 301 return; 302 303 std::lock_guard<std::recursive_mutex> guard( 304 m_impl_up->GetTarget()->GetAPIMutex()); 305 306 bp_name->GetOptions().SetCondition(condition); 307 UpdateName(*bp_name); 308 } 309 310 const char *SBBreakpointName::GetCondition() { 311 LLDB_INSTRUMENT_VA(this); 312 313 BreakpointName *bp_name = GetBreakpointName(); 314 if (!bp_name) 315 return nullptr; 316 317 std::lock_guard<std::recursive_mutex> guard( 318 m_impl_up->GetTarget()->GetAPIMutex()); 319 320 return ConstString(bp_name->GetOptions().GetConditionText()).GetCString(); 321 } 322 323 void SBBreakpointName::SetAutoContinue(bool auto_continue) { 324 LLDB_INSTRUMENT_VA(this, auto_continue); 325 326 BreakpointName *bp_name = GetBreakpointName(); 327 if (!bp_name) 328 return; 329 330 std::lock_guard<std::recursive_mutex> guard( 331 m_impl_up->GetTarget()->GetAPIMutex()); 332 333 bp_name->GetOptions().SetAutoContinue(auto_continue); 334 UpdateName(*bp_name); 335 } 336 337 bool SBBreakpointName::GetAutoContinue() { 338 LLDB_INSTRUMENT_VA(this); 339 340 BreakpointName *bp_name = GetBreakpointName(); 341 if (!bp_name) 342 return false; 343 344 std::lock_guard<std::recursive_mutex> guard( 345 m_impl_up->GetTarget()->GetAPIMutex()); 346 347 return bp_name->GetOptions().IsAutoContinue(); 348 } 349 350 void SBBreakpointName::SetThreadID(tid_t tid) { 351 LLDB_INSTRUMENT_VA(this, tid); 352 353 BreakpointName *bp_name = GetBreakpointName(); 354 if (!bp_name) 355 return; 356 357 std::lock_guard<std::recursive_mutex> guard( 358 m_impl_up->GetTarget()->GetAPIMutex()); 359 360 bp_name->GetOptions().SetThreadID(tid); 361 UpdateName(*bp_name); 362 } 363 364 tid_t SBBreakpointName::GetThreadID() { 365 LLDB_INSTRUMENT_VA(this); 366 367 BreakpointName *bp_name = GetBreakpointName(); 368 if (!bp_name) 369 return LLDB_INVALID_THREAD_ID; 370 371 std::lock_guard<std::recursive_mutex> guard( 372 m_impl_up->GetTarget()->GetAPIMutex()); 373 374 return bp_name->GetOptions().GetThreadSpec()->GetTID(); 375 } 376 377 void SBBreakpointName::SetThreadIndex(uint32_t index) { 378 LLDB_INSTRUMENT_VA(this, index); 379 380 BreakpointName *bp_name = GetBreakpointName(); 381 if (!bp_name) 382 return; 383 384 std::lock_guard<std::recursive_mutex> guard( 385 m_impl_up->GetTarget()->GetAPIMutex()); 386 387 bp_name->GetOptions().GetThreadSpec()->SetIndex(index); 388 UpdateName(*bp_name); 389 } 390 391 uint32_t SBBreakpointName::GetThreadIndex() const { 392 LLDB_INSTRUMENT_VA(this); 393 394 BreakpointName *bp_name = GetBreakpointName(); 395 if (!bp_name) 396 return LLDB_INVALID_THREAD_ID; 397 398 std::lock_guard<std::recursive_mutex> guard( 399 m_impl_up->GetTarget()->GetAPIMutex()); 400 401 return bp_name->GetOptions().GetThreadSpec()->GetIndex(); 402 } 403 404 void SBBreakpointName::SetThreadName(const char *thread_name) { 405 LLDB_INSTRUMENT_VA(this, thread_name); 406 407 BreakpointName *bp_name = GetBreakpointName(); 408 if (!bp_name) 409 return; 410 411 std::lock_guard<std::recursive_mutex> guard( 412 m_impl_up->GetTarget()->GetAPIMutex()); 413 414 bp_name->GetOptions().GetThreadSpec()->SetName(thread_name); 415 UpdateName(*bp_name); 416 } 417 418 const char *SBBreakpointName::GetThreadName() const { 419 LLDB_INSTRUMENT_VA(this); 420 421 BreakpointName *bp_name = GetBreakpointName(); 422 if (!bp_name) 423 return nullptr; 424 425 std::lock_guard<std::recursive_mutex> guard( 426 m_impl_up->GetTarget()->GetAPIMutex()); 427 428 return ConstString(bp_name->GetOptions().GetThreadSpec()->GetName()) 429 .GetCString(); 430 } 431 432 void SBBreakpointName::SetQueueName(const char *queue_name) { 433 LLDB_INSTRUMENT_VA(this, queue_name); 434 435 BreakpointName *bp_name = GetBreakpointName(); 436 if (!bp_name) 437 return; 438 439 std::lock_guard<std::recursive_mutex> guard( 440 m_impl_up->GetTarget()->GetAPIMutex()); 441 442 bp_name->GetOptions().GetThreadSpec()->SetQueueName(queue_name); 443 UpdateName(*bp_name); 444 } 445 446 const char *SBBreakpointName::GetQueueName() const { 447 LLDB_INSTRUMENT_VA(this); 448 449 BreakpointName *bp_name = GetBreakpointName(); 450 if (!bp_name) 451 return nullptr; 452 453 std::lock_guard<std::recursive_mutex> guard( 454 m_impl_up->GetTarget()->GetAPIMutex()); 455 456 return ConstString(bp_name->GetOptions().GetThreadSpec()->GetQueueName()) 457 .GetCString(); 458 } 459 460 void SBBreakpointName::SetCommandLineCommands(SBStringList &commands) { 461 LLDB_INSTRUMENT_VA(this, commands); 462 463 BreakpointName *bp_name = GetBreakpointName(); 464 if (!bp_name) 465 return; 466 if (commands.GetSize() == 0) 467 return; 468 469 470 std::lock_guard<std::recursive_mutex> guard( 471 m_impl_up->GetTarget()->GetAPIMutex()); 472 std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up( 473 new BreakpointOptions::CommandData(*commands, eScriptLanguageNone)); 474 475 bp_name->GetOptions().SetCommandDataCallback(cmd_data_up); 476 UpdateName(*bp_name); 477 } 478 479 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) { 480 LLDB_INSTRUMENT_VA(this, commands); 481 482 BreakpointName *bp_name = GetBreakpointName(); 483 if (!bp_name) 484 return false; 485 486 StringList command_list; 487 bool has_commands = 488 bp_name->GetOptions().GetCommandLineCallbacks(command_list); 489 if (has_commands) 490 commands.AppendList(command_list); 491 return has_commands; 492 } 493 494 const char *SBBreakpointName::GetHelpString() const { 495 LLDB_INSTRUMENT_VA(this); 496 497 BreakpointName *bp_name = GetBreakpointName(); 498 if (!bp_name) 499 return ""; 500 501 return ConstString(bp_name->GetHelp()).GetCString(); 502 } 503 504 void SBBreakpointName::SetHelpString(const char *help_string) { 505 LLDB_INSTRUMENT_VA(this, help_string); 506 507 BreakpointName *bp_name = GetBreakpointName(); 508 if (!bp_name) 509 return; 510 511 512 std::lock_guard<std::recursive_mutex> guard( 513 m_impl_up->GetTarget()->GetAPIMutex()); 514 bp_name->SetHelp(help_string); 515 } 516 517 bool SBBreakpointName::GetDescription(SBStream &s) { 518 LLDB_INSTRUMENT_VA(this, s); 519 520 BreakpointName *bp_name = GetBreakpointName(); 521 if (!bp_name) 522 { 523 s.Printf("No value"); 524 return false; 525 } 526 527 std::lock_guard<std::recursive_mutex> guard( 528 m_impl_up->GetTarget()->GetAPIMutex()); 529 bp_name->GetDescription(s.get(), eDescriptionLevelFull); 530 return true; 531 } 532 533 void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback, 534 void *baton) { 535 LLDB_INSTRUMENT_VA(this, callback, baton); 536 537 BreakpointName *bp_name = GetBreakpointName(); 538 if (!bp_name) 539 return; 540 std::lock_guard<std::recursive_mutex> guard( 541 m_impl_up->GetTarget()->GetAPIMutex()); 542 543 BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton)); 544 bp_name->GetOptions().SetCallback(SBBreakpointCallbackBaton 545 ::PrivateBreakpointHitCallback, 546 baton_sp, 547 false); 548 UpdateName(*bp_name); 549 } 550 551 void SBBreakpointName::SetScriptCallbackFunction( 552 const char *callback_function_name) { 553 LLDB_INSTRUMENT_VA(this, callback_function_name); 554 SBStructuredData empty_args; 555 SetScriptCallbackFunction(callback_function_name, empty_args); 556 } 557 558 SBError SBBreakpointName::SetScriptCallbackFunction( 559 const char *callback_function_name, 560 SBStructuredData &extra_args) { 561 LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args); 562 SBError sb_error; 563 BreakpointName *bp_name = GetBreakpointName(); 564 if (!bp_name) { 565 sb_error.SetErrorString("unrecognized breakpoint name"); 566 return sb_error; 567 } 568 569 std::lock_guard<std::recursive_mutex> guard( 570 m_impl_up->GetTarget()->GetAPIMutex()); 571 572 BreakpointOptions &bp_options = bp_name->GetOptions(); 573 Status error; 574 error = m_impl_up->GetTarget() 575 ->GetDebugger() 576 .GetScriptInterpreter() 577 ->SetBreakpointCommandCallbackFunction( 578 bp_options, callback_function_name, 579 extra_args.m_impl_up->GetObjectSP()); 580 sb_error.SetError(error); 581 UpdateName(*bp_name); 582 return sb_error; 583 } 584 585 SBError 586 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) { 587 LLDB_INSTRUMENT_VA(this, callback_body_text); 588 589 SBError sb_error; 590 BreakpointName *bp_name = GetBreakpointName(); 591 if (!bp_name) 592 return sb_error; 593 594 std::lock_guard<std::recursive_mutex> guard( 595 m_impl_up->GetTarget()->GetAPIMutex()); 596 597 BreakpointOptions &bp_options = bp_name->GetOptions(); 598 Status error = m_impl_up->GetTarget() 599 ->GetDebugger() 600 .GetScriptInterpreter() 601 ->SetBreakpointCommandCallback( 602 bp_options, callback_body_text, /*is_callback=*/false); 603 sb_error.SetError(error); 604 if (!sb_error.Fail()) 605 UpdateName(*bp_name); 606 607 return sb_error; 608 } 609 610 bool SBBreakpointName::GetAllowList() const { 611 LLDB_INSTRUMENT_VA(this); 612 613 BreakpointName *bp_name = GetBreakpointName(); 614 if (!bp_name) 615 return false; 616 return bp_name->GetPermissions().GetAllowList(); 617 } 618 619 void SBBreakpointName::SetAllowList(bool value) { 620 LLDB_INSTRUMENT_VA(this, value); 621 622 BreakpointName *bp_name = GetBreakpointName(); 623 if (!bp_name) 624 return; 625 bp_name->GetPermissions().SetAllowList(value); 626 } 627 628 bool SBBreakpointName::GetAllowDelete() { 629 LLDB_INSTRUMENT_VA(this); 630 631 BreakpointName *bp_name = GetBreakpointName(); 632 if (!bp_name) 633 return false; 634 return bp_name->GetPermissions().GetAllowDelete(); 635 } 636 637 void SBBreakpointName::SetAllowDelete(bool value) { 638 LLDB_INSTRUMENT_VA(this, value); 639 640 BreakpointName *bp_name = GetBreakpointName(); 641 if (!bp_name) 642 return; 643 bp_name->GetPermissions().SetAllowDelete(value); 644 } 645 646 bool SBBreakpointName::GetAllowDisable() { 647 LLDB_INSTRUMENT_VA(this); 648 649 BreakpointName *bp_name = GetBreakpointName(); 650 if (!bp_name) 651 return false; 652 return bp_name->GetPermissions().GetAllowDisable(); 653 } 654 655 void SBBreakpointName::SetAllowDisable(bool value) { 656 LLDB_INSTRUMENT_VA(this, value); 657 658 BreakpointName *bp_name = GetBreakpointName(); 659 if (!bp_name) 660 return; 661 bp_name->GetPermissions().SetAllowDisable(value); 662 } 663 664 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const 665 { 666 if (!IsValid()) 667 return nullptr; 668 return m_impl_up->GetBreakpointName(); 669 } 670