contrib/llvm-project/lldb/source/Breakpoint/BreakpointResolverName.cpp

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