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