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/LLDBLog.h"
28 #include "lldb/Utility/Log.h"
29 #include "lldb/Utility/Stream.h"
30 #include "lldb/Utility/StreamString.h"
31
32 using namespace lldb_private;
33 using namespace lldb;
34
35 // BreakpointResolver:
36 const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
37 "SymbolName", "SourceRegex",
38 "Python", "Exception",
39 "Unknown"};
40
41 const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
42 BreakpointResolver::OptionNames::LastOptionName)] = {
43 "AddressOffset", "Exact", "FileName", "Inlines", "Language",
44 "LineNumber", "Column", "ModuleName", "NameMask", "Offset",
45 "PythonClass", "Regex", "ScriptArgs", "SectionName", "SearchDepth",
46 "SkipPrologue", "SymbolNames"};
47
ResolverTyToName(enum ResolverTy type)48 const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
49 if (type > LastKnownResolverType)
50 return g_ty_to_name[UnknownResolver];
51
52 return g_ty_to_name[type];
53 }
54
55 BreakpointResolver::ResolverTy
NameToResolverTy(llvm::StringRef name)56 BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
57 for (size_t i = 0; i < LastKnownResolverType; i++) {
58 if (name == g_ty_to_name[i])
59 return (ResolverTy)i;
60 }
61 return UnknownResolver;
62 }
63
BreakpointResolver(const BreakpointSP & bkpt,const unsigned char resolverTy,lldb::addr_t offset)64 BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt,
65 const unsigned char resolverTy,
66 lldb::addr_t offset)
67 : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
68
69 BreakpointResolver::~BreakpointResolver() = default;
70
CreateFromStructuredData(const StructuredData::Dictionary & resolver_dict,Status & error)71 BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
72 const StructuredData::Dictionary &resolver_dict, Status &error) {
73 BreakpointResolverSP result_sp;
74 if (!resolver_dict.IsValid()) {
75 error.SetErrorString("Can't deserialize from an invalid data object.");
76 return result_sp;
77 }
78
79 llvm::StringRef subclass_name;
80
81 bool success = resolver_dict.GetValueForKeyAsString(
82 GetSerializationSubclassKey(), subclass_name);
83
84 if (!success) {
85 error.SetErrorString("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 = nullptr;
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 (!resolver || error.Fail())
142 return result_sp;
143
144 // Add on the global offset option:
145 resolver->SetOffset(offset);
146 return BreakpointResolverSP(resolver);
147 }
148
WrapOptionsDict(StructuredData::DictionarySP options_dict_sp)149 StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
150 StructuredData::DictionarySP options_dict_sp) {
151 if (!options_dict_sp || !options_dict_sp->IsValid())
152 return StructuredData::DictionarySP();
153
154 StructuredData::DictionarySP type_dict_sp(new StructuredData::Dictionary());
155 type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName());
156 type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
157
158 // Add the m_offset to the dictionary:
159 options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
160
161 return type_dict_sp;
162 }
163
SetBreakpoint(const BreakpointSP & bkpt)164 void BreakpointResolver::SetBreakpoint(const BreakpointSP &bkpt) {
165 assert(bkpt);
166 m_breakpoint = bkpt;
167 NotifyBreakpointSet();
168 }
169
ResolveBreakpointInModules(SearchFilter & filter,ModuleList & modules)170 void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
171 ModuleList &modules) {
172 filter.SearchInModuleList(*this, modules);
173 }
174
ResolveBreakpoint(SearchFilter & filter)175 void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
176 filter.Search(*this);
177 }
178
179 namespace {
180 struct SourceLoc {
181 uint32_t line = UINT32_MAX;
182 uint16_t column;
SourceLoc__anon27966a7c0111::SourceLoc183 SourceLoc(uint32_t l, llvm::Optional<uint16_t> c)
184 : line(l), column(c ? *c : LLDB_INVALID_COLUMN_NUMBER) {}
SourceLoc__anon27966a7c0111::SourceLoc185 SourceLoc(const SymbolContext &sc)
186 : line(sc.line_entry.line),
187 column(sc.line_entry.column ? sc.line_entry.column
188 : LLDB_INVALID_COLUMN_NUMBER) {}
189 };
190
operator <(const SourceLoc lhs,const SourceLoc rhs)191 bool operator<(const SourceLoc lhs, const SourceLoc rhs) {
192 if (lhs.line < rhs.line)
193 return true;
194 if (lhs.line > rhs.line)
195 return false;
196 // uint32_t a_col = lhs.column ? lhs.column : LLDB_INVALID_COLUMN_NUMBER;
197 // uint32_t b_col = rhs.column ? rhs.column : LLDB_INVALID_COLUMN_NUMBER;
198 return lhs.column < rhs.column;
199 }
200 } // namespace
201
SetSCMatchesByLine(SearchFilter & filter,SymbolContextList & sc_list,bool skip_prologue,llvm::StringRef log_ident,uint32_t line,llvm::Optional<uint16_t> column)202 void BreakpointResolver::SetSCMatchesByLine(
203 SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue,
204 llvm::StringRef log_ident, uint32_t line, llvm::Optional<uint16_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 before 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 requested < SourceLoc(sc); });
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
AddLocation(SearchFilter & filter,const SymbolContext & sc,bool skip_prologue,llvm::StringRef log_ident)290 void BreakpointResolver::AddLocation(SearchFilter &filter,
291 const SymbolContext &sc,
292 bool skip_prologue,
293 llvm::StringRef log_ident) {
294 Log *log = GetLog(LLDBLog::Breakpoints);
295 Address line_start = sc.line_entry.range.GetBaseAddress();
296 if (!line_start.IsValid()) {
297 LLDB_LOGF(log,
298 "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 LLDB_LOGF(log,
306 "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 && !GetBreakpoint()->IsInternal()) {
330 StreamString s;
331 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
332 LLDB_LOGF(log, "Added location (skipped prologue: %s): %s \n",
333 skipped_prologue ? "yes" : "no", s.GetData());
334 }
335 }
336
AddLocation(Address loc_addr,bool * new_location)337 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
338 bool *new_location) {
339 loc_addr.Slide(m_offset);
340 return GetBreakpoint()->AddLocation(loc_addr, new_location);
341 }
342
SetOffset(lldb::addr_t offset)343 void 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