1 files changed, 223 insertions, 0 deletions
diff --git a/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp b/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
new file mode 100644
index 000000000000..2cca7a66b014
--- /dev/null
+++ b/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
@@ -0,0 +1,223 @@
+//===-- SymbolFileBreakpad.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h"
+#include "Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/TypeMap.h"
+#include "lldb/Utility/Log.h"
+#include "llvm/ADT/StringExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::breakpad;
+
+namespace {
+class LineIterator {
+public:
+  // begin iterator for sections of given type
+  LineIterator(ObjectFile &obj, ConstString section_type)
+      : m_obj(&obj), m_section_type(section_type), m_next_section_idx(0) {
+    ++*this;
+  }
+
+  // end iterator
+  explicit LineIterator(ObjectFile &obj)
+      : m_obj(&obj),
+        m_next_section_idx(m_obj->GetSectionList()->GetNumSections(0)) {}
+
+  friend bool operator!=(const LineIterator &lhs, const LineIterator &rhs) {
+    assert(lhs.m_obj == rhs.m_obj);
+    if (lhs.m_next_section_idx != rhs.m_next_section_idx)
+      return true;
+    if (lhs.m_next_text.data() != rhs.m_next_text.data())
+      return true;
+    assert(lhs.m_current_text == rhs.m_current_text);
+    assert(rhs.m_next_text == rhs.m_next_text);
+    return false;
+  }
+
+  const LineIterator &operator++();
+  llvm::StringRef operator*() const { return m_current_text; }
+
+private:
+  ObjectFile *m_obj;
+  ConstString m_section_type;
+  uint32_t m_next_section_idx;
+  llvm::StringRef m_current_text;
+  llvm::StringRef m_next_text;
+};
+} // namespace
+
+const LineIterator &LineIterator::operator++() {
+  const SectionList &list = *m_obj->GetSectionList();
+  size_t num_sections = list.GetNumSections(0);
+  while (m_next_text.empty() && m_next_section_idx < num_sections) {
+    Section &sect = *list.GetSectionAtIndex(m_next_section_idx++);
+    if (sect.GetName() != m_section_type)
+      continue;
+    DataExtractor data;
+    m_obj->ReadSectionData(&sect, data);
+    m_next_text =
+        llvm::StringRef(reinterpret_cast<const char *>(data.GetDataStart()),
+                        data.GetByteSize());
+  }
+  std::tie(m_current_text, m_next_text) = m_next_text.split('\n');
+  return *this;
+}
+
+static llvm::iterator_range<LineIterator> lines(ObjectFile &obj,
+                                                ConstString section_type) {
+  return llvm::make_range(LineIterator(obj, section_type), LineIterator(obj));
+}
+
+void SymbolFileBreakpad::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance,
+                                DebuggerInitialize);
+}
+
+void SymbolFileBreakpad::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+ConstString SymbolFileBreakpad::GetPluginNameStatic() {
+  static ConstString g_name("breakpad");
+  return g_name;
+}
+
+uint32_t SymbolFileBreakpad::CalculateAbilities() {
+  if (!m_obj_file)
+    return 0;
+  if (m_obj_file->GetPluginName() != ObjectFileBreakpad::GetPluginNameStatic())
+    return 0;
+
+  return CompileUnits | Functions;
+}
+
+uint32_t SymbolFileBreakpad::GetNumCompileUnits() {
+  // TODO
+  return 0;
+}
+
+CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
+  // TODO
+  return nullptr;
+}
+
+size_t SymbolFileBreakpad::ParseFunctions(CompileUnit &comp_unit) {
+  // TODO
+  return 0;
+}
+
+bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) {
+  // TODO
+  return 0;
+}
+
+uint32_t
+SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
+                                         SymbolContextItem resolve_scope,
+                                         SymbolContext &sc) {
+  // TODO
+  return 0;
+}
+
+uint32_t SymbolFileBreakpad::FindFunctions(
+    const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+    FunctionNameType name_type_mask, bool include_inlines, bool append,
+    SymbolContextList &sc_list) {
+  // TODO
+  if (!append)
+    sc_list.Clear();
+  return sc_list.GetSize();
+}
+
+uint32_t SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
+                                           bool include_inlines, bool append,
+                                           SymbolContextList &sc_list) {
+  // TODO
+  if (!append)
+    sc_list.Clear();
+  return sc_list.GetSize();
+}
+
+uint32_t SymbolFileBreakpad::FindTypes(
+    const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+    bool append, uint32_t max_matches,
+    llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
+  if (!append)
+    types.Clear();
+  return types.GetSize();
+}
+
+size_t
+SymbolFileBreakpad::FindTypes(const std::vector<CompilerContext> &context,
+                              bool append, TypeMap &types) {
+  if (!append)
+    types.Clear();
+  return types.GetSize();
+}
+
+void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
+  Module &module = *m_obj_file->GetModule();
+  addr_t base = module.GetObjectFile()->GetBaseAddress().GetFileAddress();
+  if (base == LLDB_INVALID_ADDRESS) {
+    LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping "
+                  "symtab population.");
+    return;
+  }
+
+  const SectionList &list = *module.GetSectionList();
+  for (llvm::StringRef line : lines(*m_obj_file, ConstString("PUBLIC"))) {
+    // PUBLIC [m] address param_size name
+    // skip PUBLIC keyword
+    line = getToken(line).second;
+    llvm::StringRef token;
+    std::tie(token, line) = getToken(line);
+    if (token == "m")
+      std::tie(token, line) = getToken(line);
+
+    addr_t address;
+    if (!to_integer(token, address, 16))
+      continue;
+    address += base;
+
+    // skip param_size
+    line = getToken(line).second;
+
+    llvm::StringRef name = line.trim();
+
+    SectionSP section_sp = list.FindSectionContainingFileAddress(address);
+    if (!section_sp) {
+      LLDB_LOG(log,
+               "Ignoring symbol {0}, whose address ({1}) is outside of the "
+               "object file. Mismatched symbol file?",
+               name, address);
+      continue;
+    }
+
+    symtab.AddSymbol(Symbol(
+        /*symID*/ 0, Mangled(name, /*is_mangled*/ false), eSymbolTypeCode,
+        /*is_global*/ true, /*is_debug*/ false, /*is_trampoline*/ false,
+        /*is_artificial*/ false,
+        AddressRange(section_sp, address - section_sp->GetFileAddress(), 0),
+        /*size_is_valid*/ 0, /*contains_linker_annotations*/ false,
+        /*flags*/ 0));
+  }
+
+  // TODO: Process FUNC records as well.
+
+  symtab.CalculateSymbolSizes();
+}