contrib/llvm/tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

   1 //===-- SymbolFileBreakpad.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 "Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h"
  11 #include "Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h"
  12 #include "lldb/Core/Module.h"
  13 #include "lldb/Core/PluginManager.h"
  14 #include "lldb/Core/Section.h"
  15 #include "lldb/Host/FileSystem.h"
  16 #include "lldb/Symbol/ObjectFile.h"
  17 #include "lldb/Symbol/TypeMap.h"
  18 #include "lldb/Utility/Log.h"
  19 #include "llvm/ADT/StringExtras.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23 using namespace lldb_private::breakpad;
  24
  25 namespace {
  26 class LineIterator {
  27 public:
  28   // begin iterator for sections of given type
  29   LineIterator(ObjectFile &obj, ConstString section_type)
  30       : m_obj(&obj), m_section_type(section_type), m_next_section_idx(0) {
  31     ++*this;
  32   }
  33
  34   // end iterator
  35   explicit LineIterator(ObjectFile &obj)
  36       : m_obj(&obj),
  37         m_next_section_idx(m_obj->GetSectionList()->GetNumSections(0)) {}
  38
  39   friend bool operator!=(const LineIterator &lhs, const LineIterator &rhs) {
  40     assert(lhs.m_obj == rhs.m_obj);
  41     if (lhs.m_next_section_idx != rhs.m_next_section_idx)
  42       return true;
  43     if (lhs.m_next_text.data() != rhs.m_next_text.data())
  44       return true;
  45     assert(lhs.m_current_text == rhs.m_current_text);
  46     assert(rhs.m_next_text == rhs.m_next_text);
  47     return false;
  48   }
  49
  50   const LineIterator &operator++();
  51   llvm::StringRef operator*() const { return m_current_text; }
  52
  53 private:
  54   ObjectFile *m_obj;
  55   ConstString m_section_type;
  56   uint32_t m_next_section_idx;
  57   llvm::StringRef m_current_text;
  58   llvm::StringRef m_next_text;
  59 };
  60 } // namespace
  61
  62 const LineIterator &LineIterator::operator++() {
  63   const SectionList &list = *m_obj->GetSectionList();
  64   size_t num_sections = list.GetNumSections(0);
  65   while (m_next_text.empty() && m_next_section_idx < num_sections) {
  66     Section &sect = *list.GetSectionAtIndex(m_next_section_idx++);
  67     if (sect.GetName() != m_section_type)
  68       continue;
  69     DataExtractor data;
  70     m_obj->ReadSectionData(&sect, data);
  71     m_next_text =
  72         llvm::StringRef(reinterpret_cast<const char *>(data.GetDataStart()),
  73                         data.GetByteSize());
  74   }
  75   std::tie(m_current_text, m_next_text) = m_next_text.split('\n');
  76   return *this;
  77 }
  78
  79 static llvm::iterator_range<LineIterator> lines(ObjectFile &obj,
  80                                                 ConstString section_type) {
  81   return llvm::make_range(LineIterator(obj, section_type), LineIterator(obj));
  82 }
  83
  84 void SymbolFileBreakpad::Initialize() {
  85   PluginManager::RegisterPlugin(GetPluginNameStatic(),
  86                                 GetPluginDescriptionStatic(), CreateInstance,
  87                                 DebuggerInitialize);
  88 }
  89
  90 void SymbolFileBreakpad::Terminate() {
  91   PluginManager::UnregisterPlugin(CreateInstance);
  92 }
  93
  94 ConstString SymbolFileBreakpad::GetPluginNameStatic() {
  95   static ConstString g_name("breakpad");
  96   return g_name;
  97 }
  98
  99 uint32_t SymbolFileBreakpad::CalculateAbilities() {
 100   if (!m_obj_file)
 101     return 0;
 102   if (m_obj_file->GetPluginName() != ObjectFileBreakpad::GetPluginNameStatic())
 103     return 0;
 104
 105   return CompileUnits | Functions;
 106 }
 107
 108 uint32_t SymbolFileBreakpad::GetNumCompileUnits() {
 109   // TODO
 110   return 0;
 111 }
 112
 113 CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
 114   // TODO
 115   return nullptr;
 116 }
 117
 118 size_t SymbolFileBreakpad::ParseFunctions(CompileUnit &comp_unit) {
 119   // TODO
 120   return 0;
 121 }
 122
 123 bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) {
 124   // TODO
 125   return 0;
 126 }
 127
 128 uint32_t
 129 SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
 130                                          SymbolContextItem resolve_scope,
 131                                          SymbolContext &sc) {
 132   // TODO
 133   return 0;
 134 }
 135
 136 uint32_t SymbolFileBreakpad::FindFunctions(
 137     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
 138     FunctionNameType name_type_mask, bool include_inlines, bool append,
 139     SymbolContextList &sc_list) {
 140   // TODO
 141   if (!append)
 142     sc_list.Clear();
 143   return sc_list.GetSize();
 144 }
 145
 146 uint32_t SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
 147                                            bool include_inlines, bool append,
 148                                            SymbolContextList &sc_list) {
 149   // TODO
 150   if (!append)
 151     sc_list.Clear();
 152   return sc_list.GetSize();
 153 }
 154
 155 uint32_t SymbolFileBreakpad::FindTypes(
 156     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
 157     bool append, uint32_t max_matches,
 158     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
 159   if (!append)
 160     types.Clear();
 161   return types.GetSize();
 162 }
 163
 164 size_t
 165 SymbolFileBreakpad::FindTypes(const std::vector<CompilerContext> &context,
 166                               bool append, TypeMap &types) {
 167   if (!append)
 168     types.Clear();
 169   return types.GetSize();
 170 }
 171
 172 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
 173   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
 174   Module &module = *m_obj_file->GetModule();
 175   addr_t base = module.GetObjectFile()->GetBaseAddress().GetFileAddress();
 176   if (base == LLDB_INVALID_ADDRESS) {
 177     LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping "
 178                   "symtab population.");
 179     return;
 180   }
 181
 182   const SectionList &list = *module.GetSectionList();
 183   for (llvm::StringRef line : lines(*m_obj_file, ConstString("PUBLIC"))) {
 184     // PUBLIC [m] address param_size name
 185     // skip PUBLIC keyword
 186     line = getToken(line).second;
 187     llvm::StringRef token;
 188     std::tie(token, line) = getToken(line);
 189     if (token == "m")
 190       std::tie(token, line) = getToken(line);
 191
 192     addr_t address;
 193     if (!to_integer(token, address, 16))
 194       continue;
 195     address += base;
 196
 197     // skip param_size
 198     line = getToken(line).second;
 199
 200     llvm::StringRef name = line.trim();
 201
 202     SectionSP section_sp = list.FindSectionContainingFileAddress(address);
 203     if (!section_sp) {
 204       LLDB_LOG(log,
 205                "Ignoring symbol {0}, whose address ({1}) is outside of the "
 206                "object file. Mismatched symbol file?",
 207                name, address);
 208       continue;
 209     }
 210
 211     symtab.AddSymbol(Symbol(
 212         /*symID*/ 0, Mangled(name, /*is_mangled*/ false), eSymbolTypeCode,
 213         /*is_global*/ true, /*is_debug*/ false, /*is_trampoline*/ false,
 214         /*is_artificial*/ false,
 215         AddressRange(section_sp, address - section_sp->GetFileAddress(), 0),
 216         /*size_is_valid*/ 0, /*contains_linker_annotations*/ false,
 217         /*flags*/ 0));
 218   }
 219
 220   // TODO: Process FUNC records as well.
 221
 222   symtab.CalculateSymbolSizes();
 223 }