lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

   1 //===-- ObjectFileBreakpad.cpp --------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h"
  10 #include "Plugins/ObjectFile/Breakpad/BreakpadRecords.h"
  11 #include "lldb/Core/ModuleSpec.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Core/Section.h"
  14 #include <optional>
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18 using namespace lldb_private::breakpad;
  19
  20 LLDB_PLUGIN_DEFINE(ObjectFileBreakpad)
  21
  22 namespace {
  23 struct Header {
  24   ArchSpec arch;
  25   UUID uuid;
  26   static std::optional<Header> parse(llvm::StringRef text);
  27 };
  28 } // namespace
  29
  30 std::optional<Header> Header::parse(llvm::StringRef text) {
  31   llvm::StringRef line;
  32   std::tie(line, text) = text.split('\n');
  33   auto Module = ModuleRecord::parse(line);
  34   if (!Module)
  35     return std::nullopt;
  36
  37   llvm::Triple triple;
  38   triple.setArch(Module->Arch);
  39   triple.setOS(Module->OS);
  40
  41   std::tie(line, text) = text.split('\n');
  42
  43   auto Info = InfoRecord::parse(line);
  44   UUID uuid = Info && Info->ID ? Info->ID : Module->ID;
  45   return Header{ArchSpec(triple), std::move(uuid)};
  46 }
  47
  48 char ObjectFileBreakpad::ID;
  49
  50 void ObjectFileBreakpad::Initialize() {
  51   PluginManager::RegisterPlugin(GetPluginNameStatic(),
  52                                 GetPluginDescriptionStatic(), CreateInstance,
  53                                 CreateMemoryInstance, GetModuleSpecifications);
  54 }
  55
  56 void ObjectFileBreakpad::Terminate() {
  57   PluginManager::UnregisterPlugin(CreateInstance);
  58 }
  59
  60 ObjectFile *ObjectFileBreakpad::CreateInstance(
  61     const ModuleSP &module_sp, DataBufferSP data_sp, offset_t data_offset,
  62     const FileSpec *file, offset_t file_offset, offset_t length) {
  63   if (!data_sp) {
  64     data_sp = MapFileData(*file, length, file_offset);
  65     if (!data_sp)
  66       return nullptr;
  67     data_offset = 0;
  68   }
  69   auto text = toStringRef(data_sp->GetData());
  70   std::optional<Header> header = Header::parse(text);
  71   if (!header)
  72     return nullptr;
  73
  74   // Update the data to contain the entire file if it doesn't already
  75   if (data_sp->GetByteSize() < length) {
  76     data_sp = MapFileData(*file, length, file_offset);
  77     if (!data_sp)
  78       return nullptr;
  79     data_offset = 0;
  80   }
  81
  82   return new ObjectFileBreakpad(module_sp, data_sp, data_offset, file,
  83                                 file_offset, length, std::move(header->arch),
  84                                 std::move(header->uuid));
  85 }
  86
  87 ObjectFile *ObjectFileBreakpad::CreateMemoryInstance(
  88     const ModuleSP &module_sp, WritableDataBufferSP data_sp,
  89     const ProcessSP &process_sp, addr_t header_addr) {
  90   return nullptr;
  91 }
  92
  93 size_t ObjectFileBreakpad::GetModuleSpecifications(
  94     const FileSpec &file, DataBufferSP &data_sp, offset_t data_offset,
  95     offset_t file_offset, offset_t length, ModuleSpecList &specs) {
  96   auto text = toStringRef(data_sp->GetData());
  97   std::optional<Header> header = Header::parse(text);
  98   if (!header)
  99     return 0;
 100   ModuleSpec spec(file, std::move(header->arch));
 101   spec.GetUUID() = std::move(header->uuid);
 102   specs.Append(spec);
 103   return 1;
 104 }
 105
 106 ObjectFileBreakpad::ObjectFileBreakpad(const ModuleSP &module_sp,
 107                                        DataBufferSP &data_sp,
 108                                        offset_t data_offset,
 109                                        const FileSpec *file, offset_t offset,
 110                                        offset_t length, ArchSpec arch,
 111                                        UUID uuid)
 112     : ObjectFile(module_sp, file, offset, length, data_sp, data_offset),
 113       m_arch(std::move(arch)), m_uuid(std::move(uuid)) {}
 114
 115 bool ObjectFileBreakpad::ParseHeader() {
 116   // We already parsed the header during initialization.
 117   return true;
 118 }
 119
 120 void ObjectFileBreakpad::ParseSymtab(Symtab &symtab) {
 121   // Nothing to do for breakpad files, all information is parsed as debug info
 122   // which means "lldb_private::Function" objects are used, or symbols are added
 123   // by the SymbolFileBreakpad::AddSymbols(...) function in the symbol file.
 124 }
 125
 126 void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) {
 127   if (m_sections_up)
 128     return;
 129   m_sections_up = std::make_unique<SectionList>();
 130
 131   std::optional<Record::Kind> current_section;
 132   offset_t section_start;
 133   llvm::StringRef text = toStringRef(m_data.GetData());
 134   uint32_t next_section_id = 1;
 135   auto maybe_add_section = [&](const uint8_t *end_ptr) {
 136     if (!current_section)
 137       return; // We have been called before parsing the first line.
 138
 139     offset_t end_offset = end_ptr - m_data.GetDataStart();
 140     auto section_sp = std::make_shared<Section>(
 141         GetModule(), this, next_section_id++,
 142         ConstString(toString(*current_section)), eSectionTypeOther,
 143         /*file_vm_addr*/ 0, /*vm_size*/ 0, section_start,
 144         end_offset - section_start, /*log2align*/ 0, /*flags*/ 0);
 145     m_sections_up->AddSection(section_sp);
 146     unified_section_list.AddSection(section_sp);
 147   };
 148   while (!text.empty()) {
 149     llvm::StringRef line;
 150     std::tie(line, text) = text.split('\n');
 151
 152     std::optional<Record::Kind> next_section = Record::classify(line);
 153     if (next_section == Record::Line || next_section == Record::Inline) {
 154       // Line/Inline records logically belong to the preceding Func record, so
 155       // we put them in the same section.
 156       next_section = Record::Func;
 157     }
 158     if (next_section == current_section)
 159       continue;
 160
 161     // Changing sections, finish off the previous one, if there was any.
 162     maybe_add_section(line.bytes_begin());
 163     // And start a new one.
 164     current_section = next_section;
 165     section_start = line.bytes_begin() - m_data.GetDataStart();
 166   }
 167   // Finally, add the last section.
 168   maybe_add_section(m_data.GetDataEnd());
 169 }