InputFile.cpp | Explore in Territory

//===- InputFile.cpp ------------------------------------------ *- C++ --*-===//
//
// 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 "llvm/DebugInfo/PDB/Native/InputFile.h"

#include "llvm/ADT/StringExtras.h"
#include "llvm/BinaryFormat/Magic.h"
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
#include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
#include "llvm/DebugInfo/MSF/MappedBlockStream.h"
#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
#include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
#include "llvm/DebugInfo/PDB/Native/RawError.h"
#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
#include "llvm/DebugInfo/PDB/PDB.h"
#include "llvm/Object/COFF.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/FormatVariadic.h"

usingnamespacellvm;
usingnamespacellvm::codeview;
usingnamespacellvm::object;
usingnamespacellvm::pdb;

InputFile::InputFile() = default;
InputFile::~InputFile() = default;

Expected<ModuleDebugStreamRef>
llvm::pdb::getModuleDebugStream(PDBFile &File, StringRef &ModuleName,
                                uint32_t Index) { … }

Expected<ModuleDebugStreamRef> llvm::pdb::getModuleDebugStream(PDBFile &File,
                                                               uint32_t Index) { … }

static inline bool isCodeViewDebugSubsection(object::SectionRef Section,
                                             StringRef Name,
                                             BinaryStreamReader &Reader) { … }

static inline bool isDebugSSection(object::SectionRef Section,
                                   DebugSubsectionArray &Subsections) { … }

static bool isDebugTSection(SectionRef Section, CVTypeArray &Types) { … }

static std::string formatChecksumKind(FileChecksumKind Kind) { … }

template <typename... Args>
static void formatInternal(LinePrinter &Printer, bool Append, Args &&...args) { … }

SymbolGroup::SymbolGroup(InputFile *File, uint32_t GroupIndex) : … { … }

StringRef SymbolGroup::name() const { … }

void SymbolGroup::updateDebugS(const codeview::DebugSubsectionArray &SS) { … }

void SymbolGroup::updatePdbModi(uint32_t Modi) { … }

void SymbolGroup::initializeForPdb(uint32_t Modi) { … }

void SymbolGroup::rebuildChecksumMap() { … }

const ModuleDebugStreamRef &SymbolGroup::getPdbModuleStream() const { … }

Expected<StringRef> SymbolGroup::getNameFromStringTable(uint32_t Offset) const { … }

Expected<StringRef> SymbolGroup::getNameFromChecksums(uint32_t Offset) const { … }

void SymbolGroup::formatFromFileName(LinePrinter &Printer, StringRef File,
                                     bool Append) const { … }

void SymbolGroup::formatFromChecksumsOffset(LinePrinter &Printer,
                                            uint32_t Offset,
                                            bool Append) const { … }

Expected<InputFile> InputFile::open(StringRef Path, bool AllowUnknownFile) { … }

PDBFile &InputFile::pdb() { … }

const PDBFile &InputFile::pdb() const { … }

object::COFFObjectFile &InputFile::obj() { … }

const object::COFFObjectFile &InputFile::obj() const { … }

MemoryBuffer &InputFile::unknown() { … }

const MemoryBuffer &InputFile::unknown() const { … }

StringRef InputFile::getFilePath() const { … }

bool InputFile::hasTypes() const { … }

bool InputFile::hasIds() const { … }

bool InputFile::isPdb() const { … }

bool InputFile::isObj() const { … }

bool InputFile::isUnknown() const { … }

codeview::LazyRandomTypeCollection &
InputFile::getOrCreateTypeCollection(TypeCollectionKind Kind) { … }

codeview::LazyRandomTypeCollection &InputFile::types() { … }

codeview::LazyRandomTypeCollection &InputFile::ids() { … }

iterator_range<SymbolGroupIterator> InputFile::symbol_groups() { … }

SymbolGroupIterator InputFile::symbol_groups_begin() { … }

SymbolGroupIterator InputFile::symbol_groups_end() { … }

SymbolGroupIterator::SymbolGroupIterator() : … { … }

SymbolGroupIterator::SymbolGroupIterator(InputFile &File) : … { … }

bool SymbolGroupIterator::operator==(const SymbolGroupIterator &R) const { … }

const SymbolGroup &SymbolGroupIterator::operator*() const { … }
SymbolGroup &SymbolGroupIterator::operator*() { … }

SymbolGroupIterator &SymbolGroupIterator::operator++() { … }

void SymbolGroupIterator::scanToNextDebugS() { … }

bool SymbolGroupIterator::isEnd() const { … }

static bool isMyCode(const SymbolGroup &Group) { … }

bool llvm::pdb::shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group,
                                      const FilterOptions &Filters) { … }
llvm/llvm/lib/DebugInfo/PDB/Native/InputFile.cpp
