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 
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     : 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 
49 BreakpointLocation::~BreakpointLocation() { ClearBreakpointSite(); }
50 
51 lldb::addr_t BreakpointLocation::GetLoadAddress() const {
52   return m_address.GetOpcodeLoadAddress(&m_owner.GetTarget());
53 }
54 
55 const 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 
63 Address &BreakpointLocation::GetAddress() { return m_address; }
64 
65 Breakpoint &BreakpointLocation::GetBreakpoint() { return m_owner; }
66 
67 Target &BreakpointLocation::GetTarget() { return m_owner.GetTarget(); }
68 
69 bool 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 
78 void 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 
89 bool 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 
97 void BreakpointLocation::SetAutoContinue(bool auto_continue) {
98   GetLocationOptions().SetAutoContinue(auto_continue);
99   SendBreakpointLocationChangedEvent(eBreakpointEventTypeAutoContinueChanged);
100 }
101 
102 void 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 
114 lldb::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 
124 void 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 
136 uint32_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 
146 void 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 
158 const 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 
168 void 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 
180 const 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 
190 bool 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 
197 bool 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 
204 void 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 goes out of scope.
208   GetLocationOptions().SetCallback(
209       callback, std::make_shared<UntypedBaton>(baton), is_synchronous);
210   SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged);
211 }
212 
213 void 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 
220 void BreakpointLocation::ClearCallback() {
221   GetLocationOptions().ClearCallback();
222 }
223 
224 void BreakpointLocation::SetCondition(const char *condition) {
225   GetLocationOptions().SetCondition(condition);
226   SendBreakpointLocationChangedEvent(eBreakpointEventTypeConditionChanged);
227 }
228 
229 const char *BreakpointLocation::GetConditionText(size_t *hash) const {
230   return GetOptionsSpecifyingKind(BreakpointOptions::eCondition)
231       .GetConditionText(hash);
232 }
233 
234 bool 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->MatchesContext(exe_ctx)) {
254     LanguageType language = eLanguageTypeUnknown;
255     // See if we can figure out the language from the frame, otherwise use the
256     // default language:
257     CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit();
258     if (comp_unit)
259       language = comp_unit->GetLanguage();
260 
261     m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage(
262         condition_text, llvm::StringRef(), language, Expression::eResultTypeAny,
263         EvaluateExpressionOptions(), nullptr, error));
264     if (error.Fail()) {
265       LLDB_LOGF(log, "Error getting condition expression: %s.",
266                 error.AsCString());
267       m_user_expression_sp.reset();
268       return true;
269     }
270 
271     if (!m_user_expression_sp->Parse(diagnostics, exe_ctx,
272                                      eExecutionPolicyOnlyWhenNeeded, true,
273                                      false)) {
274       error.SetErrorStringWithFormat(
275           "Couldn't parse conditional expression:\n%s",
276           diagnostics.GetString().c_str());
277       m_user_expression_sp.reset();
278       return true;
279     }
280 
281     m_condition_hash = condition_hash;
282   }
283 
284   // We need to make sure the user sees any parse errors in their condition, so
285   // we'll hook the constructor errors up to the debugger's Async I/O.
286 
287   ValueObjectSP result_value_sp;
288 
289   EvaluateExpressionOptions options;
290   options.SetUnwindOnError(true);
291   options.SetIgnoreBreakpoints(true);
292   options.SetTryAllThreads(true);
293   options.SetSuppressPersistentResult(
294       true); // Don't generate a user variable for condition expressions.
295 
296   Status expr_error;
297 
298   diagnostics.Clear();
299 
300   ExpressionVariableSP result_variable_sp;
301 
302   ExpressionResults result_code = m_user_expression_sp->Execute(
303       diagnostics, exe_ctx, options, m_user_expression_sp, result_variable_sp);
304 
305   bool ret;
306 
307   if (result_code == eExpressionCompleted) {
308     if (!result_variable_sp) {
309       error.SetErrorString("Expression did not return a result");
310       return false;
311     }
312 
313     result_value_sp = result_variable_sp->GetValueObject();
314 
315     if (result_value_sp) {
316       ret = result_value_sp->IsLogicalTrue(error);
317       if (log) {
318         if (error.Success()) {
319           LLDB_LOGF(log, "Condition successfully evaluated, result is %s.\n",
320                     ret ? "true" : "false");
321         } else {
322           error.SetErrorString(
323               "Failed to get an integer result from the expression");
324           ret = false;
325         }
326       }
327     } else {
328       ret = false;
329       error.SetErrorString("Failed to get any result from the expression");
330     }
331   } else {
332     ret = false;
333     error.SetErrorStringWithFormat("Couldn't execute expression:\n%s",
334                                    diagnostics.GetString().c_str());
335   }
336 
337   return ret;
338 }
339 
340 uint32_t BreakpointLocation::GetIgnoreCount() const {
341   return GetOptionsSpecifyingKind(BreakpointOptions::eIgnoreCount)
342       .GetIgnoreCount();
343 }
344 
345 void BreakpointLocation::SetIgnoreCount(uint32_t n) {
346   GetLocationOptions().SetIgnoreCount(n);
347   SendBreakpointLocationChangedEvent(eBreakpointEventTypeIgnoreChanged);
348 }
349 
350 void BreakpointLocation::DecrementIgnoreCount() {
351   if (m_options_up != nullptr) {
352     uint32_t loc_ignore = m_options_up->GetIgnoreCount();
353     if (loc_ignore != 0)
354       m_options_up->SetIgnoreCount(loc_ignore - 1);
355   }
356 }
357 
358 bool BreakpointLocation::IgnoreCountShouldStop() {
359   uint32_t owner_ignore = GetBreakpoint().GetIgnoreCount();
360   uint32_t loc_ignore = 0;
361   if (m_options_up != nullptr)
362     loc_ignore = m_options_up->GetIgnoreCount();
363 
364   if (loc_ignore != 0 || owner_ignore != 0) {
365     m_owner.DecrementIgnoreCount();
366     DecrementIgnoreCount(); // Have to decrement our owners' ignore count,
367                             // since it won't get a chance to.
368     return false;
369   }
370   return true;
371 }
372 
373 BreakpointOptions &BreakpointLocation::GetLocationOptions() {
374   // If we make the copy we don't copy the callbacks because that is
375   // potentially expensive and we don't want to do that for the simple case
376   // where someone is just disabling the location.
377   if (m_options_up == nullptr)
378     m_options_up = std::make_unique<BreakpointOptions>(false);
379 
380   return *m_options_up;
381 }
382 
383 bool BreakpointLocation::ValidForThisThread(Thread &thread) {
384   return thread.MatchesSpec(
385       GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
386           .GetThreadSpecNoCreate());
387 }
388 
389 // RETURNS - true if we should stop at this breakpoint, false if we
390 // should continue.  Note, we don't check the thread spec for the breakpoint
391 // here, since if the breakpoint is not for this thread, then the event won't
392 // even get reported, so the check is redundant.
393 
394 bool BreakpointLocation::ShouldStop(StoppointCallbackContext *context) {
395   bool should_stop = true;
396   Log *log = GetLog(LLDBLog::Breakpoints);
397 
398   // Do this first, if a location is disabled, it shouldn't increment its hit
399   // count.
400   if (!IsEnabled())
401     return false;
402 
403   // We only run synchronous callbacks in ShouldStop:
404   context->is_synchronous = true;
405   should_stop = InvokeCallback(context);
406 
407   if (log) {
408     StreamString s;
409     GetDescription(&s, lldb::eDescriptionLevelVerbose);
410     LLDB_LOGF(log, "Hit breakpoint location: %s, %s.\n", s.GetData(),
411               should_stop ? "stopping" : "continuing");
412   }
413 
414   return should_stop;
415 }
416 
417 void BreakpointLocation::BumpHitCount() {
418   if (IsEnabled()) {
419     // Step our hit count, and also step the hit count of the owner.
420     m_hit_counter.Increment();
421     m_owner.m_hit_counter.Increment();
422   }
423 }
424 
425 void BreakpointLocation::UndoBumpHitCount() {
426   if (IsEnabled()) {
427     // Step our hit count, and also step the hit count of the owner.
428     m_hit_counter.Decrement();
429     m_owner.m_hit_counter.Decrement();
430   }
431 }
432 
433 bool BreakpointLocation::IsResolved() const {
434   return m_bp_site_sp.get() != nullptr;
435 }
436 
437 lldb::BreakpointSiteSP BreakpointLocation::GetBreakpointSite() const {
438   return m_bp_site_sp;
439 }
440 
441 bool BreakpointLocation::ResolveBreakpointSite() {
442   if (m_bp_site_sp)
443     return true;
444 
445   Process *process = m_owner.GetTarget().GetProcessSP().get();
446   if (process == nullptr)
447     return false;
448 
449   lldb::break_id_t new_id =
450       process->CreateBreakpointSite(shared_from_this(), m_owner.IsHardware());
451 
452   if (new_id == LLDB_INVALID_BREAK_ID) {
453     Log *log = GetLog(LLDBLog::Breakpoints);
454     if (log)
455       log->Warning("Failed to add breakpoint site at 0x%" PRIx64,
456                    m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()));
457   }
458 
459   return IsResolved();
460 }
461 
462 bool BreakpointLocation::SetBreakpointSite(BreakpointSiteSP &bp_site_sp) {
463   m_bp_site_sp = bp_site_sp;
464   SendBreakpointLocationChangedEvent(eBreakpointEventTypeLocationsResolved);
465   return true;
466 }
467 
468 bool BreakpointLocation::ClearBreakpointSite() {
469   if (m_bp_site_sp.get()) {
470     ProcessSP process_sp(m_owner.GetTarget().GetProcessSP());
471     // If the process exists, get it to remove the owner, it will remove the
472     // physical implementation of the breakpoint as well if there are no more
473     // owners.  Otherwise just remove this owner.
474     if (process_sp)
475       process_sp->RemoveOwnerFromBreakpointSite(GetBreakpoint().GetID(),
476                                                 GetID(), m_bp_site_sp);
477     else
478       m_bp_site_sp->RemoveOwner(GetBreakpoint().GetID(), GetID());
479 
480     m_bp_site_sp.reset();
481     return true;
482   }
483   return false;
484 }
485 
486 void BreakpointLocation::GetDescription(Stream *s,
487                                         lldb::DescriptionLevel level) {
488   SymbolContext sc;
489 
490   // If the description level is "initial" then the breakpoint is printing out
491   // our initial state, and we should let it decide how it wants to print our
492   // label.
493   if (level != eDescriptionLevelInitial) {
494     s->Indent();
495     BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID());
496   }
497 
498   if (level == lldb::eDescriptionLevelBrief)
499     return;
500 
501   if (level != eDescriptionLevelInitial)
502     s->PutCString(": ");
503 
504   if (level == lldb::eDescriptionLevelVerbose)
505     s->IndentMore();
506 
507   if (m_address.IsSectionOffset()) {
508     m_address.CalculateSymbolContext(&sc);
509 
510     if (level == lldb::eDescriptionLevelFull ||
511         level == eDescriptionLevelInitial) {
512       if (IsReExported())
513         s->PutCString("re-exported target = ");
514       else
515         s->PutCString("where = ");
516       sc.DumpStopContext(s, m_owner.GetTarget().GetProcessSP().get(), m_address,
517                          false, true, false, true, true);
518     } else {
519       if (sc.module_sp) {
520         s->EOL();
521         s->Indent("module = ");
522         sc.module_sp->GetFileSpec().Dump(s->AsRawOstream());
523       }
524 
525       if (sc.comp_unit != nullptr) {
526         s->EOL();
527         s->Indent("compile unit = ");
528         sc.comp_unit->GetPrimaryFile().GetFilename().Dump(s);
529 
530         if (sc.function != nullptr) {
531           s->EOL();
532           s->Indent("function = ");
533           s->PutCString(sc.function->GetName().AsCString("<unknown>"));
534         }
535 
536         if (sc.line_entry.line > 0) {
537           s->EOL();
538           s->Indent("location = ");
539           sc.line_entry.DumpStopContext(s, true);
540         }
541 
542       } else {
543         // If we don't have a comp unit, see if we have a symbol we can print.
544         if (sc.symbol) {
545           s->EOL();
546           if (IsReExported())
547             s->Indent("re-exported target = ");
548           else
549             s->Indent("symbol = ");
550           s->PutCString(sc.symbol->GetName().AsCString("<unknown>"));
551         }
552       }
553     }
554   }
555 
556   if (level == lldb::eDescriptionLevelVerbose) {
557     s->EOL();
558     s->Indent();
559   }
560 
561   if (m_address.IsSectionOffset() &&
562       (level == eDescriptionLevelFull || level == eDescriptionLevelInitial))
563     s->Printf(", ");
564   s->Printf("address = ");
565 
566   ExecutionContextScope *exe_scope = nullptr;
567   Target *target = &m_owner.GetTarget();
568   if (target)
569     exe_scope = target->GetProcessSP().get();
570   if (exe_scope == nullptr)
571     exe_scope = target;
572 
573   if (level == eDescriptionLevelInitial)
574     m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress,
575                    Address::DumpStyleFileAddress);
576   else
577     m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress,
578                    Address::DumpStyleModuleWithFileAddress);
579 
580   if (IsIndirect() && m_bp_site_sp) {
581     Address resolved_address;
582     resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target);
583     Symbol *resolved_symbol = resolved_address.CalculateSymbolContextSymbol();
584     if (resolved_symbol) {
585       if (level == eDescriptionLevelFull || level == eDescriptionLevelInitial)
586         s->Printf(", ");
587       else if (level == lldb::eDescriptionLevelVerbose) {
588         s->EOL();
589         s->Indent();
590       }
591       s->Printf("indirect target = %s",
592                 resolved_symbol->GetName().GetCString());
593     }
594   }
595 
596   bool is_resolved = IsResolved();
597   bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
598 
599   if (level == lldb::eDescriptionLevelVerbose) {
600     s->EOL();
601     s->Indent();
602     s->Printf("resolved = %s\n", is_resolved ? "true" : "false");
603     s->Indent();
604     s->Printf("hardware = %s\n", is_hardware ? "true" : "false");
605     s->Indent();
606     s->Printf("hit count = %-4u\n", GetHitCount());
607 
608     if (m_options_up) {
609       s->Indent();
610       m_options_up->GetDescription(s, level);
611       s->EOL();
612     }
613     s->IndentLess();
614   } else if (level != eDescriptionLevelInitial) {
615     s->Printf(", %sresolved, %shit count = %u ", (is_resolved ? "" : "un"),
616               (is_hardware ? "hardware, " : ""), GetHitCount());
617     if (m_options_up) {
618       m_options_up->GetDescription(s, level);
619     }
620   }
621 }
622 
623 void BreakpointLocation::Dump(Stream *s) const {
624   if (s == nullptr)
625     return;
626 
627   bool is_resolved = IsResolved();
628   bool is_hardware = is_resolved && m_bp_site_sp->IsHardware();
629   auto hardware_index = is_resolved ?
630       m_bp_site_sp->GetHardwareIndex() : LLDB_INVALID_INDEX32;
631 
632   lldb::tid_t tid = GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec)
633                         .GetThreadSpecNoCreate()
634                         ->GetTID();
635   s->Printf("BreakpointLocation %u: tid = %4.4" PRIx64
636             "  load addr = 0x%8.8" PRIx64 "  state = %s  type = %s breakpoint  "
637             "hw_index = %i  hit_count = %-4u  ignore_count = %-4u",
638             GetID(), tid,
639             (uint64_t)m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()),
640             (m_options_up ? m_options_up->IsEnabled() : m_owner.IsEnabled())
641                 ? "enabled "
642                 : "disabled",
643             is_hardware ? "hardware" : "software", hardware_index,
644             GetHitCount(),
645             GetOptionsSpecifyingKind(BreakpointOptions::eIgnoreCount)
646                 .GetIgnoreCount());
647 }
648 
649 void BreakpointLocation::SendBreakpointLocationChangedEvent(
650     lldb::BreakpointEventType eventKind) {
651   if (!m_being_created && !m_owner.IsInternal() &&
652       m_owner.GetTarget().EventTypeHasListeners(
653           Target::eBroadcastBitBreakpointChanged)) {
654     Breakpoint::BreakpointEventData *data = new Breakpoint::BreakpointEventData(
655         eventKind, m_owner.shared_from_this());
656     data->GetBreakpointLocationCollection().Add(shared_from_this());
657     m_owner.GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
658                                        data);
659   }
660 }
661 
662 void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) {
663   m_address = swap_from->m_address;
664   m_should_resolve_indirect_functions =
665       swap_from->m_should_resolve_indirect_functions;
666   m_is_reexported = swap_from->m_is_reexported;
667   m_is_indirect = swap_from->m_is_indirect;
668   m_user_expression_sp.reset();
669 }
670