1//===-- BreakpointLocation.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/Breakpoint/BreakpointLocation.h"
10#include "lldb/Breakpoint/BreakpointID.h"
11#include "lldb/Breakpoint/StoppointCallbackContext.h"
12#include "lldb/Core/Debugger.h"
13#include "lldb/Core/Module.h"
14#include "lldb/Core/ValueObject.h"
15#include "lldb/Expression/DiagnosticManager.h"
16#include "lldb/Expression/ExpressionVariable.h"
17#include "lldb/Expression/UserExpression.h"
18#include "lldb/Symbol/CompileUnit.h"
19#include "lldb/Symbol/Symbol.h"
20#include "lldb/Symbol/TypeSystem.h"
21#include "lldb/Target/Process.h"
22#include "lldb/Target/Target.h"
23#include "lldb/Target/Thread.h"
24#include "lldb/Target/ThreadSpec.h"
25#include "lldb/Utility/LLDBLog.h"
26#include "lldb/Utility/Log.h"
27#include "lldb/Utility/StreamString.h"
28
29using namespace lldb;
30using namespace lldb_private;
31
32BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner,
33                                       const Address &addr, lldb::tid_t tid,
34                                       bool hardware, bool check_for_resolver)
35    : m_being_created(true), m_should_resolve_indirect_functions(false),
36      m_is_reexported(false), m_is_indirect(false), m_address(addr),
37      m_owner(owner), m_condition_hash(0), m_loc_id(loc_id), m_hit_counter() {
38  if (check_for_resolver) {
39    Symbol *symbol = m_address.CalculateSymbolContextSymbol();
40    if (symbol && symbol->IsIndirect()) {
41      SetShouldResolveIndirectFunctions(true);
42    }
43  }
44
45  SetThreadID(tid);
46  m_being_created = false;
47}
48
49BreakpointLocation::~BreakpointLocation() { ClearBreakpointSite(); }
50
51lldb::addr_t BreakpointLocation::GetLoadAddress() const {
52  return m_address.GetOpcodeLoadAddress(&m_owner.GetTarget());
53}
54
55const BreakpointOptions &BreakpointLocation::GetOptionsSpecifyingKind(
56    BreakpointOptions::OptionKind kind) const {
57  if (m_options_up && m_options_up->IsOptionSet(kind))
58    return *m_options_up;
59  else
60    return m_owner.GetOptions();
61}
62
63Address &BreakpointLocation::GetAddress() { return m_address; }
64
65Breakpoint &BreakpointLocation::GetBreakpoint() { return m_owner; }
66
67Target &BreakpointLocation::GetTarget() { return m_owner.GetTarget(); }
68
69bool BreakpointLocation::IsEnabled() const {
70  if (!m_owner.IsEnabled())
71    return false;
72  else if (m_options_up != nullptr)
73    return m_options_up->IsEnabled();
74  else
75    return true;
76}
77
78void BreakpointLocation::SetEnabled(bool enabled) {
79  GetLocationOptions().SetEnabled(enabled);
80  if (enabled) {
81    ResolveBreakpointSite();
82  } else {
83    ClearBreakpointSite();
84  }
85  SendBreakpointLocationChangedEvent(enabled ? eBreakpointEventTypeEnabled
86                                             : eBreakpointEventTypeDisabled);
87}
88
89bool BreakpointLocation::IsAutoContinue() const {
90  if (m_options_up &&
91      m_options_up->IsOptionSet(BreakpointOptions::eAutoContinue))
92    return m_options_up->IsAutoContinue();
93  else
94    return m_owner.IsAutoContinue();
95}
96
97void BreakpointLocation::SetAutoContinue(bool auto_continue) {
98  GetLocationOptions().SetAutoContinue(auto_continue);
99  SendBreakpointLocationChangedEvent(eBreakpointEventTypeAutoContinueChanged);
100}
101
102void BreakpointLocation::SetThreadID(lldb::tid_t thread_id) {
103  if (thread_id != LLDB_INVALID_THREAD_ID)
104    GetLocationOptions().SetThreadID(thread_id);
105  else {
106    // If we're resetting this to an invalid thread id, then don't make an
107    // options pointer just to do that.
108    if (m_options_up != nullptr)
109      m_options_up->SetThreadID(thread_id);
110  }
111  SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
112}
113
114lldb::tid_t BreakpointLocation::GetThreadID() {
115  const ThreadSpec *thread_spec =
116      GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
117          .GetThreadSpecNoCreate();
118  if (thread_spec)
119    return thread_spec->GetTID();
120  else
121    return LLDB_INVALID_THREAD_ID;
122}
123
124void BreakpointLocation::SetThreadIndex(uint32_t index) {
125  if (index != 0)
126    GetLocationOptions().GetThreadSpec()->SetIndex(index);
127  else {
128    // If we're resetting this to an invalid thread id, then don't make an
129    // options pointer just to do that.
130    if (m_options_up != nullptr)
131      m_options_up->GetThreadSpec()->SetIndex(index);
132  }
133  SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
134}
135
136uint32_t BreakpointLocation::GetThreadIndex() const {
137  const ThreadSpec *thread_spec =
138      GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
139          .GetThreadSpecNoCreate();
140  if (thread_spec)
141    return thread_spec->GetIndex();
142  else
143    return 0;
144}
145
146void BreakpointLocation::SetThreadName(const char *thread_name) {
147  if (thread_name != nullptr)
148    GetLocationOptions().GetThreadSpec()->SetName(thread_name);
149  else {
150    // If we're resetting this to an invalid thread id, then don't make an
151    // options pointer just to do that.
152    if (m_options_up != nullptr)
153      m_options_up->GetThreadSpec()->SetName(thread_name);
154  }
155  SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
156}
157
158const char *BreakpointLocation::GetThreadName() const {
159  const ThreadSpec *thread_spec =
160      GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
161          .GetThreadSpecNoCreate();
162  if (thread_spec)
163    return thread_spec->GetName();
164  else
165    return nullptr;
166}
167
168void BreakpointLocation::SetQueueName(const char *queue_name) {
169  if (queue_name != nullptr)
170    GetLocationOptions().GetThreadSpec()->SetQueueName(queue_name);
171  else {
172    // If we're resetting this to an invalid thread id, then don't make an
173    // options pointer just to do that.
174    if (m_options_up != nullptr)
175      m_options_up->GetThreadSpec()->SetQueueName(queue_name);
176  }
177  SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged);
178}
179
180const char *BreakpointLocation::GetQueueName() const {
181  const ThreadSpec *thread_spec =
182      GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
183          .GetThreadSpecNoCreate();
184  if (thread_spec)
185    return thread_spec->GetQueueName();
186  else
187    return nullptr;
188}
189
190bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) {
191  if (m_options_up != nullptr && m_options_up->HasCallback())
192    return m_options_up->InvokeCallback(context, m_owner.GetID(), GetID());
193  else
194    return m_owner.InvokeCallback(context, GetID());
195}
196
197bool BreakpointLocation::IsCallbackSynchronous() {
198  if (m_options_up != nullptr && m_options_up->HasCallback())
199    return m_options_up->IsCallbackSynchronous();
200  else
201    return m_owner.GetOptions().IsCallbackSynchronous();
202}
203
204void BreakpointLocation::SetCallback(BreakpointHitCallback callback,
205                                     void *baton, bool is_synchronous) {
206  // The default "Baton" class will keep a copy of "baton" and won't free or
207  // delete it when it goes out of scope.
208  GetLocationOptions().SetCallback(
209      callback, std::make_shared<UntypedBaton>(baton), is_synchronous);
210  SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged);
211}
212
213void BreakpointLocation::SetCallback(BreakpointHitCallback callback,
214                                     const BatonSP &baton_sp,
215                                     bool is_synchronous) {
216  GetLocationOptions().SetCallback(callback, baton_sp, is_synchronous);
217  SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged);
218}
219
220void BreakpointLocation::ClearCallback() {
221  GetLocationOptions().ClearCallback();
222}
223
224void BreakpointLocation::SetCondition(const char *condition) {
225  GetLocationOptions().SetCondition(condition);
226  SendBreakpointLocationChangedEvent(eBreakpointEventTypeConditionChanged);
227}
228
229const char *BreakpointLocation::GetConditionText(size_t *hash) const {
230  return GetOptionsSpecifyingKind(BreakpointOptions::eCondition)
231      .GetConditionText(hash);
232}
233
234bool BreakpointLocation::ConditionSaysStop(ExecutionContext &exe_ctx,
235                                           Status &error) {
236  Log *log = GetLog(LLDBLog::Breakpoints);
237
238  std::lock_guard<std::mutex> guard(m_condition_mutex);
239
240  size_t condition_hash;
241  const char *condition_text = GetConditionText(&condition_hash);
242
243  if (!condition_text) {
244    m_user_expression_sp.reset();
245    return false;
246  }
247
248  error.Clear();
249
250  DiagnosticManager diagnostics;
251
252  if (condition_hash != m_condition_hash || !m_user_expression_sp ||
253      !m_user_expression_sp->IsParseCacheable() ||
254      !m_user_expression_sp->MatchesContext(exe_ctx)) {
255    LanguageType language = eLanguageTypeUnknown;
256    // See if we can figure out the language from the frame, otherwise use the
257    // default language:
258    CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit();
259    if (comp_unit)
260      language = comp_unit->GetLanguage();
261
262    m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage(
263        condition_text, llvm::StringRef(), language, Expression::eResultTypeAny,
264        EvaluateExpressionOptions(), nullptr, error));
265    if (error.Fail()) {
266      LLDB_LOGF(log, "Error getting condition expression: %s.",
267                error.AsCString());
268      m_user_expression_sp.reset();
269      return true;
270    }
271
272    if (!m_user_expression_sp->Parse(diagnostics, exe_ctx,
273                                     eExecutionPolicyOnlyWhenNeeded, true,
274                                     false)) {
275      error.SetErrorStringWithFormat(
276          "Couldn't parse conditional expression:\n%s",
277          diagnostics.GetString().c_str());
278      m_user_expression_sp.reset();
279      return true;
280    }
281
282    m_condition_hash = condition_hash;
283  }
284
285  // We need to make sure the user sees any parse errors in their condition, so
286  // we'll hook the constructor errors up to the debugger's Async I/O.
287
288  ValueObjectSP result_value_sp;
289
290  EvaluateExpressionOptions options;
291  options.SetUnwindOnError(true);
292  options.SetIgnoreBreakpoints(true);
293  options.SetTryAllThreads(true);
294  options.SetSuppressPersistentResult(
295      true); // Don't generate a user variable for condition expressions.
296
297  Status expr_error;
298
299  diagnostics.Clear();
300
301  ExpressionVariableSP result_variable_sp;
302
303  ExpressionResults result_code = m_user_expression_sp->Execute(
304      diagnostics, exe_ctx, options, m_user_expression_sp, result_variable_sp);
305
306  bool ret;
307
308  if (result_code == eExpressionCompleted) {
309    if (!result_variable_sp) {
310      error.SetErrorString("Expression did not return a result");
311      return false;
312    }
313
314    result_value_sp = result_variable_sp->GetValueObject();
315
316    if (result_value_sp) {
317      ret = result_value_sp->IsLogicalTrue(error);
318      if (log) {
319        if (error.Success()) {
320          LLDB_LOGF(log, "Condition successfully evaluated, result is %s.\n",
321                    ret ? "true" : "false");
322        } else {
323          error.SetErrorString(
324              "Failed to get an integer result from the expression");
325          ret = false;
326        }
327      }
328    } else {
329      ret = false;
330      error.SetErrorString("Failed to get any result from the expression");
331    }
332  } else {
333    ret = false;
334    error.SetErrorStringWithFormat("Couldn't execute expression:\n%s",
335                                   diagnostics.GetString().c_str());
336  }
337
338  return ret;
339}
340
341uint32_t BreakpointLocation::GetIgnoreCount() const {
342  return GetOptionsSpecifyingKind(BreakpointOptions::eIgnoreCount)
343      .GetIgnoreCount();
344}
345
346void BreakpointLocation::SetIgnoreCount(uint32_t n) {
347  GetLocationOptions().SetIgnoreCount(n);
348  SendBreakpointLocationChangedEvent(eBreakpointEventTypeIgnoreChanged);
349}
350
351void BreakpointLocation::DecrementIgnoreCount() {
352  if (m_options_up != nullptr) {
353    uint32_t loc_ignore = m_options_up->GetIgnoreCount();
354    if (loc_ignore != 0)
355      m_options_up->SetIgnoreCount(loc_ignore - 1);
356  }
357}
358
359bool BreakpointLocation::IgnoreCountShouldStop() {
360  uint32_t owner_ignore = GetBreakpoint().GetIgnoreCount();
361  uint32_t loc_ignore = 0;
362  if (m_options_up != nullptr)
363    loc_ignore = m_options_up->GetIgnoreCount();
364
365  if (loc_ignore != 0 || owner_ignore != 0) {
366    m_owner.DecrementIgnoreCount();
367    DecrementIgnoreCount(); // Have to decrement our owners' ignore count,
368                            // since it won't get a chance to.
369    return false;
370  }
371  return true;
372}
373
374BreakpointOptions &BreakpointLocation::GetLocationOptions() {
375  // If we make the copy we don't copy the callbacks because that is
376  // potentially expensive and we don't want to do that for the simple case
377  // where someone is just disabling the location.
378  if (m_options_up == nullptr)
379    m_options_up = std::make_unique<BreakpointOptions>(false);
380
381  return *m_options_up;
382}
383
384bool BreakpointLocation::ValidForThisThread(Thread &thread) {
385  return thread.MatchesSpec(
386      GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
387          .GetThreadSpecNoCreate());
388}
389
390// RETURNS - true if we should stop at this breakpoint, false if we
391// should continue.  Note, we don't check the thread spec for the breakpoint
392// here, since if the breakpoint is not for this thread, then the event won't
393// even get reported, so the check is redundant.
394
395bool BreakpointLocation::ShouldStop(StoppointCallbackContext *context) {
396  bool should_stop = true;
397  Log *log = GetLog(LLDBLog::Breakpoints);
398
399  // Do this first, if a location is disabled, it shouldn't increment its hit
400  // count.
401  if (!IsEnabled())
402    return false;
403
404  // We only run synchronous callbacks in ShouldStop:
405  context->is_synchronous = true;
406  should_stop = InvokeCallback(context);
407
408  if (log) {
409    StreamString s;
410    GetDescription(&s, lldb::eDescriptionLevelVerbose);
411    LLDB_LOGF(log, "Hit breakpoint location: %s, %s.\n", s.GetData(),
412              should_stop ? "stopping" : "continuing");
413  }
414
415  return should_stop;
416}
417
418void BreakpointLocation::BumpHitCount() {
419  if (IsEnabled()) {
420    // Step our hit count, and also step the hit count of the owner.
421    m_hit_counter.Increment();
422    m_owner.m_hit_counter.Increment();
423  }
424}
425
426void BreakpointLocation::UndoBumpHitCount() {
427  if (IsEnabled()) {
428    // Step our hit count, and also step the hit count of the owner.
429    m_hit_counter.Decrement();
430    m_owner.m_hit_counter.Decrement();
431  }
432}
433
434bool BreakpointLocation::IsResolved() const {
435  return m_bp_site_sp.get() != nullptr;
436}
437
438lldb::BreakpointSiteSP BreakpointLocation::GetBreakpointSite() const {
439  return m_bp_site_sp;
440}
441
442bool BreakpointLocation::ResolveBreakpointSite() {
443  if (m_bp_site_sp)
444    return true;
445
446  Process *process = m_owner.GetTarget().GetProcessSP().get();
447  if (process == nullptr)
448    return false;
449
450  lldb::break_id_t new_id =
451      process->CreateBreakpointSite(shared_from_this(), m_owner.IsHardware());
452
453  if (new_id == LLDB_INVALID_BREAK_ID) {
454    Log *log = GetLog(LLDBLog::Breakpoints);
455    if (log)
456      log->Warning("Failed to add breakpoint site at 0x%" PRIx64,
457                   m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()));
458  }
459
460  return IsResolved();
461}
462
463bool BreakpointLocation::SetBreakpointSite(BreakpointSiteSP &bp_site_sp) {
464  m_bp_site_sp = bp_site_sp;
465  SendBreakpointLocationChangedEvent(eBreakpointEventTypeLocationsResolved);
466  return true;
467}
468
469bool BreakpointLocation::ClearBreakpointSite() {
470  if (m_bp_site_sp.get()) {
471    ProcessSP process_sp(m_owner.GetTarget().GetProcessSP());
472    // If the process exists, get it to remove the owner, it will remove the
473    // physical implementation of the breakpoint as well if there are no more
474    // owners.  Otherwise just remove this owner.
475    if (process_sp)
476      process_sp->RemoveConstituentFromBreakpointSite(GetBreakpoint().GetID(),
477                                                      GetID(), m_bp_site_sp);
478    else
479      m_bp_site_sp->RemoveConstituent(GetBreakpoint().GetID(), GetID());
480
481    m_bp_site_sp.reset();
482    return true;
483  }
484  return false;
485}
486
487void BreakpointLocation::GetDescription(Stream *s,
488                                        lldb::DescriptionLevel level) {
489  SymbolContext sc;
490
491  // If the description level is "initial" then the breakpoint is printing out
492  // our initial state, and we should let it decide how it wants to print our
493  // label.
494  if (level != eDescriptionLevelInitial) {
495    s->Indent();
496    BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID());
497  }
498
499  if (level == lldb::eDescriptionLevelBrief)
500    return;
501
502  if (level != eDescriptionLevelInitial)
503    s->PutCString(": ");
504
505  if (level == lldb::eDescriptionLevelVerbose)
506    s->IndentMore();
507
508  if (m_address.IsSectionOffset()) {
509    m_address.CalculateSymbolContext(&sc);
510
511    if (level == lldb::eDescriptionLevelFull ||
512        level == eDescriptionLevelInitial) {
513      if (IsReExported())
514        s->PutCString("re-exported target = ");
515      else
516        s->PutCString("where = ");
517      sc.DumpStopContext(s, m_owner.GetTarget().GetProcessSP().get(), m_address,
518                         false, true, false, true, true);
519    } else {
520      if (sc.module_sp) {
521        s->EOL();
522        s->Indent("module = ");
523        sc.module_sp->GetFileSpec().Dump(s->AsRawOstream());
524      }
525
526      if (sc.comp_unit != nullptr) {
527        s->EOL();
528        s->Indent("compile unit = ");
529        sc.comp_unit->GetPrimaryFile().GetFilename().Dump(s);
530
531        if (sc.function != nullptr) {
532          s->EOL();
533          s->Indent("function = ");
534          s->PutCString(sc.function->GetName().AsCString("<unknown>"));
535        }
536
537        if (sc.line_entry.line > 0) {
538          s->EOL();
539          s->Indent("location = ");
540          sc.line_entry.DumpStopContext(s, true);
541        }
542
543      } else {
544        // If we don't have a comp unit, see if we have a symbol we can print.
545        if (sc.symbol) {
546          s->EOL();
547          if (IsReExported())
548            s->Indent("re-exported target = ");
549          else
550            s->Indent("symbol = ");
551          s->PutCString(sc.symbol->GetName().AsCString("<unknown>"));
552        }
553      }
554    }
555  }
556
557  if (level == lldb::eDescriptionLevelVerbose) {
558    s->EOL();
559    s->Indent();
560  }
561
562  if (m_address.IsSectionOffset() &&
563      (level == eDescriptionLevelFull || level == eDescriptionLevelInitial))
564    s->Printf(", ");
565  s->Printf("address = ");
566
567  ExecutionContextScope *exe_scope = nullptr;
568  Target *target = &m_owner.GetTarget();
569  if (target)
570    exe_scope = target->GetProcessSP().get();
571  if (exe_scope == nullptr)
572    exe_scope = target;
573
574  if (level == eDescriptionLevelInitial)
575    m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress,
576                   Address::DumpStyleFileAddress);
577  else
578    m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress,
579                   Address::DumpStyleModuleWithFileAddress);
580
581  if (IsIndirect() && m_bp_site_sp) {
582    Address resolved_address;
583    resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target);
584    Symbol *resolved_symbol = resolved_address.CalculateSymbolContextSymbol();
585    if (resolved_symbol) {
586      if (level == eDescriptionLevelFull || level == eDescriptionLevelInitial)
587        s->Printf(", ");
588      else if (level == lldb::eDescriptionLevelVerbose) {
589        s->EOL();
590        s->Indent();
591      }
592      s->Printf("indirect target = %s",
593                resolved_symbol->GetName().GetCString());
594    }
595  }
596
597  bool is_resolved = IsResolved();
598  bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
599
600  if (level == lldb::eDescriptionLevelVerbose) {
601    s->EOL();
602    s->Indent();
603    s->Printf("resolved = %s\n", is_resolved ? "true" : "false");
604    s->Indent();
605    s->Printf("hardware = %s\n", is_hardware ? "true" : "false");
606    s->Indent();
607    s->Printf("hit count = %-4u\n", GetHitCount());
608
609    if (m_options_up) {
610      s->Indent();
611      m_options_up->GetDescription(s, level);
612      s->EOL();
613    }
614    s->IndentLess();
615  } else if (level != eDescriptionLevelInitial) {
616    s->Printf(", %sresolved, %shit count = %u ", (is_resolved ? "" : "un"),
617              (is_hardware ? "hardware, " : ""), GetHitCount());
618    if (m_options_up) {
619      m_options_up->GetDescription(s, level);
620    }
621  }
622}
623
624void BreakpointLocation::Dump(Stream *s) const {
625  if (s == nullptr)
626    return;
627
628  bool is_resolved = IsResolved();
629  bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
630
631  lldb::tid_t tid = GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
632                        .GetThreadSpecNoCreate()
633                        ->GetTID();
634  s->Printf("BreakpointLocation %u: tid = %4.4" PRIx64
635            "  load addr = 0x%8.8" PRIx64 "  state = %s  type = %s breakpoint  "
636            "hit_count = %-4u  ignore_count = %-4u",
637            GetID(), tid,
638            (uint64_t)m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()),
639            (m_options_up ? m_options_up->IsEnabled() : m_owner.IsEnabled())
640                ? "enabled "
641                : "disabled",
642            is_hardware ? "hardware" : "software", GetHitCount(),
643            GetOptionsSpecifyingKind(BreakpointOptions::eIgnoreCount)
644                .GetIgnoreCount());
645}
646
647void BreakpointLocation::SendBreakpointLocationChangedEvent(
648    lldb::BreakpointEventType eventKind) {
649  if (!m_being_created && !m_owner.IsInternal() &&
650      m_owner.GetTarget().EventTypeHasListeners(
651          Target::eBroadcastBitBreakpointChanged)) {
652    auto data_sp = std::make_shared<Breakpoint::BreakpointEventData>(
653        eventKind, m_owner.shared_from_this());
654    data_sp->GetBreakpointLocationCollection().Add(shared_from_this());
655    m_owner.GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
656                                       data_sp);
657  }
658}
659
660void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) {
661  m_address = swap_from->m_address;
662  m_should_resolve_indirect_functions =
663      swap_from->m_should_resolve_indirect_functions;
664  m_is_reexported = swap_from->m_is_reexported;
665  m_is_indirect = swap_from->m_is_indirect;
666  m_user_expression_sp.reset();
667}
668