llvm/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

//===-- LVBinaryReader.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
//
//===----------------------------------------------------------------------===//
//
// This implements the LVBinaryReader class.
//
//===----------------------------------------------------------------------===//

#include "llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/FormatAdapters.h"
#include "llvm/Support/FormatVariadic.h"

usingnamespacellvm;
usingnamespacellvm::logicalview;

#define DEBUG_TYPE …

// Function names extracted from the object symbol table.
void LVSymbolTable::add(StringRef Name, LVScope *Function,
                        LVSectionIndex SectionIndex) { … }

void LVSymbolTable::add(StringRef Name, LVAddress Address,
                        LVSectionIndex SectionIndex, bool IsComdat) { … }

LVSectionIndex LVSymbolTable::update(LVScope *Function) { … }

const LVSymbolTableEntry &LVSymbolTable::getEntry(StringRef Name) { … }
LVAddress LVSymbolTable::getAddress(StringRef Name) { … }
LVSectionIndex LVSymbolTable::getIndex(StringRef Name) { … }
bool LVSymbolTable::getIsComdat(StringRef Name) { … }

void LVSymbolTable::print(raw_ostream &OS) { … }

void LVBinaryReader::addToSymbolTable(StringRef Name, LVScope *Function,
                                      LVSectionIndex SectionIndex) { … }
void LVBinaryReader::addToSymbolTable(StringRef Name, LVAddress Address,
                                      LVSectionIndex SectionIndex,
                                      bool IsComdat) { … }
LVSectionIndex LVBinaryReader::updateSymbolTable(LVScope *Function) { … }

const LVSymbolTableEntry &LVBinaryReader::getSymbolTableEntry(StringRef Name) { … }
LVAddress LVBinaryReader::getSymbolTableAddress(StringRef Name) { … }
LVSectionIndex LVBinaryReader::getSymbolTableIndex(StringRef Name) { … }
bool LVBinaryReader::getSymbolTableIsComdat(StringRef Name) { … }

void LVBinaryReader::mapVirtualAddress(const object::ObjectFile &Obj) { … }

void LVBinaryReader::mapVirtualAddress(const object::COFFObjectFile &COFFObj) { … }

Error LVBinaryReader::loadGenericTargetInfo(StringRef TheTriple,
                                            StringRef TheFeatures) { … }

Expected<std::pair<uint64_t, object::SectionRef>>
LVBinaryReader::getSection(LVScope *Scope, LVAddress Address,
                           LVSectionIndex SectionIndex) { … }

void LVBinaryReader::addSectionRange(LVSectionIndex SectionIndex,
                                     LVScope *Scope) { … }

void LVBinaryReader::addSectionRange(LVSectionIndex SectionIndex,
                                     LVScope *Scope, LVAddress LowerAddress,
                                     LVAddress UpperAddress) { … }

LVRange *LVBinaryReader::getSectionRanges(LVSectionIndex SectionIndex) { … }

Error LVBinaryReader::createInstructions(LVScope *Scope,
                                         LVSectionIndex SectionIndex,
                                         const LVNameInfo &NameInfo) { … }

Error LVBinaryReader::createInstructions(LVScope *Function,
                                         LVSectionIndex SectionIndex) { … }

Error LVBinaryReader::createInstructions() { … }

// During the traversal of the debug information sections, we created the
// logical lines representing the disassembled instructions from the text
// section and the logical lines representing the line records from the
// debug line section. Using the ranges associated with the logical scopes,
// we will allocate those logical lines to their logical scopes.
void LVBinaryReader::processLines(LVLines *DebugLines,
                                  LVSectionIndex SectionIndex,
                                  LVScope *Function) { … }

void LVBinaryReader::processLines(LVLines *DebugLines,
                                  LVSectionIndex SectionIndex) { … }

// Traverse the scopes for the given 'Function' looking for any inlined
// scopes with inlined lines, which are found in 'CUInlineeLines'.
void LVBinaryReader::includeInlineeLines(LVSectionIndex SectionIndex,
                                         LVScope *Function) { … }

void LVBinaryReader::print(raw_ostream &OS) const { … }