LLDB  mainline
BreakpointResolver.cpp
Go to the documentation of this file.
1 //===-- BreakpointResolver.cpp ----------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
13 // Have to include the other breakpoint resolver types here so the static
14 // create from StructuredData can call them.
20 #include "lldb/Core/Address.h"
21 #include "lldb/Core/ModuleList.h"
22 #include "lldb/Core/SearchFilter.h"
24 #include "lldb/Symbol/Function.h"
26 #include "lldb/Target/Target.h"
27 #include "lldb/Utility/Log.h"
28 #include "lldb/Utility/Stream.h"
30 
31 using namespace lldb_private;
32 using namespace lldb;
33 
34 // BreakpointResolver:
35 const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
36  "SymbolName", "SourceRegex",
37  "Exception", "Unknown"};
38 
39 const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
41  "AddressOffset", "Exact", "FileName", "Inlines", "Language",
42  "LineNumber", "Column", "ModuleName", "NameMask", "Offset",
43  "PythonClass", "Regex", "ScriptArgs", "SectionName", "SearchDepth",
44  "SkipPrologue", "SymbolNames"};
45 
47  if (type > LastKnownResolverType)
48  return g_ty_to_name[UnknownResolver];
49 
50  return g_ty_to_name[type];
51 }
52 
54 BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
55  for (size_t i = 0; i < LastKnownResolverType; i++) {
56  if (name == g_ty_to_name[i])
57  return (ResolverTy)i;
58  }
59  return UnknownResolver;
60 }
61 
63  const unsigned char resolverTy,
64  lldb::addr_t offset)
65  : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
66 
68 
70  const StructuredData::Dictionary &resolver_dict, Status &error) {
71  BreakpointResolverSP result_sp;
72  if (!resolver_dict.IsValid()) {
73  error.SetErrorString("Can't deserialize from an invalid data object.");
74  return result_sp;
75  }
76 
77  llvm::StringRef subclass_name;
78 
79  bool success = resolver_dict.GetValueForKeyAsString(
80  GetSerializationSubclassKey(), subclass_name);
81 
82  if (!success) {
84  "Resolver data missing subclass resolver key");
85  return result_sp;
86  }
87 
88  ResolverTy resolver_type = NameToResolverTy(subclass_name);
89  if (resolver_type == UnknownResolver) {
90  error.SetErrorStringWithFormatv("Unknown resolver type: {0}.",
91  subclass_name);
92  return result_sp;
93  }
94 
95  StructuredData::Dictionary *subclass_options = nullptr;
96  success = resolver_dict.GetValueForKeyAsDictionary(
97  GetSerializationSubclassOptionsKey(), subclass_options);
98  if (!success || !subclass_options || !subclass_options->IsValid()) {
99  error.SetErrorString("Resolver data missing subclass options key.");
100  return result_sp;
101  }
102 
103  lldb::addr_t offset;
104  success = subclass_options->GetValueForKeyAsInteger(
105  GetKey(OptionNames::Offset), offset);
106  if (!success) {
107  error.SetErrorString("Resolver data missing offset options key.");
108  return result_sp;
109  }
110 
111  BreakpointResolver *resolver;
112 
113  switch (resolver_type) {
114  case FileLineResolver:
116  nullptr, *subclass_options, error);
117  break;
118  case AddressResolver:
120  nullptr, *subclass_options, error);
121  break;
122  case NameResolver:
124  nullptr, *subclass_options, error);
125  break;
126  case FileRegexResolver:
128  nullptr, *subclass_options, error);
129  break;
130  case PythonResolver:
132  nullptr, *subclass_options, error);
133  break;
134  case ExceptionResolver:
135  error.SetErrorString("Exception resolvers are hard.");
136  break;
137  default:
138  llvm_unreachable("Should never get an unresolvable resolver type.");
139  }
140 
141  if (!error.Success()) {
142  return result_sp;
143  } else {
144  // Add on the global offset option:
145  resolver->SetOffset(offset);
146  return BreakpointResolverSP(resolver);
147  }
148 }
149 
151  StructuredData::DictionarySP options_dict_sp) {
152  if (!options_dict_sp || !options_dict_sp->IsValid())
154 
156  type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName());
157  type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
158 
159  // Add the m_offset to the dictionary:
160  options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
161 
162  return type_dict_sp;
163 }
164 
166  m_breakpoint = bkpt;
168 }
169 
171  ModuleList &modules) {
172  filter.SearchInModuleList(*this, modules);
173 }
174 
176  filter.Search(*this);
177 }
178 
179 namespace {
180 struct SourceLoc {
181  uint32_t line = UINT32_MAX;
182  uint32_t column;
183  SourceLoc(uint32_t l, uint32_t c) : line(l), column(c ? c : UINT32_MAX) {}
184  SourceLoc(const SymbolContext &sc)
185  : line(sc.line_entry.line),
186  column(sc.line_entry.column ? sc.line_entry.column : UINT32_MAX) {}
187 };
188 
189 bool operator<(const SourceLoc a, const SourceLoc b) {
190  if (a.line < b.line)
191  return true;
192  if (a.line > b.line)
193  return false;
194  uint32_t a_col = a.column ? a.column : UINT32_MAX;
195  uint32_t b_col = b.column ? b.column : UINT32_MAX;
196  return a_col < b_col;
197 }
198 } // namespace
199 
201  SymbolContextList &sc_list,
202  bool skip_prologue,
203  llvm::StringRef log_ident,
204  uint32_t line, uint32_t column) {
205  llvm::SmallVector<SymbolContext, 16> all_scs;
206  for (uint32_t i = 0; i < sc_list.GetSize(); ++i)
207  all_scs.push_back(sc_list[i]);
208 
209  while (all_scs.size()) {
210  uint32_t closest_line = UINT32_MAX;
211 
212  // Move all the elements with a matching file spec to the end.
213  auto &match = all_scs[0];
214  auto worklist_begin = std::partition(
215  all_scs.begin(), all_scs.end(), [&](const SymbolContext &sc) {
216  if (sc.line_entry.file == match.line_entry.file ||
217  sc.line_entry.original_file == match.line_entry.original_file) {
218  // When a match is found, keep track of the smallest line number.
219  closest_line = std::min(closest_line, sc.line_entry.line);
220  return false;
221  }
222  return true;
223  });
224 
225  // (worklist_begin, worklist_end) now contains all entries for one filespec.
226  auto worklist_end = all_scs.end();
227 
228  if (column) {
229  // If a column was requested, do a more precise match and only
230  // return the first location that comes after or at the
231  // requested location.
232  SourceLoc requested(line, column);
233  // First, filter out all entries left of the requested column.
234  worklist_end = std::remove_if(
235  worklist_begin, worklist_end,
236  [&](const SymbolContext &sc) { return SourceLoc(sc) < requested; });
237  // Sort the remaining entries by (line, column).
238  llvm::sort(worklist_begin, worklist_end,
239  [](const SymbolContext &a, const SymbolContext &b) {
240  return SourceLoc(a) < SourceLoc(b);
241  });
242 
243  // Filter out all locations with a source location after the closest match.
244  if (worklist_begin != worklist_end)
245  worklist_end = std::remove_if(
246  worklist_begin, worklist_end, [&](const SymbolContext &sc) {
247  return SourceLoc(*worklist_begin) < SourceLoc(sc);
248  });
249  } else {
250  // Remove all entries with a larger line number.
251  // ResolveSymbolContext will always return a number that is >=
252  // the line number you pass in. So the smaller line number is
253  // always better.
254  worklist_end = std::remove_if(worklist_begin, worklist_end,
255  [&](const SymbolContext &sc) {
256  return closest_line != sc.line_entry.line;
257  });
258  }
259 
260  // Sort by file address.
261  llvm::sort(worklist_begin, worklist_end,
262  [](const SymbolContext &a, const SymbolContext &b) {
265  });
266 
267  // Go through and see if there are line table entries that are
268  // contiguous, and if so keep only the first of the contiguous range.
269  // We do this by picking the first location in each lexical block.
270  llvm::SmallDenseSet<Block *, 8> blocks_with_breakpoints;
271  for (auto first = worklist_begin; first != worklist_end; ++first) {
272  assert(!blocks_with_breakpoints.count(first->block));
273  blocks_with_breakpoints.insert(first->block);
274  worklist_end =
275  std::remove_if(std::next(first), worklist_end,
276  [&](const SymbolContext &sc) {
277  return blocks_with_breakpoints.count(sc.block);
278  });
279  }
280 
281  // Make breakpoints out of the closest line number match.
282  for (auto &sc : llvm::make_range(worklist_begin, worklist_end))
283  AddLocation(filter, sc, skip_prologue, log_ident);
284 
285  // Remove all contexts processed by this iteration.
286  all_scs.erase(worklist_begin, all_scs.end());
287  }
288 }
289 
291  const SymbolContext &sc,
292  bool skip_prologue,
293  llvm::StringRef log_ident) {
295  Address line_start = sc.line_entry.range.GetBaseAddress();
296  if (!line_start.IsValid()) {
297  if (log)
298  log->Printf("error: Unable to set breakpoint %s at file address "
299  "0x%" PRIx64 "\n",
300  log_ident.str().c_str(), line_start.GetFileAddress());
301  return;
302  }
303 
304  if (!filter.AddressPasses(line_start)) {
305  if (log)
306  log->Printf("Breakpoint %s at file address 0x%" PRIx64
307  " didn't pass the filter.\n",
308  log_ident.str().c_str(), line_start.GetFileAddress());
309  }
310 
311  // If the line number is before the prologue end, move it there...
312  bool skipped_prologue = false;
313  if (skip_prologue && sc.function) {
314  Address prologue_addr(sc.function->GetAddressRange().GetBaseAddress());
315  if (prologue_addr.IsValid() && (line_start == prologue_addr)) {
316  const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
317  if (prologue_byte_size) {
318  prologue_addr.Slide(prologue_byte_size);
319 
320  if (filter.AddressPasses(prologue_addr)) {
321  skipped_prologue = true;
322  line_start = prologue_addr;
323  }
324  }
325  }
326  }
327 
328  BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
329  if (log && bp_loc_sp && !m_breakpoint->IsInternal()) {
330  StreamString s;
331  bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
332  log->Printf("Added location (skipped prologue: %s): %s \n",
333  skipped_prologue ? "yes" : "no", s.GetData());
334  }
335 }
336 
337 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
338  bool *new_location) {
339  loc_addr.Slide(m_offset);
340  return m_breakpoint->AddLocation(loc_addr, new_location);
341 }
342 
344  // There may already be an offset, so we are actually adjusting location
345  // addresses by the difference.
346  // lldb::addr_t slide = offset - m_offset;
347  // FIXME: We should go fix up all the already set locations for the new
348  // slide.
349 
350  m_offset = offset;
351 }
static lldb::BreakpointResolverSP CreateFromStructuredData(const StructuredData::Dictionary &resolver_dict, Status &error)
This section handles serializing and deserializing from StructuredData objects.
static const char * GetSerializationSubclassOptionsKey()
void SetBreakpoint(Breakpoint *bkpt)
This sets the breakpoint for this resolver.
Defines a list of symbol context objects.
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
static BreakpointResolver * CreateFromStructuredData(Breakpoint *bkpt, const StructuredData::Dictionary &options_dict, Status &error)
static const char * GetSerializationSubclassKey()
lldb::BreakpointLocationSP AddLocation(Address loc_addr, bool *new_location=NULL)
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:78
virtual void ResolveBreakpointInModules(SearchFilter &filter, ModuleList &modules)
In response to this method the resolver scans the modules in the module list modules, and adds any new locations it finds.
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:272
static BreakpointResolver * CreateFromStructuredData(Breakpoint *bkpt, const StructuredData::Dictionary &options_dict, Status &error)
const char * GetData() const
Definition: StreamString.h:43
lldb::BreakpointLocationSP AddLocation(const Address &addr, bool *new_location=nullptr)
Add a location to the breakpoint&#39;s location list.
Definition: Breakpoint.cpp:253
bool GetValueForKeyAsDictionary(llvm::StringRef key, Dictionary *&result) const
uint32_t GetSize() const
Get accessor for a symbol context list size.
Function * function
The Function for a given query.
std::shared_ptr< Dictionary > DictionarySP
uint32_t GetPrologueByteSize()
Get the size of the prologue instructions for this function.
Definition: Function.cpp:476
virtual void ResolveBreakpoint(SearchFilter &filter)
In response to this method the resolver scans all the modules in the breakpoint&#39;s target...
#define UINT32_MAX
Definition: lldb-defines.h:31
bool Slide(int64_t offset)
Definition: Address.h:430
bool IsInternal() const
Tell whether this breakpoint is an "internal" breakpoint.
Definition: Breakpoint.cpp:251
void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue, llvm::StringRef log_ident, uint32_t line=0, uint32_t column=0)
Takes a symbol context list of matches which supposedly represent the same file and line number in a ...
static const char * g_ty_to_name[LastKnownResolverType+2]
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
A collection class for Module objects.
Definition: ModuleList.h:91
General Outline: The BreakpointResolver is a Searcher.
uint16_t column
The column number of the source line, or zero if there is no column information.
Definition: LineEntry.h:156
#define LIBLLDB_LOG_BREAKPOINTS
Definition: Logging.h:19
virtual void Search(Searcher &searcher)
Call this method to do the search using the Searcher.
static const char * g_option_names[static_cast< uint32_t >(OptionNames::LastOptionName)]
virtual void SearchInModuleList(Searcher &searcher, ModuleList &modules)
Call this method to do the search using the Searcher in the module list modules.
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition: SearchFilter.h:101
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
~BreakpointResolver() override
The Destructor is virtual, all significant breakpoint resolvers derive from this class.
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:154
bool Success() const
Test for success condition.
Definition: Status.cpp:287
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:343
A section + offset based address class.
Definition: Address.h:80
static ResolverTy NameToResolverTy(llvm::StringRef name)
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
static const char * ResolverTyToName(enum ResolverTy)
uint64_t addr_t
Definition: lldb-types.h:83
void SetOffset(lldb::addr_t offset)
This updates the offset for this breakpoint.
LineEntry line_entry
The LineEntry for a given query.
ResolverTy
An enumeration for keeping track of the concrete subclass that is actually instantiated.
Definition: SBAddress.h:15
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:220
void SetErrorStringWithFormatv(const char *format, Args &&... args)
Definition: Status.h:185
BreakpointResolver(Breakpoint *bkpt, unsigned char resolverType, lldb::addr_t offset=0)
The breakpoint resolver need to have a breakpoint for "ResolveBreakpoint to make sense.
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
static BreakpointResolver * CreateFromStructuredData(Breakpoint *bkpt, const StructuredData::Dictionary &data_dict, Status &error)
const AddressRange & GetAddressRange()
Definition: Function.h:371
virtual bool AddressPasses(Address &addr)
Call this method with a Address to see if address passes the filter.
bool operator<(const Address &lhs, const Address &rhs)
Definition: Address.cpp:942
StructuredData::DictionarySP WrapOptionsDict(StructuredData::DictionarySP options_dict_sp)
Block * block
The Block for a given query.
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
static BreakpointResolver * CreateFromStructuredData(Breakpoint *bkpt, const StructuredData::Dictionary &data_dict, Status &error)
static const char * GetKey(OptionNames enum_value)
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:150
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
An error handling class.
Definition: Status.h:44
static BreakpointResolver * CreateFromStructuredData(Breakpoint *bkpt, const StructuredData::Dictionary &options_dict, Status &error)