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

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

#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
#include "llvm/DebugInfo/LogicalView/Core/LVCompare.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 KindBaseType = …;
const char *const KindConst = …;
const char *const KindEnumerator = …;
const char *const KindImport = …;
const char *const KindPointer = …;
const char *const KindPointerMember = …;
const char *const KindReference = …;
const char *const KindRestrict = …;
const char *const KindRvalueReference = …;
const char *const KindSubrange = …;
const char *const KindTemplateTemplate = …;
const char *const KindTemplateType = …;
const char *const KindTemplateValue = …;
const char *const KindTypeAlias = …;
const char *const KindUndefined = …;
const char *const KindUnaligned = …;
const char *const KindUnspecified = …;
const char *const KindVolatile = …;
} // end anonymous namespace

//===----------------------------------------------------------------------===//
// DWARF Type.
//===----------------------------------------------------------------------===//
// Return a string representation for the type kind.
const char *LVType::kind() const { … }

LVTypeDispatch LVType::Dispatch = …;

void LVType::resolveReferences() { … }

void LVType::resolveName() { … }

StringRef LVType::resolveReferencesChain() { … }

void LVType::markMissingParents(const LVTypes *References,
                                const LVTypes *Targets) { … }

LVType *LVType::findIn(const LVTypes *Targets) const { … }

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

// Return the types which are parameters.
void LVType::getParameters(const LVTypes *Types, LVTypes *TypesParam,
                           LVScopes *ScopesParam) { … }

bool LVType::equals(const LVType *Type) const { … }

bool LVType::equals(const LVTypes *References, const LVTypes *Targets) { … }

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

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

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

//===----------------------------------------------------------------------===//
// DWARF typedef.
//===----------------------------------------------------------------------===//
// Return the underlying type for a typedef, which can be a type or scope.
LVElement *LVTypeDefinition::getUnderlyingType() { … }

void LVTypeDefinition::resolveExtra() { … }

bool LVTypeDefinition::equals(const LVType *Type) const { … }

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

//===----------------------------------------------------------------------===//
// DWARF enumerator (DW_TAG_enumerator).
//===----------------------------------------------------------------------===//
bool LVTypeEnumerator::equals(const LVType *Type) const { … }

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

//===----------------------------------------------------------------------===//
// DWARF import (DW_TAG_imported_module / DW_TAG_imported_declaration).
//===----------------------------------------------------------------------===//
bool LVTypeImport::equals(const LVType *Type) const { … }

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

//===----------------------------------------------------------------------===//
// DWARF Template parameter holder (type or param).
//===----------------------------------------------------------------------===//
LVTypeParam::LVTypeParam() : … { … }

// Encode the specific template argument.
void LVTypeParam::encodeTemplateArgument(std::string &Name) const { … }

bool LVTypeParam::equals(const LVType *Type) const { … }

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

//===----------------------------------------------------------------------===//
// DW_TAG_subrange_type
//===----------------------------------------------------------------------===//
void LVTypeSubrange::resolveExtra() { … }

bool LVTypeSubrange::equals(const LVType *Type) const { … }

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