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

   1 //===-- BreakpointResolverName.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/BreakpointResolverName.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Breakpoint/BreakpointLocation.h"
  17 #include "lldb/Core/Log.h"
  18 #include "lldb/Core/Module.h"
  19 #include "lldb/Core/StreamString.h"
  20 #include "lldb/Symbol/ClangNamespaceDecl.h"
  21 #include "lldb/Symbol/Block.h"
  22 #include "lldb/Symbol/Function.h"
  23 #include "lldb/Symbol/Symbol.h"
  24 #include "lldb/Symbol/SymbolContext.h"
  25 #include "lldb/Target/ObjCLanguageRuntime.h"
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
  31                                                 const char *name_cstr,
  32                                                 uint32_t name_type_mask,
  33                                                 Breakpoint::MatchType type,
  34                                                 bool skip_prologue) :
  35     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
  36     m_class_name (),
  37     m_regex (),
  38     m_match_type (type),
  39     m_skip_prologue (skip_prologue)
  40 {
  41
  42     if (m_match_type == Breakpoint::Regexp)
  43     {
  44         if (!m_regex.Compile (name_cstr))
  45         {
  46             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
  47
  48             if (log)
  49                 log->Warning ("function name regexp: \"%s\" did not compile.", name_cstr);
  50         }
  51     }
  52     else
  53     {
  54         AddNameLookup (ConstString(name_cstr), name_type_mask);
  55     }
  56 }
  57
  58 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
  59                                                 const char *names[],
  60                                                 size_t num_names,
  61                                                 uint32_t name_type_mask,
  62                                                 bool skip_prologue) :
  63     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
  64     m_match_type (Breakpoint::Exact),
  65     m_skip_prologue (skip_prologue)
  66 {
  67     for (size_t i = 0; i < num_names; i++)
  68     {
  69         AddNameLookup (ConstString (names[i]), name_type_mask);
  70     }
  71 }
  72
  73 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
  74                                                 std::vector<std::string> names,
  75                                                 uint32_t name_type_mask,
  76                                                 bool skip_prologue) :
  77     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
  78     m_match_type (Breakpoint::Exact),
  79     m_skip_prologue (skip_prologue)
  80 {
  81     for (const std::string& name : names)
  82     {
  83         AddNameLookup (ConstString (name.c_str(), name.size()), name_type_mask);
  84     }
  85 }
  86
  87 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
  88                                                 RegularExpression &func_regex,
  89                                                 bool skip_prologue) :
  90     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
  91     m_class_name (NULL),
  92     m_regex (func_regex),
  93     m_match_type (Breakpoint::Regexp),
  94     m_skip_prologue (skip_prologue)
  95 {
  96 }
  97
  98 BreakpointResolverName::BreakpointResolverName
  99 (
 100     Breakpoint *bkpt,
 101     const char *class_name,
 102     const char *method,
 103     Breakpoint::MatchType type,
 104     bool skip_prologue
 105 ) :
 106     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
 107     m_class_name (class_name),
 108     m_regex (),
 109     m_match_type (type),
 110     m_skip_prologue (skip_prologue)
 111 {
 112     LookupInfo lookup;
 113     lookup.name.SetCString(method);
 114     lookup.lookup_name = lookup.name;
 115     lookup.name_type_mask = eFunctionNameTypeMethod;
 116     lookup.match_name_after_lookup = false;
 117     m_lookups.push_back (lookup);
 118 }
 119
 120 BreakpointResolverName::~BreakpointResolverName ()
 121 {
 122 }
 123
 124 void
 125 BreakpointResolverName::AddNameLookup (const ConstString &name, uint32_t name_type_mask)
 126 {
 127     ObjCLanguageRuntime::MethodName objc_method(name.GetCString(), false);
 128     if (objc_method.IsValid(false))
 129     {
 130         std::vector<ConstString> objc_names;
 131         objc_method.GetFullNames(objc_names, true);
 132         for (ConstString objc_name : objc_names)
 133         {
 134             LookupInfo lookup;
 135             lookup.name = name;
 136             lookup.lookup_name = objc_name;
 137             lookup.name_type_mask = eFunctionNameTypeFull;
 138             lookup.match_name_after_lookup = false;
 139             m_lookups.push_back (lookup);
 140         }
 141     }
 142     else
 143     {
 144         LookupInfo lookup;
 145         lookup.name = name;
 146         Module::PrepareForFunctionNameLookup(lookup.name, name_type_mask, lookup.lookup_name, lookup.name_type_mask, lookup.match_name_after_lookup);
 147         m_lookups.push_back (lookup);
 148     }
 149 }
 150
 151
 152 void
 153 BreakpointResolverName::LookupInfo::Prune (SymbolContextList &sc_list, size_t start_idx) const
 154 {
 155     if (match_name_after_lookup && name)
 156     {
 157         SymbolContext sc;
 158         size_t i = start_idx;
 159         while (i < sc_list.GetSize())
 160         {
 161             if (!sc_list.GetContextAtIndex(i, sc))
 162                 break;
 163             ConstString full_name (sc.GetFunctionName());
 164             if (full_name && ::strstr(full_name.GetCString(), name.GetCString()) == NULL)
 165             {
 166                 sc_list.RemoveContextAtIndex(i);
 167             }
 168             else
 169             {
 170                 ++i;
 171             }
 172         }
 173     }
 174 }
 175
 176
 177 // FIXME: Right now we look at the module level, and call the module's "FindFunctions".
 178 // Greg says he will add function tables, maybe at the CompileUnit level to accelerate function
 179 // lookup.  At that point, we should switch the depth to CompileUnit, and look in these tables.
 180
 181 Searcher::CallbackReturn
 182 BreakpointResolverName::SearchCallback
 183 (
 184     SearchFilter &filter,
 185     SymbolContext &context,
 186     Address *addr,
 187     bool containing
 188 )
 189 {
 190     SymbolContextList func_list;
 191     //SymbolContextList sym_list;
 192
 193     uint32_t i;
 194     bool new_location;
 195     Address break_addr;
 196     assert (m_breakpoint != NULL);
 197
 198     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 199
 200     if (m_class_name)
 201     {
 202         if (log)
 203             log->Warning ("Class/method function specification not supported yet.\n");
 204         return Searcher::eCallbackReturnStop;
 205     }
 206     bool filter_by_cu = (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0;
 207     const bool include_symbols = filter_by_cu == false;
 208     const bool include_inlines = true;
 209     const bool append = true;
 210
 211     switch (m_match_type)
 212     {
 213         case Breakpoint::Exact:
 214             if (context.module_sp)
 215             {
 216                 for (const LookupInfo &lookup : m_lookups)
 217                 {
 218                     const size_t start_func_idx = func_list.GetSize();
 219                     context.module_sp->FindFunctions (lookup.lookup_name,
 220                                                       NULL,
 221                                                       lookup.name_type_mask,
 222                                                       include_symbols,
 223                                                       include_inlines,
 224                                                       append,
 225                                                       func_list);
 226                     const size_t end_func_idx = func_list.GetSize();
 227
 228                     if (start_func_idx < end_func_idx)
 229                         lookup.Prune (func_list, start_func_idx);
 230                 }
 231             }
 232             break;
 233         case Breakpoint::Regexp:
 234             if (context.module_sp)
 235             {
 236                 context.module_sp->FindFunctions (m_regex,
 237                                                   !filter_by_cu, // include symbols only if we aren't filterning by CU
 238                                                   include_inlines,
 239                                                   append,
 240                                                   func_list);
 241             }
 242             break;
 243         case Breakpoint::Glob:
 244             if (log)
 245                 log->Warning ("glob is not supported yet.");
 246             break;
 247     }
 248
 249     // If the filter specifies a Compilation Unit, remove the ones that don't pass at this point.
 250     if (filter_by_cu)
 251     {
 252         uint32_t num_functions = func_list.GetSize();
 253
 254         for (size_t idx = 0; idx < num_functions; idx++)
 255         {
 256             SymbolContext sc;
 257             func_list.GetContextAtIndex(idx, sc);
 258             if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit))
 259             {
 260                 func_list.RemoveContextAtIndex(idx);
 261                 num_functions--;
 262                 idx--;
 263             }
 264         }
 265     }
 266
 267     // Remove any duplicates between the funcion list and the symbol list
 268     SymbolContext sc;
 269     if (func_list.GetSize())
 270     {
 271         for (i = 0; i < func_list.GetSize(); i++)
 272         {
 273             if (func_list.GetContextAtIndex(i, sc))
 274             {
 275                 if (sc.block && sc.block->GetInlinedFunctionInfo())
 276                 {
 277                     if (!sc.block->GetStartAddress(break_addr))
 278                         break_addr.Clear();
 279                 }
 280                 else if (sc.function)
 281                 {
 282                     break_addr = sc.function->GetAddressRange().GetBaseAddress();
 283                     if (m_skip_prologue && break_addr.IsValid())
 284                     {
 285                         const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
 286                         if (prologue_byte_size)
 287                             break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
 288                     }
 289                 }
 290                 else if (sc.symbol)
 291                 {
 292                     break_addr = sc.symbol->GetAddress();
 293                     if (m_skip_prologue && break_addr.IsValid())
 294                     {
 295                         const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
 296                         if (prologue_byte_size)
 297                             break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
 298                     }
 299                 }
 300
 301                 if (break_addr.IsValid())
 302                 {
 303                     if (filter.AddressPasses(break_addr))
 304                     {
 305                         BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location));
 306                         if (bp_loc_sp && new_location && !m_breakpoint->IsInternal())
 307                         {
 308                             if (log)
 309                             {
 310                                 StreamString s;
 311                                 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
 312                                 log->Printf ("Added location: %s\n", s.GetData());
 313                             }
 314                         }
 315                     }
 316                 }
 317             }
 318         }
 319     }
 320
 321     return Searcher::eCallbackReturnContinue;
 322 }
 323
 324 Searcher::Depth
 325 BreakpointResolverName::GetDepth()
 326 {
 327     return Searcher::eDepthModule;
 328 }
 329
 330 void
 331 BreakpointResolverName::GetDescription (Stream *s)
 332 {
 333     if (m_match_type == Breakpoint::Regexp)
 334         s->Printf("regex = '%s'", m_regex.GetText());
 335     else
 336     {
 337         size_t num_names = m_lookups.size();
 338         if (num_names == 1)
 339             s->Printf("name = '%s'", m_lookups[0].name.GetCString());
 340         else
 341         {
 342             s->Printf("names = {");
 343             for (size_t i = 0; i < num_names - 1; i++)
 344             {
 345                 s->Printf ("'%s', ", m_lookups[i].name.GetCString());
 346             }
 347             s->Printf ("'%s'}", m_lookups[num_names - 1].name.GetCString());
 348         }
 349     }
 350 }
 351
 352 void
 353 BreakpointResolverName::Dump (Stream *s) const
 354 {
 355
 356 }
 357