llvm/llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

//===-- LVSymbol.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 LVSymbol class.
//
//===----------------------------------------------------------------------===//

#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
#include "llvm/DebugInfo/LogicalView/Core/LVLocation.h"
#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"

usingnamespacellvm;
usingnamespacellvm::logicalview;

#define DEBUG_TYPE …

namespace {
const char *const KindCallSiteParameter = …;
const char *const KindConstant = …;
const char *const KindInherits = …;
const char *const KindMember = …;
const char *const KindParameter = …;
const char *const KindUndefined = …;
const char *const KindUnspecified = …;
const char *const KindVariable = …;
} // end anonymous namespace

// Return a string representation for the symbol kind.
const char *LVSymbol::kind() const { … }

LVSymbolDispatch LVSymbol::Dispatch = …;

// Add a Location Entry.
void LVSymbol::addLocation(dwarf::Attribute Attr, LVAddress LowPC,
                           LVAddress HighPC, LVUnsigned SectionOffset,
                           uint64_t LocDescOffset, bool CallSiteLocation) { … }

// Add a Location Record.
void LVSymbol::addLocationOperands(LVSmall Opcode,
                                   ArrayRef<uint64_t> Operands) { … }

// Add a Location Entry.
void LVSymbol::addLocationConstant(dwarf::Attribute Attr, LVUnsigned Constant,
                                   uint64_t LocDescOffset) { … }

LVLocations::iterator LVSymbol::addLocationGap(LVLocations::iterator Pos,
                                               LVAddress LowPC,
                                               LVAddress HighPC) { … }

void LVSymbol::fillLocationGaps() { … }

// Get all the locations based on the valid function.
void LVSymbol::getLocations(LVLocations &LocationList,
                            LVValidLocation ValidLocation, bool RecordInvalid) { … }

void LVSymbol::getLocations(LVLocations &LocationList) const { … }

// Calculate coverage factor.
void LVSymbol::calculateCoverage() { … }

void LVSymbol::resolveName() { … }

void LVSymbol::resolveReferences() { … }

StringRef LVSymbol::resolveReferencesChain() { … }

void LVSymbol::markMissingParents(const LVSymbols *References,
                                  const LVSymbols *Targets) { … }

LVSymbol *LVSymbol::findIn(const LVSymbols *Targets) const { … }

// Check for a match on the arguments of a function.
bool LVSymbol::parametersMatch(const LVSymbols *References,
                               const LVSymbols *Targets) { … }

// Return the symbols which are parameters.
void LVSymbol::getParameters(const LVSymbols *Symbols, LVSymbols *Parameters) { … }

bool LVSymbol::equals(const LVSymbol *Symbol) const { … }

bool LVSymbol::equals(const LVSymbols *References, const LVSymbols *Targets) { … }

void LVSymbol::report(LVComparePass Pass) { … }

void LVSymbol::printLocations(raw_ostream &OS, bool Full) const { … }

void LVSymbol::print(raw_ostream &OS, bool Full) const { … }

void LVSymbol::printExtra(raw_ostream &OS, bool Full) const { … }