contrib/llvm/tools/lldb/source/Breakpoint/BreakpointLocation.cpp

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