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 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(llvm::StringRef::withNullAsEmpty(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 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 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 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 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 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.SetErrorStringWithFormat("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.SetErrorStringWithFormat("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.SetErrorStringWithFormat("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.SetErrorStringWithFormat( 142 "BRN::CFSD: Missing symbol names mask entry."); 143 return nullptr; 144 } 145 146 size_t num_elem = names_array->GetSize(); 147 if (num_elem != names_mask_array->GetSize()) { 148 error.SetErrorString( 149 "BRN::CFSD: names and names mask arrays have different sizes."); 150 return nullptr; 151 } 152 153 if (num_elem == 0) { 154 error.SetErrorString( 155 "BRN::CFSD: no name entry in a breakpoint by name breakpoint."); 156 return nullptr; 157 } 158 std::vector<std::string> names; 159 std::vector<FunctionNameType> name_masks; 160 for (size_t i = 0; i < num_elem; i++) { 161 llvm::StringRef name; 162 163 success = names_array->GetItemAtIndexAsString(i, name); 164 if (!success) { 165 error.SetErrorString("BRN::CFSD: name entry is not a string."); 166 return nullptr; 167 } 168 std::underlying_type<FunctionNameType>::type fnt; 169 success = names_mask_array->GetItemAtIndexAsInteger(i, fnt); 170 if (!success) { 171 error.SetErrorString("BRN::CFSD: name mask entry is not an integer."); 172 return nullptr; 173 } 174 names.push_back(std::string(name)); 175 name_masks.push_back(static_cast<FunctionNameType>(fnt)); 176 } 177 178 BreakpointResolverName *resolver = new BreakpointResolverName( 179 bkpt, names[0].c_str(), name_masks[0], language, 180 Breakpoint::MatchType::Exact, offset, skip_prologue); 181 for (size_t i = 1; i < num_elem; i++) { 182 resolver->AddNameLookup(ConstString(names[i]), name_masks[i]); 183 } 184 return resolver; 185 } 186 } 187 188 StructuredData::ObjectSP BreakpointResolverName::SerializeToStructuredData() { 189 StructuredData::DictionarySP options_dict_sp( 190 new StructuredData::Dictionary()); 191 192 if (m_regex.IsValid()) { 193 options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString), 194 m_regex.GetText()); 195 } else { 196 StructuredData::ArraySP names_sp(new StructuredData::Array()); 197 StructuredData::ArraySP name_masks_sp(new StructuredData::Array()); 198 for (auto lookup : m_lookups) { 199 names_sp->AddItem(StructuredData::StringSP( 200 new StructuredData::String(lookup.GetName().GetStringRef()))); 201 name_masks_sp->AddItem(StructuredData::IntegerSP( 202 new StructuredData::Integer(lookup.GetNameTypeMask()))); 203 } 204 options_dict_sp->AddItem(GetKey(OptionNames::SymbolNameArray), names_sp); 205 options_dict_sp->AddItem(GetKey(OptionNames::NameMaskArray), name_masks_sp); 206 } 207 if (m_language != eLanguageTypeUnknown) 208 options_dict_sp->AddStringItem( 209 GetKey(OptionNames::LanguageName), 210 Language::GetNameForLanguageType(m_language)); 211 options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue), 212 m_skip_prologue); 213 214 return WrapOptionsDict(options_dict_sp); 215 } 216 217 void BreakpointResolverName::AddNameLookup(ConstString name, 218 FunctionNameType name_type_mask) { 219 220 Module::LookupInfo lookup(name, name_type_mask, m_language); 221 m_lookups.emplace_back(lookup); 222 223 auto add_variant_funcs = [&](Language *lang) { 224 for (ConstString variant_name : lang->GetMethodNameVariants(name)) { 225 Module::LookupInfo variant_lookup(name, name_type_mask, 226 lang->GetLanguageType()); 227 variant_lookup.SetLookupName(variant_name); 228 m_lookups.emplace_back(variant_lookup); 229 } 230 return true; 231 }; 232 233 if (Language *lang = Language::FindPlugin(m_language)) { 234 add_variant_funcs(lang); 235 } else { 236 // Most likely m_language is eLanguageTypeUnknown. We check each language for 237 // possible variants or more qualified names and create lookups for those as 238 // well. 239 Language::ForEach(add_variant_funcs); 240 } 241 } 242 243 // FIXME: Right now we look at the module level, and call the module's 244 // "FindFunctions". 245 // Greg says he will add function tables, maybe at the CompileUnit level to 246 // accelerate function lookup. At that point, we should switch the depth to 247 // CompileUnit, and look in these tables. 248 249 Searcher::CallbackReturn 250 BreakpointResolverName::SearchCallback(SearchFilter &filter, 251 SymbolContext &context, Address *addr) { 252 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 253 254 if (m_class_name) { 255 if (log) 256 log->Warning("Class/method function specification not supported yet.\n"); 257 return Searcher::eCallbackReturnStop; 258 } 259 260 SymbolContextList func_list; 261 bool filter_by_cu = 262 (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0; 263 bool filter_by_language = (m_language != eLanguageTypeUnknown); 264 const bool include_symbols = !filter_by_cu; 265 const bool include_inlines = true; 266 267 switch (m_match_type) { 268 case Breakpoint::Exact: 269 if (context.module_sp) { 270 for (const auto &lookup : m_lookups) { 271 const size_t start_func_idx = func_list.GetSize(); 272 context.module_sp->FindFunctions( 273 lookup.GetLookupName(), CompilerDeclContext(), 274 lookup.GetNameTypeMask(), include_symbols, include_inlines, 275 func_list); 276 277 const size_t end_func_idx = func_list.GetSize(); 278 279 if (start_func_idx < end_func_idx) 280 lookup.Prune(func_list, start_func_idx); 281 } 282 } 283 break; 284 case Breakpoint::Regexp: 285 if (context.module_sp) { 286 context.module_sp->FindFunctions( 287 m_regex, 288 !filter_by_cu, // include symbols only if we aren't filtering by CU 289 include_inlines, func_list); 290 } 291 break; 292 case Breakpoint::Glob: 293 if (log) 294 log->Warning("glob is not supported yet."); 295 break; 296 } 297 298 // If the filter specifies a Compilation Unit, remove the ones that don't 299 // pass at this point. 300 if (filter_by_cu || filter_by_language) { 301 uint32_t num_functions = func_list.GetSize(); 302 303 for (size_t idx = 0; idx < num_functions; idx++) { 304 bool remove_it = false; 305 SymbolContext sc; 306 func_list.GetContextAtIndex(idx, sc); 307 if (filter_by_cu) { 308 if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit)) 309 remove_it = true; 310 } 311 312 if (filter_by_language) { 313 LanguageType sym_language = sc.GetLanguage(); 314 if ((Language::GetPrimaryLanguage(sym_language) != 315 Language::GetPrimaryLanguage(m_language)) && 316 (sym_language != eLanguageTypeUnknown)) { 317 remove_it = true; 318 } 319 } 320 321 if (remove_it) { 322 func_list.RemoveContextAtIndex(idx); 323 num_functions--; 324 idx--; 325 } 326 } 327 } 328 329 BreakpointSP breakpoint_sp = GetBreakpoint(); 330 Breakpoint &breakpoint = *breakpoint_sp; 331 Address break_addr; 332 333 // Remove any duplicates between the function list and the symbol list 334 SymbolContext sc; 335 if (!func_list.GetSize()) 336 return Searcher::eCallbackReturnContinue; 337 338 for (uint32_t i = 0; i < func_list.GetSize(); i++) { 339 if (!func_list.GetContextAtIndex(i, sc)) 340 continue; 341 342 bool is_reexported = false; 343 344 if (sc.block && sc.block->GetInlinedFunctionInfo()) { 345 if (!sc.block->GetStartAddress(break_addr)) 346 break_addr.Clear(); 347 } else if (sc.function) { 348 break_addr = sc.function->GetAddressRange().GetBaseAddress(); 349 if (m_skip_prologue && break_addr.IsValid()) { 350 const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize(); 351 if (prologue_byte_size) 352 break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); 353 } 354 } else if (sc.symbol) { 355 if (sc.symbol->GetType() == eSymbolTypeReExported) { 356 const Symbol *actual_symbol = 357 sc.symbol->ResolveReExportedSymbol(breakpoint.GetTarget()); 358 if (actual_symbol) { 359 is_reexported = true; 360 break_addr = actual_symbol->GetAddress(); 361 } 362 } else { 363 break_addr = sc.symbol->GetAddress(); 364 } 365 366 if (m_skip_prologue && break_addr.IsValid()) { 367 const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize(); 368 if (prologue_byte_size) 369 break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); 370 else { 371 const Architecture *arch = 372 breakpoint.GetTarget().GetArchitecturePlugin(); 373 if (arch) 374 arch->AdjustBreakpointAddress(*sc.symbol, break_addr); 375 } 376 } 377 } 378 379 if (!break_addr.IsValid()) 380 continue; 381 382 if (!filter.AddressPasses(break_addr)) 383 continue; 384 385 bool new_location; 386 BreakpointLocationSP bp_loc_sp(AddLocation(break_addr, &new_location)); 387 bp_loc_sp->SetIsReExported(is_reexported); 388 if (bp_loc_sp && new_location && !breakpoint.IsInternal()) { 389 if (log) { 390 StreamString s; 391 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 392 LLDB_LOGF(log, "Added location: %s\n", s.GetData()); 393 } 394 } 395 } 396 397 return Searcher::eCallbackReturnContinue; 398 } 399 400 lldb::SearchDepth BreakpointResolverName::GetDepth() { 401 return lldb::eSearchDepthModule; 402 } 403 404 void BreakpointResolverName::GetDescription(Stream *s) { 405 if (m_match_type == Breakpoint::Regexp) 406 s->Printf("regex = '%s'", m_regex.GetText().str().c_str()); 407 else { 408 size_t num_names = m_lookups.size(); 409 if (num_names == 1) 410 s->Printf("name = '%s'", m_lookups[0].GetName().GetCString()); 411 else { 412 s->Printf("names = {"); 413 for (size_t i = 0; i < num_names; i++) { 414 s->Printf("%s'%s'", (i == 0 ? "" : ", "), 415 m_lookups[i].GetName().GetCString()); 416 } 417 s->Printf("}"); 418 } 419 } 420 if (m_language != eLanguageTypeUnknown) { 421 s->Printf(", language = %s", Language::GetNameForLanguageType(m_language)); 422 } 423 } 424 425 void BreakpointResolverName::Dump(Stream *s) const {} 426 427 lldb::BreakpointResolverSP 428 BreakpointResolverName::CopyForBreakpoint(BreakpointSP &breakpoint) { 429 lldb::BreakpointResolverSP ret_sp(new BreakpointResolverName(*this)); 430 ret_sp->SetBreakpoint(breakpoint); 431 return ret_sp; 432 } 433