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