1 //===-- BreakpointLocation.cpp ----------------------------------*- C++ -*-===// 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/Log.h" 26 #include "lldb/Utility/StreamString.h" 27 28 using namespace lldb; 29 using namespace lldb_private; 30 31 BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner, 32 const Address &addr, lldb::tid_t tid, 33 bool hardware, bool check_for_resolver) 34 : StoppointLocation(loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), 35 hardware), 36 m_being_created(true), m_should_resolve_indirect_functions(false), 37 m_is_reexported(false), m_is_indirect(false), m_address(addr), 38 m_owner(owner), m_options_up(), m_bp_site_sp(), m_condition_mutex() { 39 if (check_for_resolver) { 40 Symbol *symbol = m_address.CalculateSymbolContextSymbol(); 41 if (symbol && symbol->IsIndirect()) { 42 SetShouldResolveIndirectFunctions(true); 43 } 44 } 45 46 SetThreadID(tid); 47 m_being_created = false; 48 } 49 50 BreakpointLocation::~BreakpointLocation() { ClearBreakpointSite(); } 51 52 lldb::addr_t BreakpointLocation::GetLoadAddress() const { 53 return m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()); 54 } 55 56 const BreakpointOptions * 57 BreakpointLocation::GetOptionsSpecifyingKind(BreakpointOptions::OptionKind kind) 58 const { 59 if (m_options_up && m_options_up->IsOptionSet(kind)) 60 return m_options_up.get(); 61 else 62 return m_owner.GetOptions(); 63 } 64 65 Address &BreakpointLocation::GetAddress() { return m_address; } 66 67 Breakpoint &BreakpointLocation::GetBreakpoint() { return m_owner; } 68 69 Target &BreakpointLocation::GetTarget() { return m_owner.GetTarget(); } 70 71 bool BreakpointLocation::IsEnabled() const { 72 if (!m_owner.IsEnabled()) 73 return false; 74 else if (m_options_up != nullptr) 75 return m_options_up->IsEnabled(); 76 else 77 return true; 78 } 79 80 void BreakpointLocation::SetEnabled(bool enabled) { 81 GetLocationOptions()->SetEnabled(enabled); 82 if (enabled) { 83 ResolveBreakpointSite(); 84 } else { 85 ClearBreakpointSite(); 86 } 87 SendBreakpointLocationChangedEvent(enabled ? eBreakpointEventTypeEnabled 88 : eBreakpointEventTypeDisabled); 89 } 90 91 bool BreakpointLocation::IsAutoContinue() const { 92 if (m_options_up && 93 m_options_up->IsOptionSet(BreakpointOptions::eAutoContinue)) 94 return m_options_up->IsAutoContinue(); 95 else 96 return m_owner.IsAutoContinue(); 97 } 98 99 void BreakpointLocation::SetAutoContinue(bool auto_continue) { 100 GetLocationOptions()->SetAutoContinue(auto_continue); 101 SendBreakpointLocationChangedEvent(eBreakpointEventTypeAutoContinueChanged); 102 } 103 104 void BreakpointLocation::SetThreadID(lldb::tid_t thread_id) { 105 if (thread_id != LLDB_INVALID_THREAD_ID) 106 GetLocationOptions()->SetThreadID(thread_id); 107 else { 108 // If we're resetting this to an invalid thread id, then don't make an 109 // options pointer just to do that. 110 if (m_options_up != nullptr) 111 m_options_up->SetThreadID(thread_id); 112 } 113 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); 114 } 115 116 lldb::tid_t BreakpointLocation::GetThreadID() { 117 const ThreadSpec *thread_spec = 118 GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec) 119 ->GetThreadSpecNoCreate(); 120 if (thread_spec) 121 return thread_spec->GetTID(); 122 else 123 return LLDB_INVALID_THREAD_ID; 124 } 125 126 void BreakpointLocation::SetThreadIndex(uint32_t index) { 127 if (index != 0) 128 GetLocationOptions()->GetThreadSpec()->SetIndex(index); 129 else { 130 // If we're resetting this to an invalid thread id, then don't make an 131 // options pointer just to do that. 132 if (m_options_up != nullptr) 133 m_options_up->GetThreadSpec()->SetIndex(index); 134 } 135 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); 136 } 137 138 uint32_t BreakpointLocation::GetThreadIndex() const { 139 const ThreadSpec *thread_spec = 140 GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec) 141 ->GetThreadSpecNoCreate(); 142 if (thread_spec) 143 return thread_spec->GetIndex(); 144 else 145 return 0; 146 } 147 148 void BreakpointLocation::SetThreadName(const char *thread_name) { 149 if (thread_name != nullptr) 150 GetLocationOptions()->GetThreadSpec()->SetName(thread_name); 151 else { 152 // If we're resetting this to an invalid thread id, then don't make an 153 // options pointer just to do that. 154 if (m_options_up != nullptr) 155 m_options_up->GetThreadSpec()->SetName(thread_name); 156 } 157 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); 158 } 159 160 const char *BreakpointLocation::GetThreadName() const { 161 const ThreadSpec *thread_spec = 162 GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec) 163 ->GetThreadSpecNoCreate(); 164 if (thread_spec) 165 return thread_spec->GetName(); 166 else 167 return nullptr; 168 } 169 170 void BreakpointLocation::SetQueueName(const char *queue_name) { 171 if (queue_name != nullptr) 172 GetLocationOptions()->GetThreadSpec()->SetQueueName(queue_name); 173 else { 174 // If we're resetting this to an invalid thread id, then don't make an 175 // options pointer just to do that. 176 if (m_options_up != nullptr) 177 m_options_up->GetThreadSpec()->SetQueueName(queue_name); 178 } 179 SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); 180 } 181 182 const char *BreakpointLocation::GetQueueName() const { 183 const ThreadSpec *thread_spec = 184 GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec) 185 ->GetThreadSpecNoCreate(); 186 if (thread_spec) 187 return thread_spec->GetQueueName(); 188 else 189 return nullptr; 190 } 191 192 bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) { 193 if (m_options_up != nullptr && m_options_up->HasCallback()) 194 return m_options_up->InvokeCallback(context, m_owner.GetID(), GetID()); 195 else 196 return m_owner.InvokeCallback(context, GetID()); 197 } 198 199 void BreakpointLocation::SetCallback(BreakpointHitCallback callback, 200 void *baton, bool is_synchronous) { 201 // The default "Baton" class will keep a copy of "baton" and won't free or 202 // delete it when it goes goes out of scope. 203 GetLocationOptions()->SetCallback( 204 callback, std::make_shared<UntypedBaton>(baton), is_synchronous); 205 SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged); 206 } 207 208 void BreakpointLocation::SetCallback(BreakpointHitCallback callback, 209 const BatonSP &baton_sp, 210 bool is_synchronous) { 211 GetLocationOptions()->SetCallback(callback, baton_sp, is_synchronous); 212 SendBreakpointLocationChangedEvent(eBreakpointEventTypeCommandChanged); 213 } 214 215 void BreakpointLocation::ClearCallback() { 216 GetLocationOptions()->ClearCallback(); 217 } 218 219 void BreakpointLocation::SetCondition(const char *condition) { 220 GetLocationOptions()->SetCondition(condition); 221 SendBreakpointLocationChangedEvent(eBreakpointEventTypeConditionChanged); 222 } 223 224 const char *BreakpointLocation::GetConditionText(size_t *hash) const { 225 return GetOptionsSpecifyingKind(BreakpointOptions::eCondition) 226 ->GetConditionText(hash); 227 } 228 229 bool BreakpointLocation::ConditionSaysStop(ExecutionContext &exe_ctx, 230 Status &error) { 231 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS); 232 233 std::lock_guard<std::mutex> guard(m_condition_mutex); 234 235 size_t condition_hash; 236 const char *condition_text = GetConditionText(&condition_hash); 237 238 if (!condition_text) { 239 m_user_expression_sp.reset(); 240 return false; 241 } 242 243 error.Clear(); 244 245 DiagnosticManager diagnostics; 246 247 if (condition_hash != m_condition_hash || !m_user_expression_sp || 248 !m_user_expression_sp->MatchesContext(exe_ctx)) { 249 LanguageType language = eLanguageTypeUnknown; 250 // See if we can figure out the language from the frame, otherwise use the 251 // default language: 252 CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit(); 253 if (comp_unit) 254 language = comp_unit->GetLanguage(); 255 256 m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage( 257 condition_text, llvm::StringRef(), language, Expression::eResultTypeAny, 258 EvaluateExpressionOptions(), nullptr, error)); 259 if (error.Fail()) { 260 if (log) 261 log->Printf("Error getting condition expression: %s.", 262 error.AsCString()); 263 m_user_expression_sp.reset(); 264 return true; 265 } 266 267 if (!m_user_expression_sp->Parse(diagnostics, exe_ctx, 268 eExecutionPolicyOnlyWhenNeeded, true, 269 false)) { 270 error.SetErrorStringWithFormat( 271 "Couldn't parse conditional expression:\n%s", 272 diagnostics.GetString().c_str()); 273 m_user_expression_sp.reset(); 274 return true; 275 } 276 277 m_condition_hash = condition_hash; 278 } 279 280 // We need to make sure the user sees any parse errors in their condition, so 281 // we'll hook the constructor errors up to the debugger's Async I/O. 282 283 ValueObjectSP result_value_sp; 284 285 EvaluateExpressionOptions options; 286 options.SetUnwindOnError(true); 287 options.SetIgnoreBreakpoints(true); 288 options.SetTryAllThreads(true); 289 options.SetResultIsInternal( 290 true); // Don't generate a user variable for condition expressions. 291 292 Status expr_error; 293 294 diagnostics.Clear(); 295 296 ExpressionVariableSP result_variable_sp; 297 298 ExpressionResults result_code = m_user_expression_sp->Execute( 299 diagnostics, exe_ctx, options, m_user_expression_sp, result_variable_sp); 300 301 bool ret; 302 303 if (result_code == eExpressionCompleted) { 304 if (!result_variable_sp) { 305 error.SetErrorString("Expression did not return a result"); 306 return false; 307 } 308 309 result_value_sp = result_variable_sp->GetValueObject(); 310 311 if (result_value_sp) { 312 ret = result_value_sp->IsLogicalTrue(error); 313 if (log) { 314 if (error.Success()) { 315 log->Printf("Condition successfully evaluated, result is %s.\n", 316 ret ? "true" : "false"); 317 } else { 318 error.SetErrorString( 319 "Failed to get an integer result from the expression"); 320 ret = false; 321 } 322 } 323 } else { 324 ret = false; 325 error.SetErrorString("Failed to get any result from the expression"); 326 } 327 } else { 328 ret = false; 329 error.SetErrorStringWithFormat("Couldn't execute expression:\n%s", 330 diagnostics.GetString().c_str()); 331 } 332 333 return ret; 334 } 335 336 uint32_t BreakpointLocation::GetIgnoreCount() { 337 return GetOptionsSpecifyingKind(BreakpointOptions::eIgnoreCount) 338 ->GetIgnoreCount(); 339 } 340 341 void BreakpointLocation::SetIgnoreCount(uint32_t n) { 342 GetLocationOptions()->SetIgnoreCount(n); 343 SendBreakpointLocationChangedEvent(eBreakpointEventTypeIgnoreChanged); 344 } 345 346 void BreakpointLocation::DecrementIgnoreCount() { 347 if (m_options_up != nullptr) { 348 uint32_t loc_ignore = m_options_up->GetIgnoreCount(); 349 if (loc_ignore != 0) 350 m_options_up->SetIgnoreCount(loc_ignore - 1); 351 } 352 } 353 354 bool BreakpointLocation::IgnoreCountShouldStop() { 355 if (m_options_up != nullptr) { 356 uint32_t loc_ignore = m_options_up->GetIgnoreCount(); 357 if (loc_ignore != 0) { 358 m_owner.DecrementIgnoreCount(); 359 DecrementIgnoreCount(); // Have to decrement our owners' ignore count, 360 // since it won't get a 361 // chance to. 362 return false; 363 } 364 } 365 return true; 366 } 367 368 BreakpointOptions *BreakpointLocation::GetLocationOptions() { 369 // If we make the copy we don't copy the callbacks because that is 370 // potentially expensive and we don't want to do that for the simple case 371 // where someone is just disabling the location. 372 if (m_options_up == nullptr) 373 m_options_up.reset(new BreakpointOptions(false)); 374 375 return m_options_up.get(); 376 } 377 378 bool BreakpointLocation::ValidForThisThread(Thread *thread) { 379 return thread 380 ->MatchesSpec(GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec) 381 ->GetThreadSpecNoCreate()); 382 } 383 384 // RETURNS - true if we should stop at this breakpoint, false if we 385 // should continue. Note, we don't check the thread spec for the breakpoint 386 // here, since if the breakpoint is not for this thread, then the event won't 387 // even get reported, so the check is redundant. 388 389 bool BreakpointLocation::ShouldStop(StoppointCallbackContext *context) { 390 bool should_stop = true; 391 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS); 392 393 // Do this first, if a location is disabled, it shouldn't increment its hit 394 // count. 395 if (!IsEnabled()) 396 return false; 397 398 if (!IgnoreCountShouldStop()) 399 return false; 400 401 if (!m_owner.IgnoreCountShouldStop()) 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 log->Printf("Hit breakpoint location: %s, %s.\n", s.GetData(), 412 should_stop ? "stopping" : "continuing"); 413 } 414 415 return should_stop; 416 } 417 418 void BreakpointLocation::BumpHitCount() { 419 if (IsEnabled()) { 420 // Step our hit count, and also step the hit count of the owner. 421 IncrementHitCount(); 422 m_owner.IncrementHitCount(); 423 } 424 } 425 426 void BreakpointLocation::UndoBumpHitCount() { 427 if (IsEnabled()) { 428 // Step our hit count, and also step the hit count of the owner. 429 DecrementHitCount(); 430 m_owner.DecrementHitCount(); 431 } 432 } 433 434 bool BreakpointLocation::IsResolved() const { 435 return m_bp_site_sp.get() != nullptr; 436 } 437 438 lldb::BreakpointSiteSP BreakpointLocation::GetBreakpointSite() const { 439 return m_bp_site_sp; 440 } 441 442 bool 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 = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_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 463 bool BreakpointLocation::SetBreakpointSite(BreakpointSiteSP &bp_site_sp) { 464 m_bp_site_sp = bp_site_sp; 465 SendBreakpointLocationChangedEvent(eBreakpointEventTypeLocationsResolved); 466 return true; 467 } 468 469 bool 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->RemoveOwnerFromBreakpointSite(GetBreakpoint().GetID(), 477 GetID(), m_bp_site_sp); 478 else 479 m_bp_site_sp->RemoveOwner(GetBreakpoint().GetID(), GetID()); 480 481 m_bp_site_sp.reset(); 482 return true; 483 } 484 return false; 485 } 486 487 void 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); 524 } 525 526 if (sc.comp_unit != nullptr) { 527 s->EOL(); 528 s->Indent("compile unit = "); 529 static_cast<FileSpec *>(sc.comp_unit)->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 if (level == lldb::eDescriptionLevelVerbose) { 598 s->EOL(); 599 s->Indent(); 600 s->Printf("resolved = %s\n", IsResolved() ? "true" : "false"); 601 602 s->Indent(); 603 s->Printf("hit count = %-4u\n", GetHitCount()); 604 605 if (m_options_up) { 606 s->Indent(); 607 m_options_up->GetDescription(s, level); 608 s->EOL(); 609 } 610 s->IndentLess(); 611 } else if (level != eDescriptionLevelInitial) { 612 s->Printf(", %sresolved, hit count = %u ", (IsResolved() ? "" : "un"), 613 GetHitCount()); 614 if (m_options_up) { 615 m_options_up->GetDescription(s, level); 616 } 617 } 618 } 619 620 void BreakpointLocation::Dump(Stream *s) const { 621 if (s == nullptr) 622 return; 623 624 lldb::tid_t tid = GetOptionsSpecifyingKind(BreakpointOptions::eThreadSpec) 625 ->GetThreadSpecNoCreate()->GetTID(); 626 s->Printf("BreakpointLocation %u: tid = %4.4" PRIx64 627 " load addr = 0x%8.8" PRIx64 " state = %s type = %s breakpoint " 628 "hw_index = %i hit_count = %-4u ignore_count = %-4u", 629 GetID(), tid, 630 (uint64_t)m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()), 631 (m_options_up ? m_options_up->IsEnabled() : m_owner.IsEnabled()) 632 ? "enabled " 633 : "disabled", 634 IsHardware() ? "hardware" : "software", GetHardwareIndex(), 635 GetHitCount(), 636 GetOptionsSpecifyingKind(BreakpointOptions::eIgnoreCount) 637 ->GetIgnoreCount()); 638 } 639 640 void BreakpointLocation::SendBreakpointLocationChangedEvent( 641 lldb::BreakpointEventType eventKind) { 642 if (!m_being_created && !m_owner.IsInternal() && 643 m_owner.GetTarget().EventTypeHasListeners( 644 Target::eBroadcastBitBreakpointChanged)) { 645 Breakpoint::BreakpointEventData *data = new Breakpoint::BreakpointEventData( 646 eventKind, m_owner.shared_from_this()); 647 data->GetBreakpointLocationCollection().Add(shared_from_this()); 648 m_owner.GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, 649 data); 650 } 651 } 652 653 void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) { 654 m_address = swap_from->m_address; 655 m_should_resolve_indirect_functions = 656 swap_from->m_should_resolve_indirect_functions; 657 m_is_reexported = swap_from->m_is_reexported; 658 m_is_indirect = swap_from->m_is_indirect; 659 m_user_expression_sp.reset(); 660 } 661