1 //===-- BreakpointResolverName.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/BreakpointResolverName.h"
10
11 #include "lldb/Breakpoint/BreakpointLocation.h"
12 #include "lldb/Core/Architecture.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Symbol/Block.h"
15 #include "lldb/Symbol/Function.h"
16 #include "lldb/Symbol/Symbol.h"
17 #include "lldb/Symbol/SymbolContext.h"
18 #include "lldb/Target/Target.h"
19 #include "lldb/Target/Language.h"
20 #include "lldb/Utility/Log.h"
21 #include "lldb/Utility/StreamString.h"
22
23 using namespace lldb;
24 using namespace lldb_private;
25
BreakpointResolverName(const BreakpointSP & bkpt,const char * name_cstr,FunctionNameType name_type_mask,LanguageType language,Breakpoint::MatchType type,lldb::addr_t offset,bool skip_prologue)26 BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
27 const char *name_cstr, FunctionNameType name_type_mask,
28 LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset,
29 bool skip_prologue)
30 : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
31 m_class_name(), m_regex(), m_match_type(type), m_language(language),
32 m_skip_prologue(skip_prologue) {
33 if (m_match_type == Breakpoint::Regexp) {
34 m_regex = RegularExpression(name_cstr);
35 if (!m_regex.IsValid()) {
36 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
37
38 if (log)
39 log->Warning("function name regexp: \"%s\" did not compile.",
40 name_cstr);
41 }
42 } else {
43 AddNameLookup(ConstString(name_cstr), name_type_mask);
44 }
45 }
46
BreakpointResolverName(const BreakpointSP & bkpt,const char * names[],size_t num_names,FunctionNameType name_type_mask,LanguageType language,lldb::addr_t offset,bool skip_prologue)47 BreakpointResolverName::BreakpointResolverName(
48 const BreakpointSP &bkpt, const char *names[], size_t num_names,
49 FunctionNameType name_type_mask, LanguageType language, lldb::addr_t offset,
50 bool skip_prologue)
51 : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
52 m_match_type(Breakpoint::Exact), m_language(language),
53 m_skip_prologue(skip_prologue) {
54 for (size_t i = 0; i < num_names; i++) {
55 AddNameLookup(ConstString(names[i]), name_type_mask);
56 }
57 }
58
BreakpointResolverName(const BreakpointSP & bkpt,std::vector<std::string> names,FunctionNameType name_type_mask,LanguageType language,lldb::addr_t offset,bool skip_prologue)59 BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
60 std::vector<std::string> names,
61 FunctionNameType name_type_mask,
62 LanguageType language,
63 lldb::addr_t offset,
64 bool skip_prologue)
65 : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
66 m_match_type(Breakpoint::Exact), m_language(language),
67 m_skip_prologue(skip_prologue) {
68 for (const std::string &name : names) {
69 AddNameLookup(ConstString(name.c_str(), name.size()), name_type_mask);
70 }
71 }
72
BreakpointResolverName(const BreakpointSP & bkpt,RegularExpression func_regex,lldb::LanguageType language,lldb::addr_t offset,bool skip_prologue)73 BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
74 RegularExpression func_regex,
75 lldb::LanguageType language,
76 lldb::addr_t offset,
77 bool skip_prologue)
78 : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
79 m_class_name(nullptr), m_regex(std::move(func_regex)),
80 m_match_type(Breakpoint::Regexp), m_language(language),
81 m_skip_prologue(skip_prologue) {}
82
BreakpointResolverName(const BreakpointResolverName & rhs)83 BreakpointResolverName::BreakpointResolverName(
84 const BreakpointResolverName &rhs)
85 : BreakpointResolver(rhs.GetBreakpoint(), BreakpointResolver::NameResolver,
86 rhs.GetOffset()),
87 m_lookups(rhs.m_lookups), m_class_name(rhs.m_class_name),
88 m_regex(rhs.m_regex), m_match_type(rhs.m_match_type),
89 m_language(rhs.m_language), m_skip_prologue(rhs.m_skip_prologue) {}
90
CreateFromStructuredData(const BreakpointSP & bkpt,const StructuredData::Dictionary & options_dict,Status & error)91 BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
92 const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
93 Status &error) {
94 LanguageType language = eLanguageTypeUnknown;
95 llvm::StringRef language_name;
96 bool success = options_dict.GetValueForKeyAsString(
97 GetKey(OptionNames::LanguageName), language_name);
98 if (success) {
99 language = Language::GetLanguageTypeFromString(language_name);
100 if (language == eLanguageTypeUnknown) {
101 error.SetErrorStringWithFormatv("BRN::CFSD: Unknown language: {0}.",
102 language_name);
103 return nullptr;
104 }
105 }
106
107 lldb::addr_t offset = 0;
108 success =
109 options_dict.GetValueForKeyAsInteger(GetKey(OptionNames::Offset), offset);
110 if (!success) {
111 error.SetErrorString("BRN::CFSD: Missing offset entry.");
112 return nullptr;
113 }
114
115 bool skip_prologue;
116 success = options_dict.GetValueForKeyAsBoolean(
117 GetKey(OptionNames::SkipPrologue), skip_prologue);
118 if (!success) {
119 error.SetErrorString("BRN::CFSD: Missing Skip prologue entry.");
120 return nullptr;
121 }
122
123 llvm::StringRef regex_text;
124 success = options_dict.GetValueForKeyAsString(
125 GetKey(OptionNames::RegexString), regex_text);
126 if (success) {
127 return new BreakpointResolverName(bkpt, RegularExpression(regex_text),
128 language, offset, skip_prologue);
129 } else {
130 StructuredData::Array *names_array;
131 success = options_dict.GetValueForKeyAsArray(
132 GetKey(OptionNames::SymbolNameArray), names_array);
133 if (!success) {
134 error.SetErrorString("BRN::CFSD: Missing symbol names entry.");
135 return nullptr;
136 }
137 StructuredData::Array *names_mask_array;
138 success = options_dict.GetValueForKeyAsArray(
139 GetKey(OptionNames::NameMaskArray), names_mask_array);
140 if (!success) {
141 error.SetErrorString("BRN::CFSD: Missing symbol names mask entry.");
142 return nullptr;
143 }
144
145 size_t num_elem = names_array->GetSize();
146 if (num_elem != names_mask_array->GetSize()) {
147 error.SetErrorString(
148 "BRN::CFSD: names and names mask arrays have different sizes.");
149 return nullptr;
150 }
151
152 if (num_elem == 0) {
153 error.SetErrorString(
154 "BRN::CFSD: no name entry in a breakpoint by name breakpoint.");
155 return nullptr;
156 }
157 std::vector<std::string> names;
158 std::vector<FunctionNameType> name_masks;
159 for (size_t i = 0; i < num_elem; i++) {
160 llvm::StringRef name;
161
162 success = names_array->GetItemAtIndexAsString(i, name);
163 if (!success) {
164 error.SetErrorString("BRN::CFSD: name entry is not a string.");
165 return nullptr;
166 }
167 std::underlying_type<FunctionNameType>::type fnt;
168 success = names_mask_array->GetItemAtIndexAsInteger(i, fnt);
169 if (!success) {
170 error.SetErrorString("BRN::CFSD: name mask entry is not an integer.");
171 return nullptr;
172 }
173 names.push_back(std::string(name));
174 name_masks.push_back(static_cast<FunctionNameType>(fnt));
175 }
176
177 BreakpointResolverName *resolver = new BreakpointResolverName(
178 bkpt, names[0].c_str(), name_masks[0], language,
179 Breakpoint::MatchType::Exact, offset, skip_prologue);
180 for (size_t i = 1; i < num_elem; i++) {
181 resolver->AddNameLookup(ConstString(names[i]), name_masks[i]);
182 }
183 return resolver;
184 }
185 }
186
SerializeToStructuredData()187 StructuredData::ObjectSP BreakpointResolverName::SerializeToStructuredData() {
188 StructuredData::DictionarySP options_dict_sp(
189 new StructuredData::Dictionary());
190
191 if (m_regex.IsValid()) {
192 options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),
193 m_regex.GetText());
194 } else {
195 StructuredData::ArraySP names_sp(new StructuredData::Array());
196 StructuredData::ArraySP name_masks_sp(new StructuredData::Array());
197 for (auto lookup : m_lookups) {
198 names_sp->AddItem(StructuredData::StringSP(
199 new StructuredData::String(lookup.GetName().GetStringRef())));
200 name_masks_sp->AddItem(StructuredData::IntegerSP(
201 new StructuredData::Integer(lookup.GetNameTypeMask())));
202 }
203 options_dict_sp->AddItem(GetKey(OptionNames::SymbolNameArray), names_sp);
204 options_dict_sp->AddItem(GetKey(OptionNames::NameMaskArray), name_masks_sp);
205 }
206 if (m_language != eLanguageTypeUnknown)
207 options_dict_sp->AddStringItem(
208 GetKey(OptionNames::LanguageName),
209 Language::GetNameForLanguageType(m_language));
210 options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
211 m_skip_prologue);
212
213 return WrapOptionsDict(options_dict_sp);
214 }
215
AddNameLookup(ConstString name,FunctionNameType name_type_mask)216 void BreakpointResolverName::AddNameLookup(ConstString name,
217 FunctionNameType name_type_mask) {
218
219 Module::LookupInfo lookup(name, name_type_mask, m_language);
220 m_lookups.emplace_back(lookup);
221
222 auto add_variant_funcs = [&](Language *lang) {
223 for (Language::MethodNameVariant variant :
224 lang->GetMethodNameVariants(name)) {
225 // FIXME: Should we be adding variants that aren't of type Full?
226 if (variant.GetType() & lldb::eFunctionNameTypeFull) {
227 Module::LookupInfo variant_lookup(name, variant.GetType(),
228 lang->GetLanguageType());
229 variant_lookup.SetLookupName(variant.GetName());
230 m_lookups.emplace_back(variant_lookup);
231 }
232 }
233 return true;
234 };
235
236 if (Language *lang = Language::FindPlugin(m_language)) {
237 add_variant_funcs(lang);
238 } else {
239 // Most likely m_language is eLanguageTypeUnknown. We check each language for
240 // possible variants or more qualified names and create lookups for those as
241 // well.
242 Language::ForEach(add_variant_funcs);
243 }
244 }
245
246 // FIXME: Right now we look at the module level, and call the module's
247 // "FindFunctions".
248 // Greg says he will add function tables, maybe at the CompileUnit level to
249 // accelerate function lookup. At that point, we should switch the depth to
250 // CompileUnit, and look in these tables.
251
252 Searcher::CallbackReturn
SearchCallback(SearchFilter & filter,SymbolContext & context,Address * addr)253 BreakpointResolverName::SearchCallback(SearchFilter &filter,
254 SymbolContext &context, Address *addr) {
255 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
256
257 if (m_class_name) {
258 if (log)
259 log->Warning("Class/method function specification not supported yet.\n");
260 return Searcher::eCallbackReturnStop;
261 }
262
263 SymbolContextList func_list;
264 bool filter_by_cu =
265 (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0;
266 bool filter_by_language = (m_language != eLanguageTypeUnknown);
267 const bool include_symbols = !filter_by_cu;
268 const bool include_inlines = true;
269
270 switch (m_match_type) {
271 case Breakpoint::Exact:
272 if (context.module_sp) {
273 for (const auto &lookup : m_lookups) {
274 const size_t start_func_idx = func_list.GetSize();
275 context.module_sp->FindFunctions(
276 lookup.GetLookupName(), CompilerDeclContext(),
277 lookup.GetNameTypeMask(), include_symbols, include_inlines,
278 func_list);
279
280 const size_t end_func_idx = func_list.GetSize();
281
282 if (start_func_idx < end_func_idx)
283 lookup.Prune(func_list, start_func_idx);
284 }
285 }
286 break;
287 case Breakpoint::Regexp:
288 if (context.module_sp) {
289 context.module_sp->FindFunctions(
290 m_regex,
291 !filter_by_cu, // include symbols only if we aren't filtering by CU
292 include_inlines, func_list);
293 }
294 break;
295 case Breakpoint::Glob:
296 if (log)
297 log->Warning("glob is not supported yet.");
298 break;
299 }
300
301 // If the filter specifies a Compilation Unit, remove the ones that don't
302 // pass at this point.
303 if (filter_by_cu || filter_by_language) {
304 uint32_t num_functions = func_list.GetSize();
305
306 for (size_t idx = 0; idx < num_functions; idx++) {
307 bool remove_it = false;
308 SymbolContext sc;
309 func_list.GetContextAtIndex(idx, sc);
310 if (filter_by_cu) {
311 if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit))
312 remove_it = true;
313 }
314
315 if (filter_by_language) {
316 LanguageType sym_language = sc.GetLanguage();
317 if ((Language::GetPrimaryLanguage(sym_language) !=
318 Language::GetPrimaryLanguage(m_language)) &&
319 (sym_language != eLanguageTypeUnknown)) {
320 remove_it = true;
321 }
322 }
323
324 if (remove_it) {
325 func_list.RemoveContextAtIndex(idx);
326 num_functions--;
327 idx--;
328 }
329 }
330 }
331
332 BreakpointSP breakpoint_sp = GetBreakpoint();
333 Breakpoint &breakpoint = *breakpoint_sp;
334 Address break_addr;
335
336 // Remove any duplicates between the function list and the symbol list
337 SymbolContext sc;
338 if (!func_list.GetSize())
339 return Searcher::eCallbackReturnContinue;
340
341 for (uint32_t i = 0; i < func_list.GetSize(); i++) {
342 if (!func_list.GetContextAtIndex(i, sc))
343 continue;
344
345 bool is_reexported = false;
346
347 if (sc.block && sc.block->GetInlinedFunctionInfo()) {
348 if (!sc.block->GetStartAddress(break_addr))
349 break_addr.Clear();
350 } else if (sc.function) {
351 break_addr = sc.function->GetAddressRange().GetBaseAddress();
352 if (m_skip_prologue && break_addr.IsValid()) {
353 const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
354 if (prologue_byte_size)
355 break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
356 }
357 } else if (sc.symbol) {
358 if (sc.symbol->GetType() == eSymbolTypeReExported) {
359 const Symbol *actual_symbol =
360 sc.symbol->ResolveReExportedSymbol(breakpoint.GetTarget());
361 if (actual_symbol) {
362 is_reexported = true;
363 break_addr = actual_symbol->GetAddress();
364 }
365 } else {
366 break_addr = sc.symbol->GetAddress();
367 }
368
369 if (m_skip_prologue && break_addr.IsValid()) {
370 const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
371 if (prologue_byte_size)
372 break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
373 else {
374 const Architecture *arch =
375 breakpoint.GetTarget().GetArchitecturePlugin();
376 if (arch)
377 arch->AdjustBreakpointAddress(*sc.symbol, break_addr);
378 }
379 }
380 }
381
382 if (!break_addr.IsValid())
383 continue;
384
385 if (!filter.AddressPasses(break_addr))
386 continue;
387
388 bool new_location;
389 BreakpointLocationSP bp_loc_sp(AddLocation(break_addr, &new_location));
390 bp_loc_sp->SetIsReExported(is_reexported);
391 if (bp_loc_sp && new_location && !breakpoint.IsInternal()) {
392 if (log) {
393 StreamString s;
394 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
395 LLDB_LOGF(log, "Added location: %s\n", s.GetData());
396 }
397 }
398 }
399
400 return Searcher::eCallbackReturnContinue;
401 }
402
GetDepth()403 lldb::SearchDepth BreakpointResolverName::GetDepth() {
404 return lldb::eSearchDepthModule;
405 }
406
GetDescription(Stream * s)407 void BreakpointResolverName::GetDescription(Stream *s) {
408 if (m_match_type == Breakpoint::Regexp)
409 s->Printf("regex = '%s'", m_regex.GetText().str().c_str());
410 else {
411 size_t num_names = m_lookups.size();
412 if (num_names == 1)
413 s->Printf("name = '%s'", m_lookups[0].GetName().GetCString());
414 else {
415 s->Printf("names = {");
416 for (size_t i = 0; i < num_names; i++) {
417 s->Printf("%s'%s'", (i == 0 ? "" : ", "),
418 m_lookups[i].GetName().GetCString());
419 }
420 s->Printf("}");
421 }
422 }
423 if (m_language != eLanguageTypeUnknown) {
424 s->Printf(", language = %s", Language::GetNameForLanguageType(m_language));
425 }
426 }
427
Dump(Stream * s) const428 void BreakpointResolverName::Dump(Stream *s) const {}
429
430 lldb::BreakpointResolverSP
CopyForBreakpoint(BreakpointSP & breakpoint)431 BreakpointResolverName::CopyForBreakpoint(BreakpointSP &breakpoint) {
432 lldb::BreakpointResolverSP ret_sp(new BreakpointResolverName(*this));
433 ret_sp->SetBreakpoint(breakpoint);
434 return ret_sp;
435 }
436