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