lldb/source/Breakpoint/Breakpoint.cpp

   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 const char *Breakpoint::g_option_names[static_cast<uint32_t>(
  41     Breakpoint::OptionNames::LastOptionName)]{"Names", "Hardware"};
  42
  43 // Breakpoint constructor
  44 Breakpoint::Breakpoint(Target &target, SearchFilterSP &filter_sp,
  45                        BreakpointResolverSP &resolver_sp, bool hardware,
  46                        bool resolve_indirect_symbols)
  47     : m_being_created(true), m_hardware(hardware), m_target(target),
  48       m_filter_sp(filter_sp), m_resolver_sp(resolver_sp), m_options(true),
  49       m_locations(*this), m_resolve_indirect_symbols(resolve_indirect_symbols),
  50       m_hit_counter() {
  51   m_being_created = false;
  52 }
  53
  54 Breakpoint::Breakpoint(Target &new_target, const Breakpoint &source_bp)
  55     : m_being_created(true), m_hardware(source_bp.m_hardware),
  56       m_target(new_target), m_name_list(source_bp.m_name_list),
  57       m_options(source_bp.m_options), m_locations(*this),
  58       m_resolve_indirect_symbols(source_bp.m_resolve_indirect_symbols),
  59       m_hit_counter() {}
  60
  61 // Destructor
  62 Breakpoint::~Breakpoint() = default;
  63
  64 BreakpointSP Breakpoint::CopyFromBreakpoint(TargetSP new_target,
  65     const Breakpoint& bp_to_copy_from) {
  66   if (!new_target)
  67     return BreakpointSP();
  68
  69   BreakpointSP bp(new Breakpoint(*new_target, bp_to_copy_from));
  70   // Now go through and copy the filter & resolver:
  71   bp->m_resolver_sp = bp_to_copy_from.m_resolver_sp->CopyForBreakpoint(bp);
  72   bp->m_filter_sp = bp_to_copy_from.m_filter_sp->CreateCopy(new_target);
  73   return bp;
  74 }
  75
  76 // Serialization
  77 StructuredData::ObjectSP Breakpoint::SerializeToStructuredData() {
  78   // Serialize the resolver:
  79   StructuredData::DictionarySP breakpoint_dict_sp(
  80       new StructuredData::Dictionary());
  81   StructuredData::DictionarySP breakpoint_contents_sp(
  82       new StructuredData::Dictionary());
  83
  84   if (!m_name_list.empty()) {
  85     StructuredData::ArraySP names_array_sp(new StructuredData::Array());
  86     for (auto name : m_name_list) {
  87       names_array_sp->AddItem(
  88           StructuredData::StringSP(new StructuredData::String(name)));
  89     }
  90     breakpoint_contents_sp->AddItem(Breakpoint::GetKey(OptionNames::Names),
  91                                     names_array_sp);
  92   }
  93
  94   breakpoint_contents_sp->AddBooleanItem(
  95       Breakpoint::GetKey(OptionNames::Hardware), m_hardware);
  96
  97   StructuredData::ObjectSP resolver_dict_sp(
  98       m_resolver_sp->SerializeToStructuredData());
  99   if (!resolver_dict_sp)
 100     return StructuredData::ObjectSP();
 101
 102   breakpoint_contents_sp->AddItem(BreakpointResolver::GetSerializationKey(),
 103                                   resolver_dict_sp);
 104
 105   StructuredData::ObjectSP filter_dict_sp(
 106       m_filter_sp->SerializeToStructuredData());
 107   if (!filter_dict_sp)
 108     return StructuredData::ObjectSP();
 109
 110   breakpoint_contents_sp->AddItem(SearchFilter::GetSerializationKey(),
 111                                   filter_dict_sp);
 112
 113   StructuredData::ObjectSP options_dict_sp(
 114       m_options.SerializeToStructuredData());
 115   if (!options_dict_sp)
 116     return StructuredData::ObjectSP();
 117
 118   breakpoint_contents_sp->AddItem(BreakpointOptions::GetSerializationKey(),
 119                                   options_dict_sp);
 120
 121   breakpoint_dict_sp->AddItem(GetSerializationKey(), breakpoint_contents_sp);
 122   return breakpoint_dict_sp;
 123 }
 124
 125 lldb::BreakpointSP Breakpoint::CreateFromStructuredData(
 126     TargetSP target_sp, StructuredData::ObjectSP &object_data, Status &error) {
 127   BreakpointSP result_sp;
 128   if (!target_sp)
 129     return result_sp;
 130
 131   StructuredData::Dictionary *breakpoint_dict = object_data->GetAsDictionary();
 132
 133   if (!breakpoint_dict || !breakpoint_dict->IsValid()) {
 134     error.SetErrorString("Can't deserialize from an invalid data object.");
 135     return result_sp;
 136   }
 137
 138   StructuredData::Dictionary *resolver_dict;
 139   bool success = breakpoint_dict->GetValueForKeyAsDictionary(
 140       BreakpointResolver::GetSerializationKey(), resolver_dict);
 141   if (!success) {
 142     error.SetErrorString("Breakpoint data missing toplevel resolver key");
 143     return result_sp;
 144   }
 145
 146   Status create_error;
 147   BreakpointResolverSP resolver_sp =
 148       BreakpointResolver::CreateFromStructuredData(*resolver_dict,
 149                                                    create_error);
 150   if (create_error.Fail()) {
 151     error.SetErrorStringWithFormat(
 152         "Error creating breakpoint resolver from data: %s.",
 153         create_error.AsCString());
 154     return result_sp;
 155   }
 156
 157   StructuredData::Dictionary *filter_dict;
 158   success = breakpoint_dict->GetValueForKeyAsDictionary(
 159       SearchFilter::GetSerializationKey(), filter_dict);
 160   SearchFilterSP filter_sp;
 161   if (!success)
 162     filter_sp =
 163         std::make_shared<SearchFilterForUnconstrainedSearches>(target_sp);
 164   else {
 165     filter_sp = SearchFilter::CreateFromStructuredData(target_sp, *filter_dict,
 166         create_error);
 167     if (create_error.Fail()) {
 168       error.SetErrorStringWithFormat(
 169           "Error creating breakpoint filter from data: %s.",
 170           create_error.AsCString());
 171       return result_sp;
 172     }
 173   }
 174
 175   std::unique_ptr<BreakpointOptions> options_up;
 176   StructuredData::Dictionary *options_dict;
 177   Target& target = *target_sp;
 178   success = breakpoint_dict->GetValueForKeyAsDictionary(
 179       BreakpointOptions::GetSerializationKey(), options_dict);
 180   if (success) {
 181     options_up = BreakpointOptions::CreateFromStructuredData(
 182         target, *options_dict, create_error);
 183     if (create_error.Fail()) {
 184       error.SetErrorStringWithFormat(
 185           "Error creating breakpoint options from data: %s.",
 186           create_error.AsCString());
 187       return result_sp;
 188     }
 189   }
 190
 191   bool hardware = false;
 192   success = breakpoint_dict->GetValueForKeyAsBoolean(
 193       Breakpoint::GetKey(OptionNames::Hardware), hardware);
 194
 195   result_sp = target.CreateBreakpoint(filter_sp, resolver_sp, false,
 196                                       hardware, true);
 197
 198   if (result_sp && options_up) {
 199     result_sp->m_options = *options_up;
 200   }
 201
 202   StructuredData::Array *names_array;
 203   success = breakpoint_dict->GetValueForKeyAsArray(
 204       Breakpoint::GetKey(OptionNames::Names), names_array);
 205   if (success && names_array) {
 206     size_t num_names = names_array->GetSize();
 207     for (size_t i = 0; i < num_names; i++) {
 208       llvm::StringRef name;
 209       Status error;
 210       success = names_array->GetItemAtIndexAsString(i, name);
 211       target.AddNameToBreakpoint(result_sp, name.str().c_str(), error);
 212     }
 213   }
 214
 215   return result_sp;
 216 }
 217
 218 bool Breakpoint::SerializedBreakpointMatchesNames(
 219     StructuredData::ObjectSP &bkpt_object_sp, std::vector<std::string> &names) {
 220   if (!bkpt_object_sp)
 221     return false;
 222
 223   StructuredData::Dictionary *bkpt_dict = bkpt_object_sp->GetAsDictionary();
 224   if (!bkpt_dict)
 225     return false;
 226
 227   if (names.empty())
 228     return true;
 229
 230   StructuredData::Array *names_array;
 231
 232   bool success =
 233       bkpt_dict->GetValueForKeyAsArray(GetKey(OptionNames::Names), names_array);
 234   // If there are no names, it can't match these names;
 235   if (!success)
 236     return false;
 237
 238   size_t num_names = names_array->GetSize();
 239
 240   for (size_t i = 0; i < num_names; i++) {
 241     llvm::StringRef name;
 242     if (names_array->GetItemAtIndexAsString(i, name)) {
 243       if (llvm::is_contained(names, name))
 244         return true;
 245     }
 246   }
 247   return false;
 248 }
 249
 250 const lldb::TargetSP Breakpoint::GetTargetSP() {
 251   return m_target.shared_from_this();
 252 }
 253
 254 bool Breakpoint::IsInternal() const { return LLDB_BREAK_ID_IS_INTERNAL(m_bid); }
 255
 256 BreakpointLocationSP Breakpoint::AddLocation(const Address &addr,
 257                                              bool *new_location) {
 258   return m_locations.AddLocation(addr, m_resolve_indirect_symbols,
 259                                  new_location);
 260 }
 261
 262 BreakpointLocationSP Breakpoint::FindLocationByAddress(const Address &addr) {
 263   return m_locations.FindByAddress(addr);
 264 }
 265
 266 break_id_t Breakpoint::FindLocationIDByAddress(const Address &addr) {
 267   return m_locations.FindIDByAddress(addr);
 268 }
 269
 270 BreakpointLocationSP Breakpoint::FindLocationByID(break_id_t bp_loc_id) {
 271   return m_locations.FindByID(bp_loc_id);
 272 }
 273
 274 BreakpointLocationSP Breakpoint::GetLocationAtIndex(size_t index) {
 275   return m_locations.GetByIndex(index);
 276 }
 277
 278 void Breakpoint::RemoveInvalidLocations(const ArchSpec &arch) {
 279   m_locations.RemoveInvalidLocations(arch);
 280 }
 281
 282 // For each of the overall options we need to decide how they propagate to the
 283 // location options.  This will determine the precedence of options on the
 284 // breakpoint vs. its locations.
 285
 286 // Disable at the breakpoint level should override the location settings. That
 287 // way you can conveniently turn off a whole breakpoint without messing up the
 288 // individual settings.
 289
 290 void Breakpoint::SetEnabled(bool enable) {
 291   if (enable == m_options.IsEnabled())
 292     return;
 293
 294   m_options.SetEnabled(enable);
 295   if (enable)
 296     m_locations.ResolveAllBreakpointSites();
 297   else
 298     m_locations.ClearAllBreakpointSites();
 299
 300   SendBreakpointChangedEvent(enable ? eBreakpointEventTypeEnabled
 301                                     : eBreakpointEventTypeDisabled);
 302 }
 303
 304 bool Breakpoint::IsEnabled() { return m_options.IsEnabled(); }
 305
 306 void Breakpoint::SetIgnoreCount(uint32_t n) {
 307   if (m_options.GetIgnoreCount() == n)
 308     return;
 309
 310   m_options.SetIgnoreCount(n);
 311   SendBreakpointChangedEvent(eBreakpointEventTypeIgnoreChanged);
 312 }
 313
 314 void Breakpoint::DecrementIgnoreCount() {
 315   uint32_t ignore = m_options.GetIgnoreCount();
 316   if (ignore != 0)
 317     m_options.SetIgnoreCount(ignore - 1);
 318 }
 319
 320 uint32_t Breakpoint::GetIgnoreCount() const {
 321   return m_options.GetIgnoreCount();
 322 }
 323
 324 uint32_t Breakpoint::GetHitCount() const { return m_hit_counter.GetValue(); }
 325
 326 void Breakpoint::ResetHitCount() {
 327   m_hit_counter.Reset();
 328   m_locations.ResetHitCount();
 329 }
 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 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());
 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 llvm::StringRef Breakpoint::BreakpointEventData::GetFlavorString() {
1043   return "Breakpoint::BreakpointEventData";
1044 }
1045
1046 llvm::StringRef Breakpoint::BreakpointEventData::GetFlavor() const {
1047   return BreakpointEventData::GetFlavorString();
1048 }
1049
1050 BreakpointSP Breakpoint::BreakpointEventData::GetBreakpoint() const {
1051   return m_new_breakpoint_sp;
1052 }
1053
1054 BreakpointEventType
1055 Breakpoint::BreakpointEventData::GetBreakpointEventType() const {
1056   return m_breakpoint_event;
1057 }
1058
1059 void Breakpoint::BreakpointEventData::Dump(Stream *s) const {
1060   if (!s)
1061     return;
1062   BreakpointEventType event_type = GetBreakpointEventType();
1063   break_id_t bkpt_id = GetBreakpoint()->GetID();
1064   s->Format("bkpt: {0} type: {1}", bkpt_id,
1065       BreakpointEventTypeAsCString(event_type));
1066 }
1067
1068 const Breakpoint::BreakpointEventData *
1069 Breakpoint::BreakpointEventData::GetEventDataFromEvent(const Event *event) {
1070   if (event) {
1071     const EventData *event_data = event->GetData();
1072     if (event_data &&
1073         event_data->GetFlavor() == BreakpointEventData::GetFlavorString())
1074       return static_cast<const BreakpointEventData *>(event->GetData());
1075   }
1076   return nullptr;
1077 }
1078
1079 BreakpointEventType
1080 Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
1081     const EventSP &event_sp) {
1082   const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
1083
1084   if (data == nullptr)
1085     return eBreakpointEventTypeInvalidType;
1086   else
1087     return data->GetBreakpointEventType();
1088 }
1089
1090 BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
1091     const EventSP &event_sp) {
1092   BreakpointSP bp_sp;
1093
1094   const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
1095   if (data)
1096     bp_sp = data->m_new_breakpoint_sp;
1097
1098   return bp_sp;
1099 }
1100
1101 size_t Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
1102     const EventSP &event_sp) {
1103   const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
1104   if (data)
1105     return data->m_locations.GetSize();
1106
1107   return 0;
1108 }
1109
1110 lldb::BreakpointLocationSP
1111 Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent(
1112     const lldb::EventSP &event_sp, uint32_t bp_loc_idx) {
1113   lldb::BreakpointLocationSP bp_loc_sp;
1114
1115   const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
1116   if (data) {
1117     bp_loc_sp = data->m_locations.GetByIndex(bp_loc_idx);
1118   }
1119
1120   return bp_loc_sp;
1121 }
1122
1123 json::Value Breakpoint::GetStatistics() {
1124   json::Object bp;
1125   bp.try_emplace("id", GetID());
1126   bp.try_emplace("resolveTime", m_resolve_time.get().count());
1127   bp.try_emplace("numLocations", (int64_t)GetNumLocations());
1128   bp.try_emplace("numResolvedLocations", (int64_t)GetNumResolvedLocations());
1129   bp.try_emplace("hitCount", (int64_t)GetHitCount());
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 }