lldb/source/Breakpoint/BreakpointResolver.cpp

   1 //===-- BreakpointResolver.cpp --------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Breakpoint/BreakpointResolver.h"
  10
  11 #include "lldb/Breakpoint/Breakpoint.h"
  12 #include "lldb/Breakpoint/BreakpointLocation.h"
  13 // Have to include the other breakpoint resolver types here so the static
  14 // create from StructuredData can call them.
  15 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
  16 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
  17 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
  18 #include "lldb/Breakpoint/BreakpointResolverName.h"
  19 #include "lldb/Breakpoint/BreakpointResolverScripted.h"
  20 #include "lldb/Core/Address.h"
  21 #include "lldb/Core/ModuleList.h"
  22 #include "lldb/Core/SearchFilter.h"
  23 #include "lldb/Symbol/CompileUnit.h"
  24 #include "lldb/Symbol/Function.h"
  25 #include "lldb/Symbol/SymbolContext.h"
  26 #include "lldb/Target/Language.h"
  27 #include "lldb/Target/Target.h"
  28 #include "lldb/Utility/LLDBLog.h"
  29 #include "lldb/Utility/Log.h"
  30 #include "lldb/Utility/Stream.h"
  31 #include "lldb/Utility/StreamString.h"
  32 #include <optional>
  33
  34 using namespace lldb_private;
  35 using namespace lldb;
  36
  37 // BreakpointResolver:
  38 const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
  39                                                   "SymbolName",  "SourceRegex",
  40                                                   "Python",   "Exception",
  41                                                   "Unknown"};
  42
  43 const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
  44     BreakpointResolver::OptionNames::LastOptionName)] = {
  45     "AddressOffset", "Exact",     "FileName",     "Inlines",     "Language",
  46     "LineNumber",    "Column",    "ModuleName",   "NameMask",    "Offset",
  47     "PythonClass",   "Regex",     "ScriptArgs",   "SectionName", "SearchDepth",
  48     "SkipPrologue",  "SymbolNames"};
  49
  50 const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
  51   if (type > LastKnownResolverType)
  52     return g_ty_to_name[UnknownResolver];
  53
  54   return g_ty_to_name[type];
  55 }
  56
  57 BreakpointResolver::ResolverTy
  58 BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
  59   for (size_t i = 0; i < LastKnownResolverType; i++) {
  60     if (name == g_ty_to_name[i])
  61       return (ResolverTy)i;
  62   }
  63   return UnknownResolver;
  64 }
  65
  66 BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt,
  67                                        const unsigned char resolverTy,
  68                                        lldb::addr_t offset)
  69     : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
  70
  71 BreakpointResolver::~BreakpointResolver() = default;
  72
  73 BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
  74     const StructuredData::Dictionary &resolver_dict, Status &error) {
  75   BreakpointResolverSP result_sp;
  76   if (!resolver_dict.IsValid()) {
  77     error = Status::FromErrorString(
  78         "Can't deserialize from an invalid data object.");
  79     return result_sp;
  80   }
  81
  82   llvm::StringRef subclass_name;
  83
  84   bool success = resolver_dict.GetValueForKeyAsString(
  85       GetSerializationSubclassKey(), subclass_name);
  86
  87   if (!success) {
  88     error =
  89         Status::FromErrorString("Resolver data missing subclass resolver key");
  90     return result_sp;
  91   }
  92
  93   ResolverTy resolver_type = NameToResolverTy(subclass_name);
  94   if (resolver_type == UnknownResolver) {
  95     error = Status::FromErrorStringWithFormatv("Unknown resolver type: {0}.",
  96                                                subclass_name);
  97     return result_sp;
  98   }
  99
 100   StructuredData::Dictionary *subclass_options = nullptr;
 101   success = resolver_dict.GetValueForKeyAsDictionary(
 102       GetSerializationSubclassOptionsKey(), subclass_options);
 103   if (!success || !subclass_options || !subclass_options->IsValid()) {
 104     error =
 105         Status::FromErrorString("Resolver data missing subclass options key.");
 106     return result_sp;
 107   }
 108
 109   lldb::offset_t offset;
 110   success = subclass_options->GetValueForKeyAsInteger(
 111       GetKey(OptionNames::Offset), offset);
 112   if (!success) {
 113     error =
 114         Status::FromErrorString("Resolver data missing offset options key.");
 115     return result_sp;
 116   }
 117
 118   switch (resolver_type) {
 119   case FileLineResolver:
 120     result_sp = BreakpointResolverFileLine::CreateFromStructuredData(
 121         *subclass_options, error);
 122     break;
 123   case AddressResolver:
 124     result_sp = BreakpointResolverAddress::CreateFromStructuredData(
 125         *subclass_options, error);
 126     break;
 127   case NameResolver:
 128     result_sp = BreakpointResolverName::CreateFromStructuredData(
 129         *subclass_options, error);
 130     break;
 131   case FileRegexResolver:
 132     result_sp = BreakpointResolverFileRegex::CreateFromStructuredData(
 133         *subclass_options, error);
 134     break;
 135   case PythonResolver:
 136     result_sp = BreakpointResolverScripted::CreateFromStructuredData(
 137         *subclass_options, error);
 138     break;
 139   case ExceptionResolver:
 140     error = Status::FromErrorString("Exception resolvers are hard.");
 141     break;
 142   default:
 143     llvm_unreachable("Should never get an unresolvable resolver type.");
 144   }
 145
 146   if (error.Fail() || !result_sp)
 147     return {};
 148
 149   // Add on the global offset option:
 150   result_sp->SetOffset(offset);
 151   return result_sp;
 152 }
 153
 154 StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
 155     StructuredData::DictionarySP options_dict_sp) {
 156   if (!options_dict_sp || !options_dict_sp->IsValid())
 157     return StructuredData::DictionarySP();
 158
 159   StructuredData::DictionarySP type_dict_sp(new StructuredData::Dictionary());
 160   type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName());
 161   type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
 162
 163   // Add the m_offset to the dictionary:
 164   options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
 165
 166   return type_dict_sp;
 167 }
 168
 169 void BreakpointResolver::SetBreakpoint(const BreakpointSP &bkpt) {
 170   assert(bkpt);
 171   m_breakpoint = bkpt;
 172   NotifyBreakpointSet();
 173 }
 174
 175 void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
 176                                                     ModuleList &modules) {
 177   filter.SearchInModuleList(*this, modules);
 178 }
 179
 180 void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
 181   filter.Search(*this);
 182 }
 183
 184 namespace {
 185 struct SourceLoc {
 186   uint32_t line = UINT32_MAX;
 187   uint16_t column;
 188   SourceLoc(uint32_t l, std::optional<uint16_t> c)
 189       : line(l), column(c ? *c : LLDB_INVALID_COLUMN_NUMBER) {}
 190   SourceLoc(const SymbolContext &sc)
 191       : line(sc.line_entry.line),
 192         column(sc.line_entry.column ? sc.line_entry.column
 193                                     : LLDB_INVALID_COLUMN_NUMBER) {}
 194 };
 195
 196 bool operator<(const SourceLoc lhs, const SourceLoc rhs) {
 197   if (lhs.line < rhs.line)
 198     return true;
 199   if (lhs.line > rhs.line)
 200     return false;
 201   //  uint32_t a_col = lhs.column ? lhs.column : LLDB_INVALID_COLUMN_NUMBER;
 202   //  uint32_t b_col = rhs.column ? rhs.column : LLDB_INVALID_COLUMN_NUMBER;
 203   return lhs.column < rhs.column;
 204 }
 205 } // namespace
 206
 207 void BreakpointResolver::SetSCMatchesByLine(
 208     SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue,
 209     llvm::StringRef log_ident, uint32_t line, std::optional<uint16_t> column) {
 210   llvm::SmallVector<SymbolContext, 16> all_scs;
 211
 212   for (const auto &sc : sc_list) {
 213     if (Language::GetGlobalLanguageProperties()
 214             .GetEnableFilterForLineBreakpoints())
 215       if (Language *lang = Language::FindPlugin(sc.GetLanguage());
 216           lang && lang->IgnoreForLineBreakpoints(sc))
 217         continue;
 218     all_scs.push_back(sc);
 219   }
 220
 221   while (all_scs.size()) {
 222     uint32_t closest_line = UINT32_MAX;
 223
 224     // Move all the elements with a matching file spec to the end.
 225     auto &match = all_scs[0];
 226     auto worklist_begin = std::partition(
 227         all_scs.begin(), all_scs.end(), [&](const SymbolContext &sc) {
 228           if (sc.line_entry.GetFile() == match.line_entry.GetFile() ||
 229               sc.line_entry.original_file_sp->Equal(
 230                   *match.line_entry.original_file_sp,
 231                   SupportFile::eEqualFileSpecAndChecksumIfSet)) {
 232             // When a match is found, keep track of the smallest line number.
 233             closest_line = std::min(closest_line, sc.line_entry.line);
 234             return false;
 235           }
 236           return true;
 237         });
 238
 239     // (worklist_begin, worklist_end) now contains all entries for one filespec.
 240     auto worklist_end = all_scs.end();
 241
 242     if (column) {
 243       // If a column was requested, do a more precise match and only
 244       // return the first location that comes before or at the
 245       // requested location.
 246       SourceLoc requested(line, *column);
 247       // First, filter out all entries left of the requested column.
 248       worklist_end = std::remove_if(
 249           worklist_begin, worklist_end,
 250           [&](const SymbolContext &sc) { return requested < SourceLoc(sc); });
 251       // Sort the remaining entries by (line, column).
 252       llvm::sort(worklist_begin, worklist_end,
 253                  [](const SymbolContext &a, const SymbolContext &b) {
 254                    return SourceLoc(a) < SourceLoc(b);
 255                  });
 256
 257       // Filter out all locations with a source location after the closest match.
 258       if (worklist_begin != worklist_end)
 259         worklist_end = std::remove_if(
 260             worklist_begin, worklist_end, [&](const SymbolContext &sc) {
 261               return SourceLoc(*worklist_begin) < SourceLoc(sc);
 262             });
 263     } else {
 264       // Remove all entries with a larger line number.
 265       // ResolveSymbolContext will always return a number that is >=
 266       // the line number you pass in. So the smaller line number is
 267       // always better.
 268       worklist_end = std::remove_if(worklist_begin, worklist_end,
 269                                     [&](const SymbolContext &sc) {
 270                                       return closest_line != sc.line_entry.line;
 271                                     });
 272     }
 273
 274     // Sort by file address.
 275     llvm::sort(worklist_begin, worklist_end,
 276                [](const SymbolContext &a, const SymbolContext &b) {
 277                  return a.line_entry.range.GetBaseAddress().GetFileAddress() <
 278                         b.line_entry.range.GetBaseAddress().GetFileAddress();
 279                });
 280
 281     // Go through and see if there are line table entries that are
 282     // contiguous, and if so keep only the first of the contiguous range.
 283     // We do this by picking the first location in each lexical block.
 284     llvm::SmallDenseSet<Block *, 8> blocks_with_breakpoints;
 285     for (auto first = worklist_begin; first != worklist_end; ++first) {
 286       assert(!blocks_with_breakpoints.count(first->block));
 287       blocks_with_breakpoints.insert(first->block);
 288       worklist_end =
 289           std::remove_if(std::next(first), worklist_end,
 290                          [&](const SymbolContext &sc) {
 291                            return blocks_with_breakpoints.count(sc.block);
 292                          });
 293     }
 294
 295     // Make breakpoints out of the closest line number match.
 296     for (auto &sc : llvm::make_range(worklist_begin, worklist_end))
 297       AddLocation(filter, sc, skip_prologue, log_ident);
 298
 299     // Remove all contexts processed by this iteration.
 300     all_scs.erase(worklist_begin, all_scs.end());
 301   }
 302 }
 303
 304 void BreakpointResolver::AddLocation(SearchFilter &filter,
 305                                      const SymbolContext &sc,
 306                                      bool skip_prologue,
 307                                      llvm::StringRef log_ident) {
 308   Log *log = GetLog(LLDBLog::Breakpoints);
 309   Address line_start = sc.line_entry.range.GetBaseAddress();
 310   if (!line_start.IsValid()) {
 311     LLDB_LOGF(log,
 312               "error: Unable to set breakpoint %s at file address "
 313               "0x%" PRIx64 "\n",
 314               log_ident.str().c_str(), line_start.GetFileAddress());
 315     return;
 316   }
 317
 318   if (!filter.AddressPasses(line_start)) {
 319     LLDB_LOGF(log,
 320               "Breakpoint %s at file address 0x%" PRIx64
 321               " didn't pass the filter.\n",
 322               log_ident.str().c_str(), line_start.GetFileAddress());
 323   }
 324
 325   // If the line number is before the prologue end, move it there...
 326   bool skipped_prologue = false;
 327   if (skip_prologue && sc.function) {
 328     Address prologue_addr(sc.function->GetAddressRange().GetBaseAddress());
 329     if (prologue_addr.IsValid() && (line_start == prologue_addr)) {
 330       const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
 331       if (prologue_byte_size) {
 332         prologue_addr.Slide(prologue_byte_size);
 333
 334         if (filter.AddressPasses(prologue_addr)) {
 335           skipped_prologue = true;
 336           line_start = prologue_addr;
 337         }
 338       }
 339     }
 340   }
 341
 342   BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
 343   // If the address that we resolved the location to returns a different
 344   // LineEntry from the one in the incoming SC, we're probably dealing with an
 345   // inlined call site, so set that as the preferred LineEntry:
 346   LineEntry resolved_entry;
 347   if (!skipped_prologue && bp_loc_sp &&
 348       line_start.CalculateSymbolContextLineEntry(resolved_entry) &&
 349       LineEntry::Compare(resolved_entry, sc.line_entry)) {
 350     // FIXME: The function name will also be wrong here.  Do we need to record
 351     // that as well, or can we figure that out again when we report this
 352     // breakpoint location.
 353     if (!bp_loc_sp->SetPreferredLineEntry(sc.line_entry)) {
 354       LLDB_LOG(log, "Tried to add a preferred line entry that didn't have the "
 355                     "same address as this location's address.");
 356     }
 357   }
 358   if (log && bp_loc_sp && !GetBreakpoint()->IsInternal()) {
 359     StreamString s;
 360     bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
 361     LLDB_LOGF(log, "Added location (skipped prologue: %s): %s \n",
 362               skipped_prologue ? "yes" : "no", s.GetData());
 363   }
 364 }
 365
 366 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
 367                                                      bool *new_location) {
 368   loc_addr.Slide(m_offset);
 369   return GetBreakpoint()->AddLocation(loc_addr, new_location);
 370 }
 371
 372 void BreakpointResolver::SetOffset(lldb::addr_t offset) {
 373   // There may already be an offset, so we are actually adjusting location
 374   // addresses by the difference.
 375   // lldb::addr_t slide = offset - m_offset;
 376   // FIXME: We should go fix up all the already set locations for the new
 377   // slide.
 378
 379   m_offset = offset;
 380 }