LLDB mainline
ObjectFileBreakpad.cpp
Go to the documentation of this file.
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
13#include "lldb/Core/Section.h"
14#include <optional>
15
16using namespace lldb;
17using namespace lldb_private;
18using namespace lldb_private::breakpad;
19
21
22namespace {
23struct Header {
24 ArchSpec arch;
25 UUID uuid;
26 static std::optional<Header> parse(llvm::StringRef text);
27};
28} // namespace
29
30std::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
49
54}
55
58}
59
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
88 const ModuleSP &module_sp, WritableDataBufferSP data_sp,
89 const ProcessSP &process_sp, addr_t header_addr) {
90 return nullptr;
91}
92
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
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
116 // We already parsed the header during initialization.
117 return true;
118}
119
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
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}
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
An architecture specification class.
Definition: ArchSpec.h:31
A uniqued constant string class.
Definition: ConstString.h:40
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
const uint8_t * GetDataStart() const
Get the data start pointer.
const uint8_t * GetDataEnd() const
Get the data end pointer.
A file utility class.
Definition: FileSpec.h:56
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
void Append(const ModuleSpec &spec)
Definition: ModuleSpec.h:308
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition: ObjectFile.h:757
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition: ObjectFile.h:761
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
Definition: ObjectFile.cpp:670
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
size_t AddSection(const lldb::SectionSP &section_sp)
Definition: Section.cpp:475
static std::optional< InfoRecord > parse(llvm::StringRef Line)
static std::optional< ModuleRecord > parse(llvm::StringRef Line)
static ObjectFile * CreateMemoryInstance(const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
static size_t GetModuleSpecifications(const FileSpec &file, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, ModuleSpecList &specs)
static ObjectFile * CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t file_offset, lldb::offset_t length)
ObjectFileBreakpad(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t offset, lldb::offset_t length, ArchSpec arch, UUID uuid)
void ParseSymtab(lldb_private::Symtab &symtab) override
Parse the symbol table into the provides symbol table object.
bool ParseHeader() override
Attempts to parse the object header.
void CreateSections(SectionList &unified_section_list) override
static std::optional< Kind > classify(llvm::StringRef Line)
Attempt to guess the kind of the record present in the argument without doing a full parse.
llvm::StringRef toString(Record::Kind K)
A class that represents a running process on the host machine.
Definition: SBAddress.h:15
uint64_t offset_t
Definition: lldb-types.h:85
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:385
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
Definition: lldb-forward.h:332
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:333
uint64_t addr_t
Definition: lldb-types.h:80
@ eSectionTypeOther
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:369