lldb/source/API/SBBreakpointName.cpp

   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(lldb::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 lldb::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 = Status::FromErrorString("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 = m_impl_up->GetTarget()
 574                      ->GetDebugger()
 575                      .GetScriptInterpreter()
 576                      ->SetBreakpointCommandCallbackFunction(
 577                          bp_options, callback_function_name,
 578                          extra_args.m_impl_up->GetObjectSP());
 579   sb_error.SetError(std::move(error));
 580   UpdateName(*bp_name);
 581   return sb_error;
 582 }
 583
 584 SBError
 585 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
 586   LLDB_INSTRUMENT_VA(this, callback_body_text);
 587
 588   SBError sb_error;
 589   BreakpointName *bp_name = GetBreakpointName();
 590   if (!bp_name)
 591     return sb_error;
 592
 593   std::lock_guard<std::recursive_mutex> guard(
 594         m_impl_up->GetTarget()->GetAPIMutex());
 595
 596   BreakpointOptions &bp_options = bp_name->GetOptions();
 597   Status error = m_impl_up->GetTarget()
 598                      ->GetDebugger()
 599                      .GetScriptInterpreter()
 600                      ->SetBreakpointCommandCallback(
 601                          bp_options, callback_body_text, /*is_callback=*/false);
 602   sb_error.SetError(std::move(error));
 603   if (!sb_error.Fail())
 604     UpdateName(*bp_name);
 605
 606   return sb_error;
 607 }
 608
 609 bool SBBreakpointName::GetAllowList() const {
 610   LLDB_INSTRUMENT_VA(this);
 611
 612   BreakpointName *bp_name = GetBreakpointName();
 613   if (!bp_name)
 614     return false;
 615   return bp_name->GetPermissions().GetAllowList();
 616 }
 617
 618 void SBBreakpointName::SetAllowList(bool value) {
 619   LLDB_INSTRUMENT_VA(this, value);
 620
 621   BreakpointName *bp_name = GetBreakpointName();
 622   if (!bp_name)
 623     return;
 624   bp_name->GetPermissions().SetAllowList(value);
 625 }
 626
 627 bool SBBreakpointName::GetAllowDelete() {
 628   LLDB_INSTRUMENT_VA(this);
 629
 630   BreakpointName *bp_name = GetBreakpointName();
 631   if (!bp_name)
 632     return false;
 633   return bp_name->GetPermissions().GetAllowDelete();
 634 }
 635
 636 void SBBreakpointName::SetAllowDelete(bool value) {
 637   LLDB_INSTRUMENT_VA(this, value);
 638
 639   BreakpointName *bp_name = GetBreakpointName();
 640   if (!bp_name)
 641     return;
 642   bp_name->GetPermissions().SetAllowDelete(value);
 643 }
 644
 645 bool SBBreakpointName::GetAllowDisable() {
 646   LLDB_INSTRUMENT_VA(this);
 647
 648   BreakpointName *bp_name = GetBreakpointName();
 649   if (!bp_name)
 650     return false;
 651   return bp_name->GetPermissions().GetAllowDisable();
 652 }
 653
 654 void SBBreakpointName::SetAllowDisable(bool value) {
 655   LLDB_INSTRUMENT_VA(this, value);
 656
 657   BreakpointName *bp_name = GetBreakpointName();
 658   if (!bp_name)
 659     return;
 660   bp_name->GetPermissions().SetAllowDisable(value);
 661 }
 662
 663 lldb_private::BreakpointName *SBBreakpointName::GetBreakpointName() const
 664 {
 665   if (!IsValid())
 666     return nullptr;
 667   return m_impl_up->GetBreakpointName();
 668 }