BreakpointResolver.cpp revision 353358 
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
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/Target.h"
27#include "lldb/Utility/Log.h"
28#include "lldb/Utility/Stream.h"
29#include "lldb/Utility/StreamString.h"
30
31using namespace lldb_private;
32using namespace lldb;
33
34// BreakpointResolver:
35const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
36                                                  "SymbolName",  "SourceRegex",
37                                                  "Exception",   "Unknown"};
38
39const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
40    BreakpointResolver::OptionNames::LastOptionName)] = {
41    "AddressOffset", "Exact",     "FileName",     "Inlines",     "Language",
42    "LineNumber",    "Column",    "ModuleName",   "NameMask",    "Offset",
43    "PythonClass",   "Regex",     "ScriptArgs",   "SectionName", "SearchDepth",
44    "SkipPrologue",  "SymbolNames"};
45
46const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
47  if (type > LastKnownResolverType)
48    return g_ty_to_name[UnknownResolver];
49
50  return g_ty_to_name[type];
51}
52
53BreakpointResolver::ResolverTy
54BreakpointResolver::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
62BreakpointResolver::BreakpointResolver(Breakpoint *bkpt,
63                                       const unsigned char resolverTy,
64                                       lldb::addr_t offset)
65    : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
66
67BreakpointResolver::~BreakpointResolver() {}
68
69BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
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) {
83    error.SetErrorStringWithFormat(
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:
115    resolver = BreakpointResolverFileLine::CreateFromStructuredData(
116        nullptr, *subclass_options, error);
117    break;
118  case AddressResolver:
119    resolver = BreakpointResolverAddress::CreateFromStructuredData(
120        nullptr, *subclass_options, error);
121    break;
122  case NameResolver:
123    resolver = BreakpointResolverName::CreateFromStructuredData(
124        nullptr, *subclass_options, error);
125    break;
126  case FileRegexResolver:
127    resolver = BreakpointResolverFileRegex::CreateFromStructuredData(
128        nullptr, *subclass_options, error);
129    break;
130  case PythonResolver:
131    resolver = BreakpointResolverScripted::CreateFromStructuredData(
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
150StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
151    StructuredData::DictionarySP options_dict_sp) {
152  if (!options_dict_sp || !options_dict_sp->IsValid())
153    return StructuredData::DictionarySP();
154
155  StructuredData::DictionarySP type_dict_sp(new StructuredData::Dictionary());
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
165void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) {
166  m_breakpoint = bkpt;
167  NotifyBreakpointSet();
168}
169
170void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
171                                                    ModuleList &modules) {
172  filter.SearchInModuleList(*this, modules);
173}
174
175void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
176  filter.Search(*this);
177}
178
179namespace {
180struct 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
189bool 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
200void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter,
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) {
263                 return a.line_entry.range.GetBaseAddress().GetFileAddress() <
264                        b.line_entry.range.GetBaseAddress().GetFileAddress();
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
290void BreakpointResolver::AddLocation(SearchFilter &filter,
291                                     const SymbolContext &sc,
292                                     bool skip_prologue,
293                                     llvm::StringRef log_ident) {
294  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
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
337BreakpointLocationSP 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
343void BreakpointResolver::SetOffset(lldb::addr_t offset) {
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}
352