contrib/llvm/tools/lldb/source/Core/AddressResolverName.cpp

   1 //===-- AddressResolverName.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/Core/AddressResolverName.h"
  11
  12 #include "lldb/Core/Address.h"      // for Address, operator==
  13 #include "lldb/Core/AddressRange.h" // for AddressRange
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Symbol/Function.h"
  16 #include "lldb/Symbol/Symbol.h"
  17 #include "lldb/Symbol/SymbolContext.h"
  18 #include "lldb/Utility/Log.h"
  19 #include "lldb/Utility/Logging.h"   // for GetLogIfAllCategoriesSet, LIB...
  20 #include "lldb/Utility/Stream.h"    // for Stream
  21 #include "lldb/lldb-enumerations.h" // for SymbolType::eSymbolTypeCode
  22 #include "lldb/lldb-forward.h"      // for ModuleSP
  23 #include "lldb/lldb-types.h"        // for addr_t
  24 #include "llvm/ADT/StringRef.h"     // for StringRef
  25
  26 #include <memory> // for shared_ptr
  27 #include <string> // for string
  28 #include <vector> // for vector
  29
  30 #include <stdint.h> // for uint32_t
  31
  32 using namespace lldb;
  33 using namespace lldb_private;
  34
  35 AddressResolverName::AddressResolverName(const char *func_name,
  36                                          AddressResolver::MatchType type)
  37     : AddressResolver(), m_func_name(func_name), m_class_name(nullptr),
  38       m_regex(), m_match_type(type) {
  39   if (m_match_type == AddressResolver::Regexp) {
  40     if (!m_regex.Compile(m_func_name.GetStringRef())) {
  41       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
  42
  43       if (log)
  44         log->Warning("function name regexp: \"%s\" did not compile.",
  45                      m_func_name.AsCString());
  46     }
  47   }
  48 }
  49
  50 AddressResolverName::AddressResolverName(RegularExpression &func_regex)
  51     : AddressResolver(), m_func_name(nullptr), m_class_name(nullptr),
  52       m_regex(func_regex), m_match_type(AddressResolver::Regexp) {}
  53
  54 AddressResolverName::AddressResolverName(const char *class_name,
  55                                          const char *method,
  56                                          AddressResolver::MatchType type)
  57     : AddressResolver(), m_func_name(method), m_class_name(class_name),
  58       m_regex(), m_match_type(type) {}
  59
  60 AddressResolverName::~AddressResolverName() = default;
  61
  62 // FIXME: Right now we look at the module level, and call the module's
  63 // "FindFunctions".
  64 // Greg says he will add function tables, maybe at the CompileUnit level to
  65 // accelerate function
  66 // lookup.  At that point, we should switch the depth to CompileUnit, and look
  67 // in these tables.
  68
  69 Searcher::CallbackReturn
  70 AddressResolverName::SearchCallback(SearchFilter &filter,
  71                                     SymbolContext &context, Address *addr,
  72                                     bool containing) {
  73   SymbolContextList func_list;
  74   SymbolContextList sym_list;
  75
  76   bool skip_prologue = true;
  77   uint32_t i;
  78   SymbolContext sc;
  79   Address func_addr;
  80
  81   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
  82
  83   if (m_class_name) {
  84     if (log)
  85       log->Warning("Class/method function specification not supported yet.\n");
  86     return Searcher::eCallbackReturnStop;
  87   }
  88
  89   const bool include_symbols = false;
  90   const bool include_inlines = true;
  91   const bool append = false;
  92   switch (m_match_type) {
  93   case AddressResolver::Exact:
  94     if (context.module_sp) {
  95       context.module_sp->FindSymbolsWithNameAndType(m_func_name,
  96                                                     eSymbolTypeCode, sym_list);
  97       context.module_sp->FindFunctions(m_func_name, nullptr,
  98                                        eFunctionNameTypeAuto, include_symbols,
  99                                        include_inlines, append, func_list);
 100     }
 101     break;
 102
 103   case AddressResolver::Regexp:
 104     if (context.module_sp) {
 105       context.module_sp->FindSymbolsMatchingRegExAndType(
 106           m_regex, eSymbolTypeCode, sym_list);
 107       context.module_sp->FindFunctions(m_regex, include_symbols,
 108                                        include_inlines, append, func_list);
 109     }
 110     break;
 111
 112   case AddressResolver::Glob:
 113     if (log)
 114       log->Warning("glob is not supported yet.");
 115     break;
 116   }
 117
 118   // Remove any duplicates between the function list and the symbol list
 119   if (func_list.GetSize()) {
 120     for (i = 0; i < func_list.GetSize(); i++) {
 121       if (!func_list.GetContextAtIndex(i, sc))
 122         continue;
 123
 124       if (sc.function == nullptr)
 125         continue;
 126       uint32_t j = 0;
 127       while (j < sym_list.GetSize()) {
 128         SymbolContext symbol_sc;
 129         if (sym_list.GetContextAtIndex(j, symbol_sc)) {
 130           if (symbol_sc.symbol && symbol_sc.symbol->ValueIsAddress()) {
 131             if (sc.function->GetAddressRange().GetBaseAddress() ==
 132                 symbol_sc.symbol->GetAddressRef()) {
 133               sym_list.RemoveContextAtIndex(j);
 134               continue; // Don't increment j
 135             }
 136           }
 137         }
 138
 139         j++;
 140       }
 141     }
 142
 143     for (i = 0; i < func_list.GetSize(); i++) {
 144       if (func_list.GetContextAtIndex(i, sc)) {
 145         if (sc.function) {
 146           func_addr = sc.function->GetAddressRange().GetBaseAddress();
 147           addr_t byte_size = sc.function->GetAddressRange().GetByteSize();
 148           if (skip_prologue) {
 149             const uint32_t prologue_byte_size =
 150                 sc.function->GetPrologueByteSize();
 151             if (prologue_byte_size) {
 152               func_addr.SetOffset(func_addr.GetOffset() + prologue_byte_size);
 153               byte_size -= prologue_byte_size;
 154             }
 155           }
 156
 157           if (filter.AddressPasses(func_addr)) {
 158             AddressRange new_range(func_addr, byte_size);
 159             m_address_ranges.push_back(new_range);
 160           }
 161         }
 162       }
 163     }
 164   }
 165
 166   for (i = 0; i < sym_list.GetSize(); i++) {
 167     if (sym_list.GetContextAtIndex(i, sc)) {
 168       if (sc.symbol && sc.symbol->ValueIsAddress()) {
 169         func_addr = sc.symbol->GetAddressRef();
 170         addr_t byte_size = sc.symbol->GetByteSize();
 171
 172         if (skip_prologue) {
 173           const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
 174           if (prologue_byte_size) {
 175             func_addr.SetOffset(func_addr.GetOffset() + prologue_byte_size);
 176             byte_size -= prologue_byte_size;
 177           }
 178         }
 179
 180         if (filter.AddressPasses(func_addr)) {
 181           AddressRange new_range(func_addr, byte_size);
 182           m_address_ranges.push_back(new_range);
 183         }
 184       }
 185     }
 186   }
 187   return Searcher::eCallbackReturnContinue;
 188 }
 189
 190 Searcher::Depth AddressResolverName::GetDepth() {
 191   return Searcher::eDepthModule;
 192 }
 193
 194 void AddressResolverName::GetDescription(Stream *s) {
 195   s->PutCString("Address by function name: ");
 196
 197   if (m_match_type == AddressResolver::Regexp)
 198     s->Printf("'%s' (regular expression)", m_regex.GetText().str().c_str());
 199   else
 200     s->Printf("'%s'", m_func_name.AsCString());
 201 }