llvm/llvm/lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp

//===- NativeTypeEnum.cpp - info about enum type ----------------*- 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/NativeTypeEnum.h"

#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
#include "llvm/DebugInfo/PDB/Native/NativeSymbolEnumerator.h"
#include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
#include "llvm/DebugInfo/PDB/Native/SymbolCache.h"
#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"

#include <cassert>
#include <optional>

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

namespace {
// Yea, this is a pretty terrible class name.  But if we have an enum:
//
// enum Foo {
//  A,
//  B
// };
//
// then A and B are the "enumerators" of the "enum" Foo.  And we need
// to enumerate them.
class NativeEnumEnumEnumerators : public IPDBEnumSymbols, TypeVisitorCallbacks { … };
} // namespace

NativeEnumEnumEnumerators::NativeEnumEnumEnumerators(
    NativeSession &Session, const NativeTypeEnum &ClassParent)
    : … { … }

Error NativeEnumEnumEnumerators::visitKnownMember(CVMemberRecord &CVM,
                                                  EnumeratorRecord &Record) { … }

Error NativeEnumEnumEnumerators::visitKnownMember(
    CVMemberRecord &CVM, ListContinuationRecord &Record) { … }

uint32_t NativeEnumEnumEnumerators::getChildCount() const { … }

std::unique_ptr<PDBSymbol>
NativeEnumEnumEnumerators::getChildAtIndex(uint32_t Index) const { … }

std::unique_ptr<PDBSymbol> NativeEnumEnumEnumerators::getNext() { … }

void NativeEnumEnumEnumerators::reset() { … }

NativeTypeEnum::NativeTypeEnum(NativeSession &Session, SymIndexId Id,
                               TypeIndex Index, EnumRecord Record)
    : … { … }

NativeTypeEnum::NativeTypeEnum(NativeSession &Session, SymIndexId Id,
                               NativeTypeEnum &UnmodifiedType,
                               codeview::ModifierRecord Modifier)
    : … { … }

NativeTypeEnum::~NativeTypeEnum() = default;

void NativeTypeEnum::dump(raw_ostream &OS, int Indent,
                          PdbSymbolIdField ShowIdFields,
                          PdbSymbolIdField RecurseIdFields) const { … }

std::unique_ptr<IPDBEnumSymbols>
NativeTypeEnum::findChildren(PDB_SymType Type) const { … }

PDB_SymType NativeTypeEnum::getSymTag() const { … }

PDB_BuiltinType NativeTypeEnum::getBuiltinType() const { … }

SymIndexId NativeTypeEnum::getUnmodifiedTypeId() const { … }

bool NativeTypeEnum::hasConstructor() const { … }

bool NativeTypeEnum::hasAssignmentOperator() const { … }

bool NativeTypeEnum::hasNestedTypes() const { … }

bool NativeTypeEnum::isIntrinsic() const { … }

bool NativeTypeEnum::hasCastOperator() const { … }

uint64_t NativeTypeEnum::getLength() const { … }

std::string NativeTypeEnum::getName() const { … }

bool NativeTypeEnum::isNested() const { … }

bool NativeTypeEnum::hasOverloadedOperator() const { … }

bool NativeTypeEnum::isPacked() const { … }

bool NativeTypeEnum::isScoped() const { … }

SymIndexId NativeTypeEnum::getTypeId() const { … }

bool NativeTypeEnum::isRefUdt() const { … }

bool NativeTypeEnum::isValueUdt() const { … }

bool NativeTypeEnum::isInterfaceUdt() const { … }

bool NativeTypeEnum::isConstType() const { … }

bool NativeTypeEnum::isVolatileType() const { … }

bool NativeTypeEnum::isUnalignedType() const { … }

const NativeTypeBuiltin &NativeTypeEnum::getUnderlyingBuiltinType() const { … }