llvm/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp

//===-- BreakpadRecords.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/ObjectFile/Breakpad/BreakpadRecords.h"
#include "lldb/lldb-defines.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/FormatVariadic.h"
#include <optional>

usingnamespacelldb_private;
usingnamespacelldb_private::breakpad;

namespace {
enum class Token { … };
}

template<typename T>
static T stringTo(llvm::StringRef Str);

template <> Token stringTo<Token>(llvm::StringRef Str) { … }

template <>
llvm::Triple::OSType stringTo<llvm::Triple::OSType>(llvm::StringRef Str) { … }

template <>
llvm::Triple::ArchType stringTo<llvm::Triple::ArchType>(llvm::StringRef Str) { … }

template<typename T>
static T consume(llvm::StringRef &Str) { … }

/// Return the number of hex digits needed to encode an (POD) object of a given
/// type.
template <typename T> static constexpr size_t hex_digits() { … }

static UUID parseModuleId(llvm::Triple::OSType os, llvm::StringRef str) { … }

std::optional<Record::Kind> Record::classify(llvm::StringRef Line) { … }

std::optional<ModuleRecord> ModuleRecord::parse(llvm::StringRef Line) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const ModuleRecord &R) { … }

std::optional<InfoRecord> InfoRecord::parse(llvm::StringRef Line) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const InfoRecord &R) { … }

template <typename T>
static std::optional<T> parseNumberName(llvm::StringRef Line, Token TokenType) { … }

std::optional<FileRecord> FileRecord::parse(llvm::StringRef Line) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const FileRecord &R) { … }

std::optional<InlineOriginRecord>
InlineOriginRecord::parse(llvm::StringRef Line) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const InlineOriginRecord &R) { … }

static bool parsePublicOrFunc(llvm::StringRef Line, bool &Multiple,
                              lldb::addr_t &Address, lldb::addr_t *Size,
                              lldb::addr_t &ParamSize, llvm::StringRef &Name) { … }

std::optional<FuncRecord> FuncRecord::parse(llvm::StringRef Line) { … }

bool breakpad::operator==(const FuncRecord &L, const FuncRecord &R) { … }
llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const FuncRecord &R) { … }

std::optional<InlineRecord> InlineRecord::parse(llvm::StringRef Line) { … }

bool breakpad::operator==(const InlineRecord &L, const InlineRecord &R) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const InlineRecord &R) { … }

std::optional<LineRecord> LineRecord::parse(llvm::StringRef Line) { … }

bool breakpad::operator==(const LineRecord &L, const LineRecord &R) { … }
llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const LineRecord &R) { … }

std::optional<PublicRecord> PublicRecord::parse(llvm::StringRef Line) { … }

bool breakpad::operator==(const PublicRecord &L, const PublicRecord &R) { … }
llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const PublicRecord &R) { … }

std::optional<StackCFIRecord> StackCFIRecord::parse(llvm::StringRef Line) { … }

bool breakpad::operator==(const StackCFIRecord &L, const StackCFIRecord &R) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const StackCFIRecord &R) { … }

std::optional<StackWinRecord> StackWinRecord::parse(llvm::StringRef Line) { … }

bool breakpad::operator==(const StackWinRecord &L, const StackWinRecord &R) { … }

llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                        const StackWinRecord &R) { … }

llvm::StringRef breakpad::toString(Record::Kind K) { … }