1 //===-- Breakpoint.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 "llvm/Support/Casting.h" 10 11 #include "lldb/Breakpoint/Breakpoint.h" 12 #include "lldb/Breakpoint/BreakpointLocation.h" 13 #include "lldb/Breakpoint/BreakpointLocationCollection.h" 14 #include "lldb/Breakpoint/BreakpointPrecondition.h" 15 #include "lldb/Breakpoint/BreakpointResolver.h" 16 #include "lldb/Breakpoint/BreakpointResolverFileLine.h" 17 #include "lldb/Core/Address.h" 18 #include "lldb/Core/Module.h" 19 #include "lldb/Core/ModuleList.h" 20 #include "lldb/Core/SearchFilter.h" 21 #include "lldb/Core/Section.h" 22 #include "lldb/Symbol/CompileUnit.h" 23 #include "lldb/Symbol/Function.h" 24 #include "lldb/Symbol/Symbol.h" 25 #include "lldb/Symbol/SymbolContext.h" 26 #include "lldb/Target/SectionLoadList.h" 27 #include "lldb/Target/Target.h" 28 #include "lldb/Target/ThreadSpec.h" 29 #include "lldb/Utility/LLDBLog.h" 30 #include "lldb/Utility/Log.h" 31 #include "lldb/Utility/Stream.h" 32 #include "lldb/Utility/StreamString.h" 33 34 #include <memory> 35 36 using namespace lldb; 37 using namespace lldb_private; 38 using namespace llvm; 39 40 ConstString Breakpoint::GetEventIdentifier() { 41 static ConstString g_identifier("event-identifier.breakpoint.changed"); 42 return g_identifier; 43 } 44 45 const char *Breakpoint::g_option_names[static_cast<uint32_t>( 46 Breakpoint::OptionNames::LastOptionName)]{"Names", "Hardware"}; 47 48 // Breakpoint constructor 49 Breakpoint::Breakpoint(Target &target, SearchFilterSP &filter_sp, 50 BreakpointResolverSP &resolver_sp, bool hardware, 51 bool resolve_indirect_symbols) 52 : m_being_created(true), m_hardware(hardware), m_target(target), 53 m_filter_sp(filter_sp), m_resolver_sp(resolver_sp), m_options(true), 54 m_locations(*this), m_resolve_indirect_symbols(resolve_indirect_symbols), 55 m_hit_counter() { 56 m_being_created = false; 57 } 58 59 Breakpoint::Breakpoint(Target &new_target, const Breakpoint &source_bp) 60 : m_being_created(true), m_hardware(source_bp.m_hardware), 61 m_target(new_target), m_name_list(source_bp.m_name_list), 62 m_options(source_bp.m_options), m_locations(*this), 63 m_resolve_indirect_symbols(source_bp.m_resolve_indirect_symbols), 64 m_hit_counter() {} 65 66 // Destructor 67 Breakpoint::~Breakpoint() = default; 68 69 BreakpointSP Breakpoint::CopyFromBreakpoint(TargetSP new_target, 70 const Breakpoint& bp_to_copy_from) { 71 if (!new_target) 72 return BreakpointSP(); 73 74 BreakpointSP bp(new Breakpoint(*new_target, bp_to_copy_from)); 75 // Now go through and copy the filter & resolver: 76 bp->m_resolver_sp = bp_to_copy_from.m_resolver_sp->CopyForBreakpoint(bp); 77 bp->m_filter_sp = bp_to_copy_from.m_filter_sp->CreateCopy(new_target); 78 return bp; 79 } 80 81 // Serialization 82 StructuredData::ObjectSP Breakpoint::SerializeToStructuredData() { 83 // Serialize the resolver: 84 StructuredData::DictionarySP breakpoint_dict_sp( 85 new StructuredData::Dictionary()); 86 StructuredData::DictionarySP breakpoint_contents_sp( 87 new StructuredData::Dictionary()); 88 89 if (!m_name_list.empty()) { 90 StructuredData::ArraySP names_array_sp(new StructuredData::Array()); 91 for (auto name : m_name_list) { 92 names_array_sp->AddItem( 93 StructuredData::StringSP(new StructuredData::String(name))); 94 } 95 breakpoint_contents_sp->AddItem(Breakpoint::GetKey(OptionNames::Names), 96 names_array_sp); 97 } 98 99 breakpoint_contents_sp->AddBooleanItem( 100 Breakpoint::GetKey(OptionNames::Hardware), m_hardware); 101 102 StructuredData::ObjectSP resolver_dict_sp( 103 m_resolver_sp->SerializeToStructuredData()); 104 if (!resolver_dict_sp) 105 return StructuredData::ObjectSP(); 106 107 breakpoint_contents_sp->AddItem(BreakpointResolver::GetSerializationKey(), 108 resolver_dict_sp); 109 110 StructuredData::ObjectSP filter_dict_sp( 111 m_filter_sp->SerializeToStructuredData()); 112 if (!filter_dict_sp) 113 return StructuredData::ObjectSP(); 114 115 breakpoint_contents_sp->AddItem(SearchFilter::GetSerializationKey(), 116 filter_dict_sp); 117 118 StructuredData::ObjectSP options_dict_sp( 119 m_options.SerializeToStructuredData()); 120 if (!options_dict_sp) 121 return StructuredData::ObjectSP(); 122 123 breakpoint_contents_sp->AddItem(BreakpointOptions::GetSerializationKey(), 124 options_dict_sp); 125 126 breakpoint_dict_sp->AddItem(GetSerializationKey(), breakpoint_contents_sp); 127 return breakpoint_dict_sp; 128 } 129 130 lldb::BreakpointSP Breakpoint::CreateFromStructuredData( 131 TargetSP target_sp, StructuredData::ObjectSP &object_data, Status &error) { 132 BreakpointSP result_sp; 133 if (!target_sp) 134 return result_sp; 135 136 StructuredData::Dictionary *breakpoint_dict = object_data->GetAsDictionary(); 137 138 if (!breakpoint_dict || !breakpoint_dict->IsValid()) { 139 error.SetErrorString("Can't deserialize from an invalid data object."); 140 return result_sp; 141 } 142 143 StructuredData::Dictionary *resolver_dict; 144 bool success = breakpoint_dict->GetValueForKeyAsDictionary( 145 BreakpointResolver::GetSerializationKey(), resolver_dict); 146 if (!success) { 147 error.SetErrorString("Breakpoint data missing toplevel resolver key"); 148 return result_sp; 149 } 150 151 Status create_error; 152 BreakpointResolverSP resolver_sp = 153 BreakpointResolver::CreateFromStructuredData(*resolver_dict, 154 create_error); 155 if (create_error.Fail()) { 156 error.SetErrorStringWithFormat( 157 "Error creating breakpoint resolver from data: %s.", 158 create_error.AsCString()); 159 return result_sp; 160 } 161 162 StructuredData::Dictionary *filter_dict; 163 success = breakpoint_dict->GetValueForKeyAsDictionary( 164 SearchFilter::GetSerializationKey(), filter_dict); 165 SearchFilterSP filter_sp; 166 if (!success) 167 filter_sp = 168 std::make_shared<SearchFilterForUnconstrainedSearches>(target_sp); 169 else { 170 filter_sp = SearchFilter::CreateFromStructuredData(target_sp, *filter_dict, 171 create_error); 172 if (create_error.Fail()) { 173 error.SetErrorStringWithFormat( 174 "Error creating breakpoint filter from data: %s.", 175 create_error.AsCString()); 176 return result_sp; 177 } 178 } 179 180 std::unique_ptr<BreakpointOptions> options_up; 181 StructuredData::Dictionary *options_dict; 182 Target& target = *target_sp; 183 success = breakpoint_dict->GetValueForKeyAsDictionary( 184 BreakpointOptions::GetSerializationKey(), options_dict); 185 if (success) { 186 options_up = BreakpointOptions::CreateFromStructuredData( 187 target, *options_dict, create_error); 188 if (create_error.Fail()) { 189 error.SetErrorStringWithFormat( 190 "Error creating breakpoint options from data: %s.", 191 create_error.AsCString()); 192 return result_sp; 193 } 194 } 195 196 bool hardware = false; 197 success = breakpoint_dict->GetValueForKeyAsBoolean( 198 Breakpoint::GetKey(OptionNames::Hardware), hardware); 199 200 result_sp = target.CreateBreakpoint(filter_sp, resolver_sp, false, 201 hardware, true); 202 203 if (result_sp && options_up) { 204 result_sp->m_options = *options_up; 205 } 206 207 StructuredData::Array *names_array; 208 success = breakpoint_dict->GetValueForKeyAsArray( 209 Breakpoint::GetKey(OptionNames::Names), names_array); 210 if (success && names_array) { 211 size_t num_names = names_array->GetSize(); 212 for (size_t i = 0; i < num_names; i++) { 213 llvm::StringRef name; 214 Status error; 215 success = names_array->GetItemAtIndexAsString(i, name); 216 target.AddNameToBreakpoint(result_sp, name.str().c_str(), error); 217 } 218 } 219 220 return result_sp; 221 } 222 223 bool Breakpoint::SerializedBreakpointMatchesNames( 224 StructuredData::ObjectSP &bkpt_object_sp, std::vector<std::string> &names) { 225 if (!bkpt_object_sp) 226 return false; 227 228 StructuredData::Dictionary *bkpt_dict = bkpt_object_sp->GetAsDictionary(); 229 if (!bkpt_dict) 230 return false; 231 232 if (names.empty()) 233 return true; 234 235 StructuredData::Array *names_array; 236 237 bool success = 238 bkpt_dict->GetValueForKeyAsArray(GetKey(OptionNames::Names), names_array); 239 // If there are no names, it can't match these names; 240 if (!success) 241 return false; 242 243 size_t num_names = names_array->GetSize(); 244 245 for (size_t i = 0; i < num_names; i++) { 246 llvm::StringRef name; 247 if (names_array->GetItemAtIndexAsString(i, name)) { 248 if (llvm::is_contained(names, name)) 249 return true; 250 } 251 } 252 return false; 253 } 254 255 const lldb::TargetSP Breakpoint::GetTargetSP() { 256 return m_target.shared_from_this(); 257 } 258 259 bool Breakpoint::IsInternal() const { return LLDB_BREAK_ID_IS_INTERNAL(m_bid); } 260 261 BreakpointLocationSP Breakpoint::AddLocation(const Address &addr, 262 bool *new_location) { 263 return m_locations.AddLocation(addr, m_resolve_indirect_symbols, 264 new_location); 265 } 266 267 BreakpointLocationSP Breakpoint::FindLocationByAddress(const Address &addr) { 268 return m_locations.FindByAddress(addr); 269 } 270 271 break_id_t Breakpoint::FindLocationIDByAddress(const Address &addr) { 272 return m_locations.FindIDByAddress(addr); 273 } 274 275 BreakpointLocationSP Breakpoint::FindLocationByID(break_id_t bp_loc_id) { 276 return m_locations.FindByID(bp_loc_id); 277 } 278 279 BreakpointLocationSP Breakpoint::GetLocationAtIndex(size_t index) { 280 return m_locations.GetByIndex(index); 281 } 282 283 void Breakpoint::RemoveInvalidLocations(const ArchSpec &arch) { 284 m_locations.RemoveInvalidLocations(arch); 285 } 286 287 // For each of the overall options we need to decide how they propagate to the 288 // location options. This will determine the precedence of options on the 289 // breakpoint vs. its locations. 290 291 // Disable at the breakpoint level should override the location settings. That 292 // way you can conveniently turn off a whole breakpoint without messing up the 293 // individual settings. 294 295 void Breakpoint::SetEnabled(bool enable) { 296 if (enable == m_options.IsEnabled()) 297 return; 298 299 m_options.SetEnabled(enable); 300 if (enable) 301 m_locations.ResolveAllBreakpointSites(); 302 else 303 m_locations.ClearAllBreakpointSites(); 304 305 SendBreakpointChangedEvent(enable ? eBreakpointEventTypeEnabled 306 : eBreakpointEventTypeDisabled); 307 } 308 309 bool Breakpoint::IsEnabled() { return m_options.IsEnabled(); } 310 311 void Breakpoint::SetIgnoreCount(uint32_t n) { 312 if (m_options.GetIgnoreCount() == n) 313 return; 314 315 m_options.SetIgnoreCount(n); 316 SendBreakpointChangedEvent(eBreakpointEventTypeIgnoreChanged); 317 } 318 319 void Breakpoint::DecrementIgnoreCount() { 320 uint32_t ignore = m_options.GetIgnoreCount(); 321 if (ignore != 0) 322 m_options.SetIgnoreCount(ignore - 1); 323 } 324 325 uint32_t Breakpoint::GetIgnoreCount() const { 326 return m_options.GetIgnoreCount(); 327 } 328 329 uint32_t Breakpoint::GetHitCount() const { return m_hit_counter.GetValue(); } 330 331 bool Breakpoint::IsOneShot() const { return m_options.IsOneShot(); } 332 333 void Breakpoint::SetOneShot(bool one_shot) { m_options.SetOneShot(one_shot); } 334 335 bool Breakpoint::IsAutoContinue() const { return m_options.IsAutoContinue(); } 336 337 void Breakpoint::SetAutoContinue(bool auto_continue) { 338 m_options.SetAutoContinue(auto_continue); 339 } 340 341 void Breakpoint::SetThreadID(lldb::tid_t thread_id) { 342 if (m_options.GetThreadSpec()->GetTID() == thread_id) 343 return; 344 345 m_options.GetThreadSpec()->SetTID(thread_id); 346 SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); 347 } 348 349 lldb::tid_t Breakpoint::GetThreadID() const { 350 if (m_options.GetThreadSpecNoCreate() == nullptr) 351 return LLDB_INVALID_THREAD_ID; 352 else 353 return m_options.GetThreadSpecNoCreate()->GetTID(); 354 } 355 356 void Breakpoint::SetThreadIndex(uint32_t index) { 357 if (m_options.GetThreadSpec()->GetIndex() == index) 358 return; 359 360 m_options.GetThreadSpec()->SetIndex(index); 361 SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); 362 } 363 364 uint32_t Breakpoint::GetThreadIndex() const { 365 if (m_options.GetThreadSpecNoCreate() == nullptr) 366 return 0; 367 else 368 return m_options.GetThreadSpecNoCreate()->GetIndex(); 369 } 370 371 void Breakpoint::SetThreadName(const char *thread_name) { 372 if (m_options.GetThreadSpec()->GetName() != nullptr && 373 ::strcmp(m_options.GetThreadSpec()->GetName(), thread_name) == 0) 374 return; 375 376 m_options.GetThreadSpec()->SetName(thread_name); 377 SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); 378 } 379 380 const char *Breakpoint::GetThreadName() const { 381 if (m_options.GetThreadSpecNoCreate() == nullptr) 382 return nullptr; 383 else 384 return m_options.GetThreadSpecNoCreate()->GetName(); 385 } 386 387 void Breakpoint::SetQueueName(const char *queue_name) { 388 if (m_options.GetThreadSpec()->GetQueueName() != nullptr && 389 ::strcmp(m_options.GetThreadSpec()->GetQueueName(), queue_name) == 0) 390 return; 391 392 m_options.GetThreadSpec()->SetQueueName(queue_name); 393 SendBreakpointChangedEvent(eBreakpointEventTypeThreadChanged); 394 } 395 396 const char *Breakpoint::GetQueueName() const { 397 if (m_options.GetThreadSpecNoCreate() == nullptr) 398 return nullptr; 399 else 400 return m_options.GetThreadSpecNoCreate()->GetQueueName(); 401 } 402 403 void Breakpoint::SetCondition(const char *condition) { 404 m_options.SetCondition(condition); 405 SendBreakpointChangedEvent(eBreakpointEventTypeConditionChanged); 406 } 407 408 const char *Breakpoint::GetConditionText() const { 409 return m_options.GetConditionText(); 410 } 411 412 // This function is used when "baton" doesn't need to be freed 413 void Breakpoint::SetCallback(BreakpointHitCallback callback, void *baton, 414 bool is_synchronous) { 415 // The default "Baton" class will keep a copy of "baton" and won't free or 416 // delete it when it goes goes out of scope. 417 m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton), 418 is_synchronous); 419 420 SendBreakpointChangedEvent(eBreakpointEventTypeCommandChanged); 421 } 422 423 // This function is used when a baton needs to be freed and therefore is 424 // contained in a "Baton" subclass. 425 void Breakpoint::SetCallback(BreakpointHitCallback callback, 426 const BatonSP &callback_baton_sp, 427 bool is_synchronous) { 428 m_options.SetCallback(callback, callback_baton_sp, is_synchronous); 429 } 430 431 void Breakpoint::ClearCallback() { m_options.ClearCallback(); } 432 433 bool Breakpoint::InvokeCallback(StoppointCallbackContext *context, 434 break_id_t bp_loc_id) { 435 return m_options.InvokeCallback(context, GetID(), bp_loc_id); 436 } 437 438 BreakpointOptions &Breakpoint::GetOptions() { return m_options; } 439 440 const BreakpointOptions &Breakpoint::GetOptions() const { return m_options; } 441 442 void Breakpoint::ResolveBreakpoint() { 443 if (m_resolver_sp) { 444 ElapsedTime elapsed(m_resolve_time); 445 m_resolver_sp->ResolveBreakpoint(*m_filter_sp); 446 } 447 } 448 449 void Breakpoint::ResolveBreakpointInModules( 450 ModuleList &module_list, BreakpointLocationCollection &new_locations) { 451 ElapsedTime elapsed(m_resolve_time); 452 m_locations.StartRecordingNewLocations(new_locations); 453 454 m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list); 455 456 m_locations.StopRecordingNewLocations(); 457 } 458 459 void Breakpoint::ResolveBreakpointInModules(ModuleList &module_list, 460 bool send_event) { 461 if (m_resolver_sp) { 462 // If this is not an internal breakpoint, set up to record the new 463 // locations, then dispatch an event with the new locations. 464 if (!IsInternal() && send_event) { 465 BreakpointEventData *new_locations_event = new BreakpointEventData( 466 eBreakpointEventTypeLocationsAdded, shared_from_this()); 467 468 ResolveBreakpointInModules( 469 module_list, new_locations_event->GetBreakpointLocationCollection()); 470 471 if (new_locations_event->GetBreakpointLocationCollection().GetSize() != 472 0) { 473 SendBreakpointChangedEvent(new_locations_event); 474 } else 475 delete new_locations_event; 476 } else { 477 ElapsedTime elapsed(m_resolve_time); 478 m_resolver_sp->ResolveBreakpointInModules(*m_filter_sp, module_list); 479 } 480 } 481 } 482 483 void Breakpoint::ClearAllBreakpointSites() { 484 m_locations.ClearAllBreakpointSites(); 485 } 486 487 // ModulesChanged: Pass in a list of new modules, and 488 489 void Breakpoint::ModulesChanged(ModuleList &module_list, bool load, 490 bool delete_locations) { 491 Log *log = GetLog(LLDBLog::Breakpoints); 492 LLDB_LOGF(log, 493 "Breakpoint::ModulesChanged: num_modules: %zu load: %i " 494 "delete_locations: %i\n", 495 module_list.GetSize(), load, delete_locations); 496 497 if (load) { 498 // The logic for handling new modules is: 499 // 1) If the filter rejects this module, then skip it. 2) Run through the 500 // current location list and if there are any locations 501 // for that module, we mark the module as "seen" and we don't try to 502 // re-resolve 503 // breakpoint locations for that module. 504 // However, we do add breakpoint sites to these locations if needed. 505 // 3) If we don't see this module in our breakpoint location list, call 506 // ResolveInModules. 507 508 ModuleList new_modules; // We'll stuff the "unseen" modules in this list, 509 // and then resolve 510 // them after the locations pass. Have to do it this way because resolving 511 // breakpoints will add new locations potentially. 512 513 for (ModuleSP module_sp : module_list.Modules()) { 514 bool seen = false; 515 if (!m_filter_sp->ModulePasses(module_sp)) 516 continue; 517 518 BreakpointLocationCollection locations_with_no_section; 519 for (BreakpointLocationSP break_loc_sp : 520 m_locations.BreakpointLocations()) { 521 522 // If the section for this location was deleted, that means it's Module 523 // has gone away but somebody forgot to tell us. Let's clean it up 524 // here. 525 Address section_addr(break_loc_sp->GetAddress()); 526 if (section_addr.SectionWasDeleted()) { 527 locations_with_no_section.Add(break_loc_sp); 528 continue; 529 } 530 531 if (!break_loc_sp->IsEnabled()) 532 continue; 533 534 SectionSP section_sp(section_addr.GetSection()); 535 536 // If we don't have a Section, that means this location is a raw 537 // address that we haven't resolved to a section yet. So we'll have to 538 // look in all the new modules to resolve this location. Otherwise, if 539 // it was set in this module, re-resolve it here. 540 if (section_sp && section_sp->GetModule() == module_sp) { 541 if (!seen) 542 seen = true; 543 544 if (!break_loc_sp->ResolveBreakpointSite()) { 545 LLDB_LOGF(log, 546 "Warning: could not set breakpoint site for " 547 "breakpoint location %d of breakpoint %d.\n", 548 break_loc_sp->GetID(), GetID()); 549 } 550 } 551 } 552 553 size_t num_to_delete = locations_with_no_section.GetSize(); 554 555 for (size_t i = 0; i < num_to_delete; i++) 556 m_locations.RemoveLocation(locations_with_no_section.GetByIndex(i)); 557 558 if (!seen) 559 new_modules.AppendIfNeeded(module_sp); 560 } 561 562 if (new_modules.GetSize() > 0) { 563 ResolveBreakpointInModules(new_modules); 564 } 565 } else { 566 // Go through the currently set locations and if any have breakpoints in 567 // the module list, then remove their breakpoint sites, and their locations 568 // if asked to. 569 570 BreakpointEventData *removed_locations_event; 571 if (!IsInternal()) 572 removed_locations_event = new BreakpointEventData( 573 eBreakpointEventTypeLocationsRemoved, shared_from_this()); 574 else 575 removed_locations_event = nullptr; 576 577 for (ModuleSP module_sp : module_list.Modules()) { 578 if (m_filter_sp->ModulePasses(module_sp)) { 579 size_t loc_idx = 0; 580 size_t num_locations = m_locations.GetSize(); 581 BreakpointLocationCollection locations_to_remove; 582 for (loc_idx = 0; loc_idx < num_locations; loc_idx++) { 583 BreakpointLocationSP break_loc_sp(m_locations.GetByIndex(loc_idx)); 584 SectionSP section_sp(break_loc_sp->GetAddress().GetSection()); 585 if (section_sp && section_sp->GetModule() == module_sp) { 586 // Remove this breakpoint since the shared library is unloaded, but 587 // keep the breakpoint location around so we always get complete 588 // hit count and breakpoint lifetime info 589 break_loc_sp->ClearBreakpointSite(); 590 if (removed_locations_event) { 591 removed_locations_event->GetBreakpointLocationCollection().Add( 592 break_loc_sp); 593 } 594 if (delete_locations) 595 locations_to_remove.Add(break_loc_sp); 596 } 597 } 598 599 if (delete_locations) { 600 size_t num_locations_to_remove = locations_to_remove.GetSize(); 601 for (loc_idx = 0; loc_idx < num_locations_to_remove; loc_idx++) 602 m_locations.RemoveLocation(locations_to_remove.GetByIndex(loc_idx)); 603 } 604 } 605 } 606 SendBreakpointChangedEvent(removed_locations_event); 607 } 608 } 609 610 static bool SymbolContextsMightBeEquivalent(SymbolContext &old_sc, 611 SymbolContext &new_sc) { 612 bool equivalent_scs = false; 613 614 if (old_sc.module_sp.get() == new_sc.module_sp.get()) { 615 // If these come from the same module, we can directly compare the 616 // pointers: 617 if (old_sc.comp_unit && new_sc.comp_unit && 618 (old_sc.comp_unit == new_sc.comp_unit)) { 619 if (old_sc.function && new_sc.function && 620 (old_sc.function == new_sc.function)) { 621 equivalent_scs = true; 622 } 623 } else if (old_sc.symbol && new_sc.symbol && 624 (old_sc.symbol == new_sc.symbol)) { 625 equivalent_scs = true; 626 } 627 } else { 628 // Otherwise we will compare by name... 629 if (old_sc.comp_unit && new_sc.comp_unit) { 630 if (old_sc.comp_unit->GetPrimaryFile() == 631 new_sc.comp_unit->GetPrimaryFile()) { 632 // Now check the functions: 633 if (old_sc.function && new_sc.function && 634 (old_sc.function->GetName() == new_sc.function->GetName())) { 635 equivalent_scs = true; 636 } 637 } 638 } else if (old_sc.symbol && new_sc.symbol) { 639 if (Mangled::Compare(old_sc.symbol->GetMangled(), 640 new_sc.symbol->GetMangled()) == 0) { 641 equivalent_scs = true; 642 } 643 } 644 } 645 return equivalent_scs; 646 } 647 648 void Breakpoint::ModuleReplaced(ModuleSP old_module_sp, 649 ModuleSP new_module_sp) { 650 Log *log = GetLog(LLDBLog::Breakpoints); 651 LLDB_LOGF(log, "Breakpoint::ModulesReplaced for %s\n", 652 old_module_sp->GetSpecificationDescription().c_str()); 653 // First find all the locations that are in the old module 654 655 BreakpointLocationCollection old_break_locs; 656 for (BreakpointLocationSP break_loc_sp : m_locations.BreakpointLocations()) { 657 SectionSP section_sp = break_loc_sp->GetAddress().GetSection(); 658 if (section_sp && section_sp->GetModule() == old_module_sp) { 659 old_break_locs.Add(break_loc_sp); 660 } 661 } 662 663 size_t num_old_locations = old_break_locs.GetSize(); 664 665 if (num_old_locations == 0) { 666 // There were no locations in the old module, so we just need to check if 667 // there were any in the new module. 668 ModuleList temp_list; 669 temp_list.Append(new_module_sp); 670 ResolveBreakpointInModules(temp_list); 671 } else { 672 // First search the new module for locations. Then compare this with the 673 // old list, copy over locations that "look the same" Then delete the old 674 // locations. Finally remember to post the creation event. 675 // 676 // Two locations are the same if they have the same comp unit & function 677 // (by name) and there are the same number of locations in the old function 678 // as in the new one. 679 680 ModuleList temp_list; 681 temp_list.Append(new_module_sp); 682 BreakpointLocationCollection new_break_locs; 683 ResolveBreakpointInModules(temp_list, new_break_locs); 684 BreakpointLocationCollection locations_to_remove; 685 BreakpointLocationCollection locations_to_announce; 686 687 size_t num_new_locations = new_break_locs.GetSize(); 688 689 if (num_new_locations > 0) { 690 // Break out the case of one location -> one location since that's the 691 // most common one, and there's no need to build up the structures needed 692 // for the merge in that case. 693 if (num_new_locations == 1 && num_old_locations == 1) { 694 bool equivalent_locations = false; 695 SymbolContext old_sc, new_sc; 696 // The only way the old and new location can be equivalent is if they 697 // have the same amount of information: 698 BreakpointLocationSP old_loc_sp = old_break_locs.GetByIndex(0); 699 BreakpointLocationSP new_loc_sp = new_break_locs.GetByIndex(0); 700 701 if (old_loc_sp->GetAddress().CalculateSymbolContext(&old_sc) == 702 new_loc_sp->GetAddress().CalculateSymbolContext(&new_sc)) { 703 equivalent_locations = 704 SymbolContextsMightBeEquivalent(old_sc, new_sc); 705 } 706 707 if (equivalent_locations) { 708 m_locations.SwapLocation(old_loc_sp, new_loc_sp); 709 } else { 710 locations_to_remove.Add(old_loc_sp); 711 locations_to_announce.Add(new_loc_sp); 712 } 713 } else { 714 // We don't want to have to keep computing the SymbolContexts for these 715 // addresses over and over, so lets get them up front: 716 717 typedef std::map<lldb::break_id_t, SymbolContext> IDToSCMap; 718 IDToSCMap old_sc_map; 719 for (size_t idx = 0; idx < num_old_locations; idx++) { 720 SymbolContext sc; 721 BreakpointLocationSP bp_loc_sp = old_break_locs.GetByIndex(idx); 722 lldb::break_id_t loc_id = bp_loc_sp->GetID(); 723 bp_loc_sp->GetAddress().CalculateSymbolContext(&old_sc_map[loc_id]); 724 } 725 726 std::map<lldb::break_id_t, SymbolContext> new_sc_map; 727 for (size_t idx = 0; idx < num_new_locations; idx++) { 728 SymbolContext sc; 729 BreakpointLocationSP bp_loc_sp = new_break_locs.GetByIndex(idx); 730 lldb::break_id_t loc_id = bp_loc_sp->GetID(); 731 bp_loc_sp->GetAddress().CalculateSymbolContext(&new_sc_map[loc_id]); 732 } 733 // Take an element from the old Symbol Contexts 734 while (old_sc_map.size() > 0) { 735 lldb::break_id_t old_id = old_sc_map.begin()->first; 736 SymbolContext &old_sc = old_sc_map.begin()->second; 737 738 // Count the number of entries equivalent to this SC for the old 739 // list: 740 std::vector<lldb::break_id_t> old_id_vec; 741 old_id_vec.push_back(old_id); 742 743 IDToSCMap::iterator tmp_iter; 744 for (tmp_iter = ++old_sc_map.begin(); tmp_iter != old_sc_map.end(); 745 tmp_iter++) { 746 if (SymbolContextsMightBeEquivalent(old_sc, tmp_iter->second)) 747 old_id_vec.push_back(tmp_iter->first); 748 } 749 750 // Now find all the equivalent locations in the new list. 751 std::vector<lldb::break_id_t> new_id_vec; 752 for (tmp_iter = new_sc_map.begin(); tmp_iter != new_sc_map.end(); 753 tmp_iter++) { 754 if (SymbolContextsMightBeEquivalent(old_sc, tmp_iter->second)) 755 new_id_vec.push_back(tmp_iter->first); 756 } 757 758 // Alright, if we have the same number of potentially equivalent 759 // locations in the old and new modules, we'll just map them one to 760 // one in ascending ID order (assuming the resolver's order would 761 // match the equivalent ones. Otherwise, we'll dump all the old ones, 762 // and just take the new ones, erasing the elements from both maps as 763 // we go. 764 765 if (old_id_vec.size() == new_id_vec.size()) { 766 llvm::sort(old_id_vec); 767 llvm::sort(new_id_vec); 768 size_t num_elements = old_id_vec.size(); 769 for (size_t idx = 0; idx < num_elements; idx++) { 770 BreakpointLocationSP old_loc_sp = 771 old_break_locs.FindByIDPair(GetID(), old_id_vec[idx]); 772 BreakpointLocationSP new_loc_sp = 773 new_break_locs.FindByIDPair(GetID(), new_id_vec[idx]); 774 m_locations.SwapLocation(old_loc_sp, new_loc_sp); 775 old_sc_map.erase(old_id_vec[idx]); 776 new_sc_map.erase(new_id_vec[idx]); 777 } 778 } else { 779 for (lldb::break_id_t old_id : old_id_vec) { 780 locations_to_remove.Add( 781 old_break_locs.FindByIDPair(GetID(), old_id)); 782 old_sc_map.erase(old_id); 783 } 784 for (lldb::break_id_t new_id : new_id_vec) { 785 locations_to_announce.Add( 786 new_break_locs.FindByIDPair(GetID(), new_id)); 787 new_sc_map.erase(new_id); 788 } 789 } 790 } 791 } 792 } 793 794 // Now remove the remaining old locations, and cons up a removed locations 795 // event. Note, we don't put the new locations that were swapped with an 796 // old location on the locations_to_remove list, so we don't need to worry 797 // about telling the world about removing a location we didn't tell them 798 // about adding. 799 800 BreakpointEventData *locations_event; 801 if (!IsInternal()) 802 locations_event = new BreakpointEventData( 803 eBreakpointEventTypeLocationsRemoved, shared_from_this()); 804 else 805 locations_event = nullptr; 806 807 for (BreakpointLocationSP loc_sp : 808 locations_to_remove.BreakpointLocations()) { 809 m_locations.RemoveLocation(loc_sp); 810 if (locations_event) 811 locations_event->GetBreakpointLocationCollection().Add(loc_sp); 812 } 813 SendBreakpointChangedEvent(locations_event); 814 815 // And announce the new ones. 816 817 if (!IsInternal()) { 818 locations_event = new BreakpointEventData( 819 eBreakpointEventTypeLocationsAdded, shared_from_this()); 820 for (BreakpointLocationSP loc_sp : 821 locations_to_announce.BreakpointLocations()) 822 locations_event->GetBreakpointLocationCollection().Add(loc_sp); 823 824 SendBreakpointChangedEvent(locations_event); 825 } 826 m_locations.Compact(); 827 } 828 } 829 830 void Breakpoint::Dump(Stream *) {} 831 832 size_t Breakpoint::GetNumResolvedLocations() const { 833 // Return the number of breakpoints that are actually resolved and set down 834 // in the inferior process. 835 return m_locations.GetNumResolvedLocations(); 836 } 837 838 bool Breakpoint::HasResolvedLocations() const { 839 return GetNumResolvedLocations() > 0; 840 } 841 842 size_t Breakpoint::GetNumLocations() const { return m_locations.GetSize(); } 843 844 bool Breakpoint::AddName(llvm::StringRef new_name) { 845 m_name_list.insert(new_name.str().c_str()); 846 return true; 847 } 848 849 void Breakpoint::GetDescription(Stream *s, lldb::DescriptionLevel level, 850 bool show_locations) { 851 assert(s != nullptr); 852 853 if (!m_kind_description.empty()) { 854 if (level == eDescriptionLevelBrief) { 855 s->PutCString(GetBreakpointKind()); 856 return; 857 } else 858 s->Printf("Kind: %s\n", GetBreakpointKind()); 859 } 860 861 const size_t num_locations = GetNumLocations(); 862 const size_t num_resolved_locations = GetNumResolvedLocations(); 863 864 // They just made the breakpoint, they don't need to be told HOW they made 865 // it... Also, we'll print the breakpoint number differently depending on 866 // whether there is 1 or more locations. 867 if (level != eDescriptionLevelInitial) { 868 s->Printf("%i: ", GetID()); 869 GetResolverDescription(s); 870 GetFilterDescription(s); 871 } 872 873 switch (level) { 874 case lldb::eDescriptionLevelBrief: 875 case lldb::eDescriptionLevelFull: 876 if (num_locations > 0) { 877 s->Printf(", locations = %" PRIu64, (uint64_t)num_locations); 878 if (num_resolved_locations > 0) 879 s->Printf(", resolved = %" PRIu64 ", hit count = %d", 880 (uint64_t)num_resolved_locations, GetHitCount()); 881 } else { 882 // Don't print the pending notification for exception resolvers since we 883 // don't generally know how to set them until the target is run. 884 if (m_resolver_sp->getResolverID() != 885 BreakpointResolver::ExceptionResolver) 886 s->Printf(", locations = 0 (pending)"); 887 } 888 889 m_options.GetDescription(s, level); 890 891 if (m_precondition_sp) 892 m_precondition_sp->GetDescription(*s, level); 893 894 if (level == lldb::eDescriptionLevelFull) { 895 if (!m_name_list.empty()) { 896 s->EOL(); 897 s->Indent(); 898 s->Printf("Names:"); 899 s->EOL(); 900 s->IndentMore(); 901 for (std::string name : m_name_list) { 902 s->Indent(); 903 s->Printf("%s\n", name.c_str()); 904 } 905 s->IndentLess(); 906 } 907 s->IndentLess(); 908 s->EOL(); 909 } 910 break; 911 912 case lldb::eDescriptionLevelInitial: 913 s->Printf("Breakpoint %i: ", GetID()); 914 if (num_locations == 0) { 915 s->Printf("no locations (pending)."); 916 } else if (num_locations == 1 && !show_locations) { 917 // There is only one location, so we'll just print that location 918 // information. 919 GetLocationAtIndex(0)->GetDescription(s, level); 920 } else { 921 s->Printf("%" PRIu64 " locations.", static_cast<uint64_t>(num_locations)); 922 } 923 s->EOL(); 924 break; 925 926 case lldb::eDescriptionLevelVerbose: 927 // Verbose mode does a debug dump of the breakpoint 928 Dump(s); 929 s->EOL(); 930 // s->Indent(); 931 m_options.GetDescription(s, level); 932 break; 933 934 default: 935 break; 936 } 937 938 // The brief description is just the location name (1.2 or whatever). That's 939 // pointless to show in the breakpoint's description, so suppress it. 940 if (show_locations && level != lldb::eDescriptionLevelBrief) { 941 s->IndentMore(); 942 for (size_t i = 0; i < num_locations; ++i) { 943 BreakpointLocation *loc = GetLocationAtIndex(i).get(); 944 loc->GetDescription(s, level); 945 s->EOL(); 946 } 947 s->IndentLess(); 948 } 949 } 950 951 void Breakpoint::GetResolverDescription(Stream *s) { 952 if (m_resolver_sp) 953 m_resolver_sp->GetDescription(s); 954 } 955 956 bool Breakpoint::GetMatchingFileLine(ConstString filename, 957 uint32_t line_number, 958 BreakpointLocationCollection &loc_coll) { 959 // TODO: To be correct, this method needs to fill the breakpoint location 960 // collection 961 // with the location IDs which match the filename and line_number. 962 // 963 964 if (m_resolver_sp) { 965 BreakpointResolverFileLine *resolverFileLine = 966 dyn_cast<BreakpointResolverFileLine>(m_resolver_sp.get()); 967 968 // TODO: Handle SourceLocationSpec column information 969 if (resolverFileLine && 970 resolverFileLine->m_location_spec.GetFileSpec().GetFilename() == 971 filename && 972 resolverFileLine->m_location_spec.GetLine() == line_number) { 973 return true; 974 } 975 } 976 return false; 977 } 978 979 void Breakpoint::GetFilterDescription(Stream *s) { 980 m_filter_sp->GetDescription(s); 981 } 982 983 bool Breakpoint::EvaluatePrecondition(StoppointCallbackContext &context) { 984 if (!m_precondition_sp) 985 return true; 986 987 return m_precondition_sp->EvaluatePrecondition(context); 988 } 989 990 void Breakpoint::SendBreakpointChangedEvent( 991 lldb::BreakpointEventType eventKind) { 992 if (!m_being_created && !IsInternal() && 993 GetTarget().EventTypeHasListeners( 994 Target::eBroadcastBitBreakpointChanged)) { 995 BreakpointEventData *data = 996 new Breakpoint::BreakpointEventData(eventKind, shared_from_this()); 997 998 GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, data); 999 } 1000 } 1001 1002 void Breakpoint::SendBreakpointChangedEvent(BreakpointEventData *data) { 1003 if (data == nullptr) 1004 return; 1005 1006 if (!m_being_created && !IsInternal() && 1007 GetTarget().EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged)) 1008 GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged, data); 1009 else 1010 delete data; 1011 } 1012 1013 const char *Breakpoint::BreakpointEventTypeAsCString(BreakpointEventType type) { 1014 switch (type) { 1015 case eBreakpointEventTypeInvalidType: return "invalid"; 1016 case eBreakpointEventTypeAdded: return "breakpoint added"; 1017 case eBreakpointEventTypeRemoved: return "breakpoint removed"; 1018 case eBreakpointEventTypeLocationsAdded: return "locations added"; 1019 case eBreakpointEventTypeLocationsRemoved: return "locations removed"; 1020 case eBreakpointEventTypeLocationsResolved: return "locations resolved"; 1021 case eBreakpointEventTypeEnabled: return "breakpoint enabled"; 1022 case eBreakpointEventTypeDisabled: return "breakpoint disabled"; 1023 case eBreakpointEventTypeCommandChanged: return "command changed"; 1024 case eBreakpointEventTypeConditionChanged: return "condition changed"; 1025 case eBreakpointEventTypeIgnoreChanged: return "ignore count changed"; 1026 case eBreakpointEventTypeThreadChanged: return "thread changed"; 1027 case eBreakpointEventTypeAutoContinueChanged: return "autocontinue changed"; 1028 }; 1029 llvm_unreachable("Fully covered switch above!"); 1030 } 1031 1032 Log *Breakpoint::BreakpointEventData::GetLogChannel() { 1033 return GetLog(LLDBLog::Breakpoints); 1034 } 1035 1036 Breakpoint::BreakpointEventData::BreakpointEventData( 1037 BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp) 1038 : m_breakpoint_event(sub_type), m_new_breakpoint_sp(new_breakpoint_sp) {} 1039 1040 Breakpoint::BreakpointEventData::~BreakpointEventData() = default; 1041 1042 ConstString Breakpoint::BreakpointEventData::GetFlavorString() { 1043 static ConstString g_flavor("Breakpoint::BreakpointEventData"); 1044 return g_flavor; 1045 } 1046 1047 ConstString Breakpoint::BreakpointEventData::GetFlavor() const { 1048 return BreakpointEventData::GetFlavorString(); 1049 } 1050 1051 BreakpointSP Breakpoint::BreakpointEventData::GetBreakpoint() const { 1052 return m_new_breakpoint_sp; 1053 } 1054 1055 BreakpointEventType 1056 Breakpoint::BreakpointEventData::GetBreakpointEventType() const { 1057 return m_breakpoint_event; 1058 } 1059 1060 void Breakpoint::BreakpointEventData::Dump(Stream *s) const { 1061 if (!s) 1062 return; 1063 BreakpointEventType event_type = GetBreakpointEventType(); 1064 break_id_t bkpt_id = GetBreakpoint()->GetID(); 1065 s->Format("bkpt: {0} type: {1}", bkpt_id, 1066 BreakpointEventTypeAsCString(event_type)); 1067 } 1068 1069 const Breakpoint::BreakpointEventData * 1070 Breakpoint::BreakpointEventData::GetEventDataFromEvent(const Event *event) { 1071 if (event) { 1072 const EventData *event_data = event->GetData(); 1073 if (event_data && 1074 event_data->GetFlavor() == BreakpointEventData::GetFlavorString()) 1075 return static_cast<const BreakpointEventData *>(event->GetData()); 1076 } 1077 return nullptr; 1078 } 1079 1080 BreakpointEventType 1081 Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent( 1082 const EventSP &event_sp) { 1083 const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); 1084 1085 if (data == nullptr) 1086 return eBreakpointEventTypeInvalidType; 1087 else 1088 return data->GetBreakpointEventType(); 1089 } 1090 1091 BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent( 1092 const EventSP &event_sp) { 1093 BreakpointSP bp_sp; 1094 1095 const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); 1096 if (data) 1097 bp_sp = data->m_new_breakpoint_sp; 1098 1099 return bp_sp; 1100 } 1101 1102 size_t Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent( 1103 const EventSP &event_sp) { 1104 const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); 1105 if (data) 1106 return data->m_locations.GetSize(); 1107 1108 return 0; 1109 } 1110 1111 lldb::BreakpointLocationSP 1112 Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent( 1113 const lldb::EventSP &event_sp, uint32_t bp_loc_idx) { 1114 lldb::BreakpointLocationSP bp_loc_sp; 1115 1116 const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get()); 1117 if (data) { 1118 bp_loc_sp = data->m_locations.GetByIndex(bp_loc_idx); 1119 } 1120 1121 return bp_loc_sp; 1122 } 1123 1124 json::Value Breakpoint::GetStatistics() { 1125 json::Object bp; 1126 bp.try_emplace("id", GetID()); 1127 bp.try_emplace("resolveTime", m_resolve_time.get().count()); 1128 bp.try_emplace("numLocations", (int64_t)GetNumLocations()); 1129 bp.try_emplace("numResolvedLocations", (int64_t)GetNumResolvedLocations()); 1130 bp.try_emplace("internal", IsInternal()); 1131 if (!m_kind_description.empty()) 1132 bp.try_emplace("kindDescription", m_kind_description); 1133 // Put the full structured data for reproducing this breakpoint in a key/value 1134 // pair named "details". This allows the breakpoint's details to be visible 1135 // in the stats in case we need to reproduce a breakpoint that has long 1136 // resolve times 1137 StructuredData::ObjectSP bp_data_sp = SerializeToStructuredData(); 1138 if (bp_data_sp) { 1139 std::string buffer; 1140 llvm::raw_string_ostream ss(buffer); 1141 json::OStream json_os(ss); 1142 bp_data_sp->Serialize(json_os); 1143 if (auto expected_value = llvm::json::parse(ss.str())) { 1144 bp.try_emplace("details", std::move(*expected_value)); 1145 } else { 1146 std::string details_error = toString(expected_value.takeError()); 1147 json::Object details; 1148 details.try_emplace("error", details_error); 1149 bp.try_emplace("details", std::move(details)); 1150 } 1151 } 1152 return json::Value(std::move(bp)); 1153 } 1154