contrib/llvm/tools/lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

   1 //===-- BreakpointResolverFileRegex.cpp -------------------------*- C++-*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
  11
  12 #include "lldb/Breakpoint/BreakpointLocation.h"
  13 #include "lldb/Core/SourceManager.h"
  14 #include "lldb/Symbol/CompileUnit.h"
  15 #include "lldb/Target/Target.h"
  16 #include "lldb/Utility/Log.h"
  17 #include "lldb/Utility/StreamString.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 //----------------------------------------------------------------------
  23 // BreakpointResolverFileRegex:
  24 //----------------------------------------------------------------------
  25 BreakpointResolverFileRegex::BreakpointResolverFileRegex(
  26     Breakpoint *bkpt, RegularExpression &regex,
  27     const std::unordered_set<std::string> &func_names, bool exact_match)
  28     : BreakpointResolver(bkpt, BreakpointResolver::FileRegexResolver),
  29       m_regex(regex), m_exact_match(exact_match), m_function_names(func_names) {
  30 }
  31
  32 BreakpointResolverFileRegex::~BreakpointResolverFileRegex() {}
  33
  34 BreakpointResolver *BreakpointResolverFileRegex::CreateFromStructuredData(
  35     Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
  36     Status &error) {
  37   bool success;
  38
  39   llvm::StringRef regex_string;
  40   success = options_dict.GetValueForKeyAsString(
  41       GetKey(OptionNames::RegexString), regex_string);
  42   if (!success) {
  43     error.SetErrorString("BRFR::CFSD: Couldn't find regex entry.");
  44     return nullptr;
  45   }
  46   RegularExpression regex(regex_string);
  47
  48   bool exact_match;
  49   success = options_dict.GetValueForKeyAsBoolean(
  50       GetKey(OptionNames::ExactMatch), exact_match);
  51   if (!success) {
  52     error.SetErrorString("BRFL::CFSD: Couldn't find exact match entry.");
  53     return nullptr;
  54   }
  55
  56   // The names array is optional:
  57   std::unordered_set<std::string> names_set;
  58   StructuredData::Array *names_array;
  59   success = options_dict.GetValueForKeyAsArray(
  60       GetKey(OptionNames::SymbolNameArray), names_array);
  61   if (success && names_array) {
  62     size_t num_names = names_array->GetSize();
  63     for (size_t i = 0; i < num_names; i++) {
  64       llvm::StringRef name;
  65       success = names_array->GetItemAtIndexAsString(i, name);
  66       if (!success) {
  67         error.SetErrorStringWithFormat(
  68             "BRFR::CFSD: Malformed element %zu in the names array.", i);
  69         return nullptr;
  70       }
  71       names_set.insert(name);
  72     }
  73   }
  74
  75   return new BreakpointResolverFileRegex(bkpt, regex, names_set, exact_match);
  76 }
  77
  78 StructuredData::ObjectSP
  79 BreakpointResolverFileRegex::SerializeToStructuredData() {
  80   StructuredData::DictionarySP options_dict_sp(
  81       new StructuredData::Dictionary());
  82
  83   options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),
  84                                  m_regex.GetText());
  85   options_dict_sp->AddBooleanItem(GetKey(OptionNames::ExactMatch),
  86                                   m_exact_match);
  87   if (!m_function_names.empty()) {
  88     StructuredData::ArraySP names_array_sp(new StructuredData::Array());
  89     for (std::string name : m_function_names) {
  90       StructuredData::StringSP item(new StructuredData::String(name));
  91       names_array_sp->AddItem(item);
  92     }
  93     options_dict_sp->AddItem(GetKey(OptionNames::LineNumber), names_array_sp);
  94   }
  95
  96   return WrapOptionsDict(options_dict_sp);
  97 }
  98
  99 Searcher::CallbackReturn
 100 BreakpointResolverFileRegex::SearchCallback(SearchFilter &filter,
 101                                             SymbolContext &context,
 102                                             Address *addr, bool containing) {
 103
 104   assert(m_breakpoint != NULL);
 105   if (!context.target_sp)
 106     return eCallbackReturnContinue;
 107
 108   CompileUnit *cu = context.comp_unit;
 109   FileSpec cu_file_spec = *(static_cast<FileSpec *>(cu));
 110   std::vector<uint32_t> line_matches;
 111   context.target_sp->GetSourceManager().FindLinesMatchingRegex(
 112       cu_file_spec, m_regex, 1, UINT32_MAX, line_matches);
 113
 114   uint32_t num_matches = line_matches.size();
 115   for (uint32_t i = 0; i < num_matches; i++) {
 116     SymbolContextList sc_list;
 117     const bool search_inlines = false;
 118
 119     cu->ResolveSymbolContext(cu_file_spec, line_matches[i], search_inlines,
 120                              m_exact_match, eSymbolContextEverything, sc_list);
 121     // Find all the function names:
 122     if (!m_function_names.empty()) {
 123       std::vector<size_t> sc_to_remove;
 124       for (size_t i = 0; i < sc_list.GetSize(); i++) {
 125         SymbolContext sc_ctx;
 126         sc_list.GetContextAtIndex(i, sc_ctx);
 127         std::string name(
 128             sc_ctx
 129                 .GetFunctionName(
 130                     Mangled::NamePreference::ePreferDemangledWithoutArguments)
 131                 .AsCString());
 132         if (!m_function_names.count(name)) {
 133           sc_to_remove.push_back(i);
 134         }
 135       }
 136
 137       if (!sc_to_remove.empty()) {
 138         std::vector<size_t>::reverse_iterator iter;
 139         std::vector<size_t>::reverse_iterator rend = sc_to_remove.rend();
 140         for (iter = sc_to_remove.rbegin(); iter != rend; iter++) {
 141           sc_list.RemoveContextAtIndex(*iter);
 142         }
 143       }
 144     }
 145
 146     const bool skip_prologue = true;
 147
 148     BreakpointResolver::SetSCMatchesByLine(filter, sc_list, skip_prologue,
 149                                            m_regex.GetText());
 150   }
 151   assert(m_breakpoint != NULL);
 152
 153   return Searcher::eCallbackReturnContinue;
 154 }
 155
 156 lldb::SearchDepth BreakpointResolverFileRegex::GetDepth() {
 157   return lldb::eSearchDepthCompUnit;
 158 }
 159
 160 void BreakpointResolverFileRegex::GetDescription(Stream *s) {
 161   s->Printf("source regex = \"%s\", exact_match = %d",
 162             m_regex.GetText().str().c_str(), m_exact_match);
 163 }
 164
 165 void BreakpointResolverFileRegex::Dump(Stream *s) const {}
 166
 167 lldb::BreakpointResolverSP
 168 BreakpointResolverFileRegex::CopyForBreakpoint(Breakpoint &breakpoint) {
 169   lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex(
 170       &breakpoint, m_regex, m_function_names, m_exact_match));
 171   return ret_sp;
 172 }
 173
 174 void BreakpointResolverFileRegex::AddFunctionName(const char *func_name) {
 175   m_function_names.insert(func_name);
 176 }