lldb/source/Breakpoint/BreakpointResolverName.cpp

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