lldb/source/API/SBBreakpoint.cpp

   1 //===-- SBBreakpoint.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/SBBreakpoint.h"
  10 #include "lldb/API/SBBreakpointLocation.h"
  11 #include "lldb/API/SBDebugger.h"
  12 #include "lldb/API/SBEvent.h"
  13 #include "lldb/API/SBProcess.h"
  14 #include "lldb/API/SBStream.h"
  15 #include "lldb/API/SBStringList.h"
  16 #include "lldb/API/SBStructuredData.h"
  17 #include "lldb/API/SBThread.h"
  18 #include "lldb/Utility/Instrumentation.h"
  19
  20 #include "lldb/Breakpoint/Breakpoint.h"
  21 #include "lldb/Breakpoint/BreakpointIDList.h"
  22 #include "lldb/Breakpoint/BreakpointLocation.h"
  23 #include "lldb/Breakpoint/BreakpointResolver.h"
  24 #include "lldb/Breakpoint/BreakpointResolverScripted.h"
  25 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  26 #include "lldb/Core/Address.h"
  27 #include "lldb/Core/Debugger.h"
  28 #include "lldb/Core/StructuredDataImpl.h"
  29 #include "lldb/Interpreter/CommandInterpreter.h"
  30 #include "lldb/Interpreter/ScriptInterpreter.h"
  31 #include "lldb/Target/Process.h"
  32 #include "lldb/Target/SectionLoadList.h"
  33 #include "lldb/Target/Target.h"
  34 #include "lldb/Target/Thread.h"
  35 #include "lldb/Target/ThreadSpec.h"
  36 #include "lldb/Utility/Stream.h"
  37
  38 #include "SBBreakpointOptionCommon.h"
  39
  40 #include "lldb/lldb-enumerations.h"
  41
  42 #include "llvm/ADT/STLExtras.h"
  43
  44 using namespace lldb;
  45 using namespace lldb_private;
  46
  47 SBBreakpoint::SBBreakpoint() { LLDB_INSTRUMENT_VA(this); }
  48
  49 SBBreakpoint::SBBreakpoint(const SBBreakpoint &rhs)
  50     : m_opaque_wp(rhs.m_opaque_wp) {
  51   LLDB_INSTRUMENT_VA(this, rhs);
  52 }
  53
  54 SBBreakpoint::SBBreakpoint(const lldb::BreakpointSP &bp_sp)
  55     : m_opaque_wp(bp_sp) {
  56   LLDB_INSTRUMENT_VA(this, bp_sp);
  57 }
  58
  59 SBBreakpoint::~SBBreakpoint() = default;
  60
  61 const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
  62   LLDB_INSTRUMENT_VA(this, rhs);
  63
  64   m_opaque_wp = rhs.m_opaque_wp;
  65   return *this;
  66 }
  67
  68 bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
  69   LLDB_INSTRUMENT_VA(this, rhs);
  70
  71   return m_opaque_wp.lock() == rhs.m_opaque_wp.lock();
  72 }
  73
  74 bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) {
  75   LLDB_INSTRUMENT_VA(this, rhs);
  76
  77   return m_opaque_wp.lock() != rhs.m_opaque_wp.lock();
  78 }
  79
  80 SBTarget SBBreakpoint::GetTarget() const {
  81   LLDB_INSTRUMENT_VA(this);
  82
  83   BreakpointSP bkpt_sp = GetSP();
  84   if (bkpt_sp)
  85     return SBTarget(bkpt_sp->GetTargetSP());
  86
  87   return SBTarget();
  88 }
  89
  90 break_id_t SBBreakpoint::GetID() const {
  91   LLDB_INSTRUMENT_VA(this);
  92
  93   break_id_t break_id = LLDB_INVALID_BREAK_ID;
  94   BreakpointSP bkpt_sp = GetSP();
  95   if (bkpt_sp)
  96     break_id = bkpt_sp->GetID();
  97
  98   return break_id;
  99 }
 100
 101 bool SBBreakpoint::IsValid() const {
 102   LLDB_INSTRUMENT_VA(this);
 103   return this->operator bool();
 104 }
 105 SBBreakpoint::operator bool() const {
 106   LLDB_INSTRUMENT_VA(this);
 107
 108   BreakpointSP bkpt_sp = GetSP();
 109   if (!bkpt_sp)
 110     return false;
 111   else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
 112     return true;
 113   else
 114     return false;
 115 }
 116
 117 void SBBreakpoint::ClearAllBreakpointSites() {
 118   LLDB_INSTRUMENT_VA(this);
 119
 120   BreakpointSP bkpt_sp = GetSP();
 121   if (bkpt_sp) {
 122     std::lock_guard<std::recursive_mutex> guard(
 123         bkpt_sp->GetTarget().GetAPIMutex());
 124     bkpt_sp->ClearAllBreakpointSites();
 125   }
 126 }
 127
 128 SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
 129   LLDB_INSTRUMENT_VA(this, vm_addr);
 130
 131   SBBreakpointLocation sb_bp_location;
 132
 133   BreakpointSP bkpt_sp = GetSP();
 134   if (bkpt_sp) {
 135     if (vm_addr != LLDB_INVALID_ADDRESS) {
 136       std::lock_guard<std::recursive_mutex> guard(
 137           bkpt_sp->GetTarget().GetAPIMutex());
 138       Address address;
 139       Target &target = bkpt_sp->GetTarget();
 140       if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) {
 141         address.SetRawAddress(vm_addr);
 142       }
 143       sb_bp_location.SetLocation(bkpt_sp->FindLocationByAddress(address));
 144     }
 145   }
 146   return sb_bp_location;
 147 }
 148
 149 break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
 150   LLDB_INSTRUMENT_VA(this, vm_addr);
 151
 152   break_id_t break_id = LLDB_INVALID_BREAK_ID;
 153   BreakpointSP bkpt_sp = GetSP();
 154
 155   if (bkpt_sp && vm_addr != LLDB_INVALID_ADDRESS) {
 156     std::lock_guard<std::recursive_mutex> guard(
 157         bkpt_sp->GetTarget().GetAPIMutex());
 158     Address address;
 159     Target &target = bkpt_sp->GetTarget();
 160     if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address)) {
 161       address.SetRawAddress(vm_addr);
 162     }
 163     break_id = bkpt_sp->FindLocationIDByAddress(address);
 164   }
 165
 166   return break_id;
 167 }
 168
 169 SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
 170   LLDB_INSTRUMENT_VA(this, bp_loc_id);
 171
 172   SBBreakpointLocation sb_bp_location;
 173   BreakpointSP bkpt_sp = GetSP();
 174
 175   if (bkpt_sp) {
 176     std::lock_guard<std::recursive_mutex> guard(
 177         bkpt_sp->GetTarget().GetAPIMutex());
 178     sb_bp_location.SetLocation(bkpt_sp->FindLocationByID(bp_loc_id));
 179   }
 180
 181   return sb_bp_location;
 182 }
 183
 184 SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
 185   LLDB_INSTRUMENT_VA(this, index);
 186
 187   SBBreakpointLocation sb_bp_location;
 188   BreakpointSP bkpt_sp = GetSP();
 189
 190   if (bkpt_sp) {
 191     std::lock_guard<std::recursive_mutex> guard(
 192         bkpt_sp->GetTarget().GetAPIMutex());
 193     sb_bp_location.SetLocation(bkpt_sp->GetLocationAtIndex(index));
 194   }
 195
 196   return sb_bp_location;
 197 }
 198
 199 void SBBreakpoint::SetEnabled(bool enable) {
 200   LLDB_INSTRUMENT_VA(this, enable);
 201
 202   BreakpointSP bkpt_sp = GetSP();
 203
 204   if (bkpt_sp) {
 205     std::lock_guard<std::recursive_mutex> guard(
 206         bkpt_sp->GetTarget().GetAPIMutex());
 207     bkpt_sp->SetEnabled(enable);
 208   }
 209 }
 210
 211 bool SBBreakpoint::IsEnabled() {
 212   LLDB_INSTRUMENT_VA(this);
 213
 214   BreakpointSP bkpt_sp = GetSP();
 215   if (bkpt_sp) {
 216     std::lock_guard<std::recursive_mutex> guard(
 217         bkpt_sp->GetTarget().GetAPIMutex());
 218     return bkpt_sp->IsEnabled();
 219   } else
 220     return false;
 221 }
 222
 223 void SBBreakpoint::SetOneShot(bool one_shot) {
 224   LLDB_INSTRUMENT_VA(this, one_shot);
 225
 226   BreakpointSP bkpt_sp = GetSP();
 227
 228   if (bkpt_sp) {
 229     std::lock_guard<std::recursive_mutex> guard(
 230         bkpt_sp->GetTarget().GetAPIMutex());
 231     bkpt_sp->SetOneShot(one_shot);
 232   }
 233 }
 234
 235 bool SBBreakpoint::IsOneShot() const {
 236   LLDB_INSTRUMENT_VA(this);
 237
 238   BreakpointSP bkpt_sp = GetSP();
 239   if (bkpt_sp) {
 240     std::lock_guard<std::recursive_mutex> guard(
 241         bkpt_sp->GetTarget().GetAPIMutex());
 242     return bkpt_sp->IsOneShot();
 243   } else
 244     return false;
 245 }
 246
 247 bool SBBreakpoint::IsInternal() {
 248   LLDB_INSTRUMENT_VA(this);
 249
 250   BreakpointSP bkpt_sp = GetSP();
 251   if (bkpt_sp) {
 252     std::lock_guard<std::recursive_mutex> guard(
 253         bkpt_sp->GetTarget().GetAPIMutex());
 254     return bkpt_sp->IsInternal();
 255   } else
 256     return false;
 257 }
 258
 259 void SBBreakpoint::SetIgnoreCount(uint32_t count) {
 260   LLDB_INSTRUMENT_VA(this, count);
 261
 262   BreakpointSP bkpt_sp = GetSP();
 263
 264   if (bkpt_sp) {
 265     std::lock_guard<std::recursive_mutex> guard(
 266         bkpt_sp->GetTarget().GetAPIMutex());
 267     bkpt_sp->SetIgnoreCount(count);
 268   }
 269 }
 270
 271 void SBBreakpoint::SetCondition(const char *condition) {
 272   LLDB_INSTRUMENT_VA(this, condition);
 273
 274   BreakpointSP bkpt_sp = GetSP();
 275   if (bkpt_sp) {
 276     std::lock_guard<std::recursive_mutex> guard(
 277         bkpt_sp->GetTarget().GetAPIMutex());
 278     bkpt_sp->SetCondition(condition);
 279   }
 280 }
 281
 282 const char *SBBreakpoint::GetCondition() {
 283   LLDB_INSTRUMENT_VA(this);
 284
 285   BreakpointSP bkpt_sp = GetSP();
 286   if (!bkpt_sp)
 287     return nullptr;
 288
 289   std::lock_guard<std::recursive_mutex> guard(
 290       bkpt_sp->GetTarget().GetAPIMutex());
 291   return ConstString(bkpt_sp->GetConditionText()).GetCString();
 292 }
 293
 294 void SBBreakpoint::SetAutoContinue(bool auto_continue) {
 295   LLDB_INSTRUMENT_VA(this, auto_continue);
 296
 297   BreakpointSP bkpt_sp = GetSP();
 298   if (bkpt_sp) {
 299     std::lock_guard<std::recursive_mutex> guard(
 300         bkpt_sp->GetTarget().GetAPIMutex());
 301     bkpt_sp->SetAutoContinue(auto_continue);
 302   }
 303 }
 304
 305 bool SBBreakpoint::GetAutoContinue() {
 306   LLDB_INSTRUMENT_VA(this);
 307
 308   BreakpointSP bkpt_sp = GetSP();
 309   if (bkpt_sp) {
 310     std::lock_guard<std::recursive_mutex> guard(
 311         bkpt_sp->GetTarget().GetAPIMutex());
 312     return bkpt_sp->IsAutoContinue();
 313   }
 314   return false;
 315 }
 316
 317 uint32_t SBBreakpoint::GetHitCount() const {
 318   LLDB_INSTRUMENT_VA(this);
 319
 320   uint32_t count = 0;
 321   BreakpointSP bkpt_sp = GetSP();
 322   if (bkpt_sp) {
 323     std::lock_guard<std::recursive_mutex> guard(
 324         bkpt_sp->GetTarget().GetAPIMutex());
 325     count = bkpt_sp->GetHitCount();
 326   }
 327
 328   return count;
 329 }
 330
 331 uint32_t SBBreakpoint::GetIgnoreCount() const {
 332   LLDB_INSTRUMENT_VA(this);
 333
 334   uint32_t count = 0;
 335   BreakpointSP bkpt_sp = GetSP();
 336   if (bkpt_sp) {
 337     std::lock_guard<std::recursive_mutex> guard(
 338         bkpt_sp->GetTarget().GetAPIMutex());
 339     count = bkpt_sp->GetIgnoreCount();
 340   }
 341
 342   return count;
 343 }
 344
 345 void SBBreakpoint::SetThreadID(tid_t tid) {
 346   LLDB_INSTRUMENT_VA(this, tid);
 347
 348   BreakpointSP bkpt_sp = GetSP();
 349   if (bkpt_sp) {
 350     std::lock_guard<std::recursive_mutex> guard(
 351         bkpt_sp->GetTarget().GetAPIMutex());
 352     bkpt_sp->SetThreadID(tid);
 353   }
 354 }
 355
 356 tid_t SBBreakpoint::GetThreadID() {
 357   LLDB_INSTRUMENT_VA(this);
 358
 359   tid_t tid = LLDB_INVALID_THREAD_ID;
 360   BreakpointSP bkpt_sp = GetSP();
 361   if (bkpt_sp) {
 362     std::lock_guard<std::recursive_mutex> guard(
 363         bkpt_sp->GetTarget().GetAPIMutex());
 364     tid = bkpt_sp->GetThreadID();
 365   }
 366
 367   return tid;
 368 }
 369
 370 void SBBreakpoint::SetThreadIndex(uint32_t index) {
 371   LLDB_INSTRUMENT_VA(this, index);
 372
 373   BreakpointSP bkpt_sp = GetSP();
 374   if (bkpt_sp) {
 375     std::lock_guard<std::recursive_mutex> guard(
 376         bkpt_sp->GetTarget().GetAPIMutex());
 377     bkpt_sp->GetOptions().GetThreadSpec()->SetIndex(index);
 378   }
 379 }
 380
 381 uint32_t SBBreakpoint::GetThreadIndex() const {
 382   LLDB_INSTRUMENT_VA(this);
 383
 384   uint32_t thread_idx = UINT32_MAX;
 385   BreakpointSP bkpt_sp = GetSP();
 386   if (bkpt_sp) {
 387     std::lock_guard<std::recursive_mutex> guard(
 388         bkpt_sp->GetTarget().GetAPIMutex());
 389     const ThreadSpec *thread_spec =
 390         bkpt_sp->GetOptions().GetThreadSpecNoCreate();
 391     if (thread_spec != nullptr)
 392       thread_idx = thread_spec->GetIndex();
 393   }
 394
 395   return thread_idx;
 396 }
 397
 398 void SBBreakpoint::SetThreadName(const char *thread_name) {
 399   LLDB_INSTRUMENT_VA(this, thread_name);
 400
 401   BreakpointSP bkpt_sp = GetSP();
 402
 403   if (bkpt_sp) {
 404     std::lock_guard<std::recursive_mutex> guard(
 405         bkpt_sp->GetTarget().GetAPIMutex());
 406     bkpt_sp->GetOptions().GetThreadSpec()->SetName(thread_name);
 407   }
 408 }
 409
 410 const char *SBBreakpoint::GetThreadName() const {
 411   LLDB_INSTRUMENT_VA(this);
 412
 413   BreakpointSP bkpt_sp = GetSP();
 414   if (!bkpt_sp)
 415     return nullptr;
 416
 417   std::lock_guard<std::recursive_mutex> guard(
 418       bkpt_sp->GetTarget().GetAPIMutex());
 419   if (const ThreadSpec *thread_spec =
 420           bkpt_sp->GetOptions().GetThreadSpecNoCreate())
 421     return ConstString(thread_spec->GetName()).GetCString();
 422
 423   return nullptr;
 424 }
 425
 426 void SBBreakpoint::SetQueueName(const char *queue_name) {
 427   LLDB_INSTRUMENT_VA(this, queue_name);
 428
 429   BreakpointSP bkpt_sp = GetSP();
 430   if (bkpt_sp) {
 431     std::lock_guard<std::recursive_mutex> guard(
 432         bkpt_sp->GetTarget().GetAPIMutex());
 433     bkpt_sp->GetOptions().GetThreadSpec()->SetQueueName(queue_name);
 434   }
 435 }
 436
 437 const char *SBBreakpoint::GetQueueName() const {
 438   LLDB_INSTRUMENT_VA(this);
 439
 440   BreakpointSP bkpt_sp = GetSP();
 441   if (!bkpt_sp)
 442     return nullptr;
 443
 444   std::lock_guard<std::recursive_mutex> guard(
 445       bkpt_sp->GetTarget().GetAPIMutex());
 446   if (const ThreadSpec *thread_spec =
 447           bkpt_sp->GetOptions().GetThreadSpecNoCreate())
 448     return ConstString(thread_spec->GetQueueName()).GetCString();
 449
 450   return nullptr;
 451 }
 452
 453 size_t SBBreakpoint::GetNumResolvedLocations() const {
 454   LLDB_INSTRUMENT_VA(this);
 455
 456   size_t num_resolved = 0;
 457   BreakpointSP bkpt_sp = GetSP();
 458   if (bkpt_sp) {
 459     std::lock_guard<std::recursive_mutex> guard(
 460         bkpt_sp->GetTarget().GetAPIMutex());
 461     num_resolved = bkpt_sp->GetNumResolvedLocations();
 462   }
 463   return num_resolved;
 464 }
 465
 466 size_t SBBreakpoint::GetNumLocations() const {
 467   LLDB_INSTRUMENT_VA(this);
 468
 469   BreakpointSP bkpt_sp = GetSP();
 470   size_t num_locs = 0;
 471   if (bkpt_sp) {
 472     std::lock_guard<std::recursive_mutex> guard(
 473         bkpt_sp->GetTarget().GetAPIMutex());
 474     num_locs = bkpt_sp->GetNumLocations();
 475   }
 476   return num_locs;
 477 }
 478
 479 void SBBreakpoint::SetCommandLineCommands(SBStringList &commands) {
 480   LLDB_INSTRUMENT_VA(this, commands);
 481
 482   BreakpointSP bkpt_sp = GetSP();
 483   if (!bkpt_sp)
 484     return;
 485   if (commands.GetSize() == 0)
 486     return;
 487
 488   std::lock_guard<std::recursive_mutex> guard(
 489       bkpt_sp->GetTarget().GetAPIMutex());
 490   std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
 491       new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
 492
 493   bkpt_sp->GetOptions().SetCommandDataCallback(cmd_data_up);
 494 }
 495
 496 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
 497   LLDB_INSTRUMENT_VA(this, commands);
 498
 499   BreakpointSP bkpt_sp = GetSP();
 500   if (!bkpt_sp)
 501     return false;
 502   StringList command_list;
 503   bool has_commands =
 504       bkpt_sp->GetOptions().GetCommandLineCallbacks(command_list);
 505   if (has_commands)
 506     commands.AppendList(command_list);
 507   return has_commands;
 508 }
 509
 510 bool SBBreakpoint::GetDescription(SBStream &s) {
 511   LLDB_INSTRUMENT_VA(this, s);
 512
 513   return GetDescription(s, true);
 514 }
 515
 516 bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
 517   LLDB_INSTRUMENT_VA(this, s, include_locations);
 518
 519   BreakpointSP bkpt_sp = GetSP();
 520   if (bkpt_sp) {
 521     std::lock_guard<std::recursive_mutex> guard(
 522         bkpt_sp->GetTarget().GetAPIMutex());
 523     s.Printf("SBBreakpoint: id = %i, ", bkpt_sp->GetID());
 524     bkpt_sp->GetResolverDescription(s.get());
 525     bkpt_sp->GetFilterDescription(s.get());
 526     if (include_locations) {
 527       const size_t num_locations = bkpt_sp->GetNumLocations();
 528       s.Printf(", locations = %" PRIu64, (uint64_t)num_locations);
 529     }
 530     return true;
 531   }
 532   s.Printf("No value");
 533   return false;
 534 }
 535
 536 SBError SBBreakpoint::AddLocation(SBAddress &address) {
 537   LLDB_INSTRUMENT_VA(this, address);
 538
 539   BreakpointSP bkpt_sp = GetSP();
 540   SBError error;
 541
 542   if (!address.IsValid()) {
 543     error.SetErrorString("Can't add an invalid address.");
 544     return error;
 545   }
 546
 547   if (!bkpt_sp) {
 548     error.SetErrorString("No breakpoint to add a location to.");
 549     return error;
 550   }
 551
 552   if (!llvm::isa<BreakpointResolverScripted>(bkpt_sp->GetResolver().get())) {
 553     error.SetErrorString("Only a scripted resolver can add locations.");
 554     return error;
 555   }
 556
 557   if (bkpt_sp->GetSearchFilter()->AddressPasses(address.ref()))
 558     bkpt_sp->AddLocation(address.ref());
 559   else {
 560     StreamString s;
 561     address.get()->Dump(&s, &bkpt_sp->GetTarget(),
 562                         Address::DumpStyleModuleWithFileAddress);
 563     error.SetErrorStringWithFormat("Address: %s didn't pass the filter.",
 564                                    s.GetData());
 565   }
 566   return error;
 567 }
 568
 569 SBStructuredData SBBreakpoint::SerializeToStructuredData() {
 570   LLDB_INSTRUMENT_VA(this);
 571
 572   SBStructuredData data;
 573   BreakpointSP bkpt_sp = GetSP();
 574
 575   if (!bkpt_sp)
 576     return data;
 577
 578   StructuredData::ObjectSP bkpt_dict = bkpt_sp->SerializeToStructuredData();
 579   data.m_impl_up->SetObjectSP(bkpt_dict);
 580   return data;
 581 }
 582
 583 void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
 584   LLDB_INSTRUMENT_VA(this, callback, baton);
 585
 586   BreakpointSP bkpt_sp = GetSP();
 587
 588   if (bkpt_sp) {
 589     std::lock_guard<std::recursive_mutex> guard(
 590         bkpt_sp->GetTarget().GetAPIMutex());
 591     BatonSP baton_sp(new SBBreakpointCallbackBaton(callback, baton));
 592     bkpt_sp->SetCallback(SBBreakpointCallbackBaton
 593       ::PrivateBreakpointHitCallback, baton_sp,
 594                          false);
 595   }
 596 }
 597
 598 void SBBreakpoint::SetScriptCallbackFunction(
 599   const char *callback_function_name) {
 600   LLDB_INSTRUMENT_VA(this, callback_function_name);
 601   SBStructuredData empty_args;
 602   SetScriptCallbackFunction(callback_function_name, empty_args);
 603 }
 604
 605 SBError SBBreakpoint::SetScriptCallbackFunction(
 606     const char *callback_function_name,
 607     SBStructuredData &extra_args) {
 608   LLDB_INSTRUMENT_VA(this, callback_function_name, extra_args);
 609   SBError sb_error;
 610   BreakpointSP bkpt_sp = GetSP();
 611
 612   if (bkpt_sp) {
 613     Status error;
 614     std::lock_guard<std::recursive_mutex> guard(
 615         bkpt_sp->GetTarget().GetAPIMutex());
 616     BreakpointOptions &bp_options = bkpt_sp->GetOptions();
 617     error = bkpt_sp->GetTarget()
 618         .GetDebugger()
 619         .GetScriptInterpreter()
 620         ->SetBreakpointCommandCallbackFunction(bp_options,
 621                                                callback_function_name,
 622                                                extra_args.m_impl_up
 623                                                    ->GetObjectSP());
 624     sb_error.SetError(error);
 625   } else
 626     sb_error.SetErrorString("invalid breakpoint");
 627
 628   return sb_error;
 629 }
 630
 631 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
 632   LLDB_INSTRUMENT_VA(this, callback_body_text);
 633
 634   BreakpointSP bkpt_sp = GetSP();
 635
 636   SBError sb_error;
 637   if (bkpt_sp) {
 638     std::lock_guard<std::recursive_mutex> guard(
 639         bkpt_sp->GetTarget().GetAPIMutex());
 640     BreakpointOptions &bp_options = bkpt_sp->GetOptions();
 641     Status error =
 642         bkpt_sp->GetTarget()
 643             .GetDebugger()
 644             .GetScriptInterpreter()
 645             ->SetBreakpointCommandCallback(bp_options, callback_body_text,
 646                                            /*is_callback=*/false);
 647     sb_error.SetError(error);
 648   } else
 649     sb_error.SetErrorString("invalid breakpoint");
 650
 651   return sb_error;
 652 }
 653
 654 bool SBBreakpoint::AddName(const char *new_name) {
 655   LLDB_INSTRUMENT_VA(this, new_name);
 656
 657   SBError status = AddNameWithErrorHandling(new_name);
 658   return status.Success();
 659 }
 660
 661 SBError SBBreakpoint::AddNameWithErrorHandling(const char *new_name) {
 662   LLDB_INSTRUMENT_VA(this, new_name);
 663
 664   BreakpointSP bkpt_sp = GetSP();
 665
 666   SBError status;
 667   if (bkpt_sp) {
 668     std::lock_guard<std::recursive_mutex> guard(
 669         bkpt_sp->GetTarget().GetAPIMutex());
 670     Status error;
 671     bkpt_sp->GetTarget().AddNameToBreakpoint(bkpt_sp, new_name, error);
 672     status.SetError(error);
 673   } else {
 674     status.SetErrorString("invalid breakpoint");
 675   }
 676
 677   return status;
 678 }
 679
 680 void SBBreakpoint::RemoveName(const char *name_to_remove) {
 681   LLDB_INSTRUMENT_VA(this, name_to_remove);
 682
 683   BreakpointSP bkpt_sp = GetSP();
 684
 685   if (bkpt_sp) {
 686     std::lock_guard<std::recursive_mutex> guard(
 687         bkpt_sp->GetTarget().GetAPIMutex());
 688     bkpt_sp->GetTarget().RemoveNameFromBreakpoint(bkpt_sp,
 689                                                   ConstString(name_to_remove));
 690   }
 691 }
 692
 693 bool SBBreakpoint::MatchesName(const char *name) {
 694   LLDB_INSTRUMENT_VA(this, name);
 695
 696   BreakpointSP bkpt_sp = GetSP();
 697
 698   if (bkpt_sp) {
 699     std::lock_guard<std::recursive_mutex> guard(
 700         bkpt_sp->GetTarget().GetAPIMutex());
 701     return bkpt_sp->MatchesName(name);
 702   }
 703
 704   return false;
 705 }
 706
 707 void SBBreakpoint::GetNames(SBStringList &names) {
 708   LLDB_INSTRUMENT_VA(this, names);
 709
 710   BreakpointSP bkpt_sp = GetSP();
 711
 712   if (bkpt_sp) {
 713     std::lock_guard<std::recursive_mutex> guard(
 714         bkpt_sp->GetTarget().GetAPIMutex());
 715     std::vector<std::string> names_vec;
 716     bkpt_sp->GetNames(names_vec);
 717     for (std::string name : names_vec) {
 718       names.AppendString(name.c_str());
 719     }
 720   }
 721 }
 722
 723 bool SBBreakpoint::EventIsBreakpointEvent(const lldb::SBEvent &event) {
 724   LLDB_INSTRUMENT_VA(event);
 725
 726   return Breakpoint::BreakpointEventData::GetEventDataFromEvent(event.get()) !=
 727          nullptr;
 728 }
 729
 730 BreakpointEventType
 731 SBBreakpoint::GetBreakpointEventTypeFromEvent(const SBEvent &event) {
 732   LLDB_INSTRUMENT_VA(event);
 733
 734   if (event.IsValid())
 735     return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
 736         event.GetSP());
 737   return eBreakpointEventTypeInvalidType;
 738 }
 739
 740 SBBreakpoint SBBreakpoint::GetBreakpointFromEvent(const lldb::SBEvent &event) {
 741   LLDB_INSTRUMENT_VA(event);
 742
 743   if (event.IsValid())
 744     return SBBreakpoint(
 745         Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event.GetSP()));
 746   return SBBreakpoint();
 747 }
 748
 749 SBBreakpointLocation
 750 SBBreakpoint::GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
 751                                                     uint32_t loc_idx) {
 752   LLDB_INSTRUMENT_VA(event, loc_idx);
 753
 754   SBBreakpointLocation sb_breakpoint_loc;
 755   if (event.IsValid())
 756     sb_breakpoint_loc.SetLocation(
 757         Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
 758             event.GetSP(), loc_idx));
 759   return sb_breakpoint_loc;
 760 }
 761
 762 uint32_t
 763 SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
 764   LLDB_INSTRUMENT_VA(event);
 765
 766   uint32_t num_locations = 0;
 767   if (event.IsValid())
 768     num_locations =
 769         (Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
 770             event.GetSP()));
 771   return num_locations;
 772 }
 773
 774 bool SBBreakpoint::IsHardware() const {
 775   LLDB_INSTRUMENT_VA(this);
 776
 777   BreakpointSP bkpt_sp = GetSP();
 778   if (bkpt_sp)
 779     return bkpt_sp->IsHardware();
 780   return false;
 781 }
 782
 783 BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); }
 784
 785 // This is simple collection of breakpoint id's and their target.
 786 class SBBreakpointListImpl {
 787 public:
 788   SBBreakpointListImpl(lldb::TargetSP target_sp) {
 789     if (target_sp && target_sp->IsValid())
 790       m_target_wp = target_sp;
 791   }
 792
 793   ~SBBreakpointListImpl() = default;
 794
 795   size_t GetSize() { return m_break_ids.size(); }
 796
 797   BreakpointSP GetBreakpointAtIndex(size_t idx) {
 798     if (idx >= m_break_ids.size())
 799       return BreakpointSP();
 800     TargetSP target_sp = m_target_wp.lock();
 801     if (!target_sp)
 802       return BreakpointSP();
 803     lldb::break_id_t bp_id = m_break_ids[idx];
 804     return target_sp->GetBreakpointList().FindBreakpointByID(bp_id);
 805   }
 806
 807   BreakpointSP FindBreakpointByID(lldb::break_id_t desired_id) {
 808     TargetSP target_sp = m_target_wp.lock();
 809     if (!target_sp)
 810       return BreakpointSP();
 811
 812     for (lldb::break_id_t &break_id : m_break_ids) {
 813       if (break_id == desired_id)
 814         return target_sp->GetBreakpointList().FindBreakpointByID(break_id);
 815     }
 816     return BreakpointSP();
 817   }
 818
 819   bool Append(BreakpointSP bkpt) {
 820     TargetSP target_sp = m_target_wp.lock();
 821     if (!target_sp || !bkpt)
 822       return false;
 823     if (bkpt->GetTargetSP() != target_sp)
 824       return false;
 825     m_break_ids.push_back(bkpt->GetID());
 826     return true;
 827   }
 828
 829   bool AppendIfUnique(BreakpointSP bkpt) {
 830     TargetSP target_sp = m_target_wp.lock();
 831     if (!target_sp || !bkpt)
 832       return false;
 833     if (bkpt->GetTargetSP() != target_sp)
 834       return false;
 835     lldb::break_id_t bp_id = bkpt->GetID();
 836     if (!llvm::is_contained(m_break_ids, bp_id))
 837       return false;
 838
 839     m_break_ids.push_back(bkpt->GetID());
 840     return true;
 841   }
 842
 843   bool AppendByID(lldb::break_id_t id) {
 844     TargetSP target_sp = m_target_wp.lock();
 845     if (!target_sp)
 846       return false;
 847     if (id == LLDB_INVALID_BREAK_ID)
 848       return false;
 849     m_break_ids.push_back(id);
 850     return true;
 851   }
 852
 853   void Clear() { m_break_ids.clear(); }
 854
 855   void CopyToBreakpointIDList(lldb_private::BreakpointIDList &bp_list) {
 856     for (lldb::break_id_t id : m_break_ids) {
 857       bp_list.AddBreakpointID(BreakpointID(id));
 858     }
 859   }
 860
 861   TargetSP GetTarget() { return m_target_wp.lock(); }
 862
 863 private:
 864   std::vector<lldb::break_id_t> m_break_ids;
 865   TargetWP m_target_wp;
 866 };
 867
 868 SBBreakpointList::SBBreakpointList(SBTarget &target)
 869     : m_opaque_sp(new SBBreakpointListImpl(target.GetSP())) {
 870   LLDB_INSTRUMENT_VA(this, target);
 871 }
 872
 873 SBBreakpointList::~SBBreakpointList() = default;
 874
 875 size_t SBBreakpointList::GetSize() const {
 876   LLDB_INSTRUMENT_VA(this);
 877
 878   if (!m_opaque_sp)
 879     return 0;
 880   else
 881     return m_opaque_sp->GetSize();
 882 }
 883
 884 SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
 885   LLDB_INSTRUMENT_VA(this, idx);
 886
 887   if (!m_opaque_sp)
 888     return SBBreakpoint();
 889
 890   BreakpointSP bkpt_sp = m_opaque_sp->GetBreakpointAtIndex(idx);
 891   return SBBreakpoint(bkpt_sp);
 892 }
 893
 894 SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
 895   LLDB_INSTRUMENT_VA(this, id);
 896
 897   if (!m_opaque_sp)
 898     return SBBreakpoint();
 899   BreakpointSP bkpt_sp = m_opaque_sp->FindBreakpointByID(id);
 900   return SBBreakpoint(bkpt_sp);
 901 }
 902
 903 void SBBreakpointList::Append(const SBBreakpoint &sb_bkpt) {
 904   LLDB_INSTRUMENT_VA(this, sb_bkpt);
 905
 906   if (!sb_bkpt.IsValid())
 907     return;
 908   if (!m_opaque_sp)
 909     return;
 910   m_opaque_sp->Append(sb_bkpt.m_opaque_wp.lock());
 911 }
 912
 913 void SBBreakpointList::AppendByID(lldb::break_id_t id) {
 914   LLDB_INSTRUMENT_VA(this, id);
 915
 916   if (!m_opaque_sp)
 917     return;
 918   m_opaque_sp->AppendByID(id);
 919 }
 920
 921 bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {
 922   LLDB_INSTRUMENT_VA(this, sb_bkpt);
 923
 924   if (!sb_bkpt.IsValid())
 925     return false;
 926   if (!m_opaque_sp)
 927     return false;
 928   return m_opaque_sp->AppendIfUnique(sb_bkpt.GetSP());
 929 }
 930
 931 void SBBreakpointList::Clear() {
 932   LLDB_INSTRUMENT_VA(this);
 933
 934   if (m_opaque_sp)
 935     m_opaque_sp->Clear();
 936 }
 937
 938 void SBBreakpointList::CopyToBreakpointIDList(
 939     lldb_private::BreakpointIDList &bp_id_list) {
 940   if (m_opaque_sp)
 941     m_opaque_sp->CopyToBreakpointIDList(bp_id_list);
 942 }