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

//===-- SymbolFileBreakpad.cpp --------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h"
#include "Plugins/ObjectFile/Breakpad/BreakpadRecords.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/CompileUnit.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/TypeMap.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/StringExtras.h"
#include <optional>

usingnamespacelldb;
usingnamespacelldb_private;
usingnamespacelldb_private::breakpad;

LLDB_PLUGIN_DEFINE(…)

char SymbolFileBreakpad::ID;

class SymbolFileBreakpad::LineIterator { … };

SymbolFileBreakpad::LineIterator::LineIterator(ObjectFile &obj,
                                               Record::Kind section_type,
                                               Bookmark bookmark)
    : … { … }

const SymbolFileBreakpad::LineIterator &
SymbolFileBreakpad::LineIterator::operator++() { … }

llvm::iterator_range<SymbolFileBreakpad::LineIterator>
SymbolFileBreakpad::lines(Record::Kind section_type) { … }

namespace {
// A helper class for constructing the list of support files for a given compile
// unit.
class SupportFileMap { … };
} // namespace

FileSpecList SupportFileMap::translate(const FileSpec &cu_spec,
                                       llvm::ArrayRef<FileSpec> all_files) { … }

void SymbolFileBreakpad::Initialize() { … }

void SymbolFileBreakpad::Terminate() { … }

uint32_t SymbolFileBreakpad::CalculateAbilities() { … }

uint32_t SymbolFileBreakpad::CalculateNumCompileUnits() { … }

CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) { … }

FunctionSP SymbolFileBreakpad::GetOrCreateFunction(CompileUnit &comp_unit) { … }

size_t SymbolFileBreakpad::ParseFunctions(CompileUnit &comp_unit) { … }

bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) { … }

bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit,
                                           SupportFileList &support_files) { … }

size_t SymbolFileBreakpad::ParseBlocksRecursive(Function &func) { … }

void SymbolFileBreakpad::ParseInlineOriginRecords() { … }

uint32_t
SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
                                         SymbolContextItem resolve_scope,
                                         SymbolContext &sc) { … }

uint32_t SymbolFileBreakpad::ResolveSymbolContext(
    const SourceLocationSpec &src_location_spec,
    lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) { … }

void SymbolFileBreakpad::FindFunctions(
    const Module::LookupInfo &lookup_info,
    const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
    SymbolContextList &sc_list) { … }

void SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
                                       bool include_inlines,
                                       SymbolContextList &sc_list) { … }

void SymbolFileBreakpad::AddSymbols(Symtab &symtab) { … }

llvm::Expected<lldb::addr_t>
SymbolFileBreakpad::GetParameterStackSize(Symbol &symbol) { … }

static std::optional<std::pair<llvm::StringRef, llvm::StringRef>>
GetRule(llvm::StringRef &unwind_rules) { … }

static const RegisterInfo *
ResolveRegister(const llvm::Triple &triple,
                const SymbolFile::RegisterInfoResolver &resolver,
                llvm::StringRef name) { … }

static const RegisterInfo *
ResolveRegisterOrRA(const llvm::Triple &triple,
                    const SymbolFile::RegisterInfoResolver &resolver,
                    llvm::StringRef name) { … }

llvm::ArrayRef<uint8_t> SymbolFileBreakpad::SaveAsDWARF(postfix::Node &node) { … }

bool SymbolFileBreakpad::ParseCFIUnwindRow(llvm::StringRef unwind_rules,
                                        const RegisterInfoResolver &resolver,
                                        UnwindPlan::Row &row) { … }

UnwindPlanSP
SymbolFileBreakpad::GetUnwindPlan(const Address &address,
                                  const RegisterInfoResolver &resolver) { … }

UnwindPlanSP
SymbolFileBreakpad::ParseCFIUnwindPlan(const Bookmark &bookmark,
                                       const RegisterInfoResolver &resolver) { … }

UnwindPlanSP
SymbolFileBreakpad::ParseWinUnwindPlan(const Bookmark &bookmark,
                                       const RegisterInfoResolver &resolver) { … }

addr_t SymbolFileBreakpad::GetBaseFileAddress() { … }

// Parse out all the FILE records from the breakpad file. These will be needed
// when constructing the support file lists for individual compile units.
void SymbolFileBreakpad::ParseFileRecords() { … }

void SymbolFileBreakpad::ParseCUData() { … }

// Construct the list of support files and line table entries for the given
// compile unit.
void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu,
                                                       CompUnitData &data) { … }

void SymbolFileBreakpad::ParseUnwindData() { … }

uint64_t SymbolFileBreakpad::GetDebugInfoSize(bool load_all_debug_info) { … }