doxygen/DIARawSymbol_8cpp_source.html

//===- DIARawSymbol.cpp - DIA implementation of IPDBRawSymbol ---*- 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/DIA/DIARawSymbol.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/DebugInfo/CodeView/Formatters.h"

#include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h"

#include "llvm/DebugInfo/PDB/DIA/DIAEnumSymbols.h"

#include "llvm/DebugInfo/PDB/DIA/DIALineNumber.h"

#include "llvm/DebugInfo/PDB/DIA/DIASession.h"

#include "llvm/DebugInfo/PDB/DIA/DIAUtils.h"

#include "llvm/DebugInfo/PDB/PDBExtras.h"

#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"

#include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"

#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"

#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h"

#include "llvm/Support/ConvertUTF.h"

#include "llvm/Support/raw_ostream.h"


using namespace llvm;

using namespace llvm::pdb;


namespace {

Variant VariantFromVARIANT(const VARIANT &V) {

  Variant Result;

  switch (V.vt) {

  case VT_I1:

    Result.Value.Int8 = V.cVal;

    Result.Type = PDB_VariantType::Int8;

    break;

  case VT_I2:

    Result.Value.Int16 = V.iVal;

    Result.Type = PDB_VariantType::Int16;

    break;

  case VT_I4:

    Result.Value.Int32 = V.intVal;

    Result.Type = PDB_VariantType::Int32;

    break;

  case VT_I8:

    Result.Value.Int64 = V.llVal;

    Result.Type = PDB_VariantType::Int64;

    break;

  case VT_UI1:

    Result.Value.UInt8 = V.bVal;

    Result.Type = PDB_VariantType::UInt8;

    break;

  case VT_UI2:

    Result.Value.UInt16 = V.uiVal;

    Result.Type = PDB_VariantType::UInt16;

    break;

  case VT_UI4:

    Result.Value.UInt32 = V.uintVal;

    Result.Type = PDB_VariantType::UInt32;

    break;

  case VT_UI8:

    Result.Value.UInt64 = V.ullVal;

    Result.Type = PDB_VariantType::UInt64;

    break;

  case VT_BOOL:

    Result.Value.Bool = (V.boolVal == VARIANT_TRUE) ? true : false;

    Result.Type = PDB_VariantType::Bool;

    break;

  case VT_R4:

    Result.Value.Single = V.fltVal;

    Result.Type = PDB_VariantType::Single;

    break;

  case VT_R8:

    Result.Value.Double = V.dblVal;

    Result.Type = PDB_VariantType::Double;

    break;

  case VT_BSTR: {

    const char *SrcBytes = reinterpret_cast<const char *>(V.bstrVal);

    llvm::ArrayRef<char> SrcByteArray(SrcBytes, SysStringByteLen(V.bstrVal));

    std::string Result8;

    if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8))

      Result.Value.String = nullptr;

    Result.Value.String = new char[Result8.length() + 1];

    ::strcpy(Result.Value.String, Result8.c_str());

    Result.Type = PDB_VariantType::String;

    break;

  }

  default:

    Result.Type = PDB_VariantType::Unknown;

    break;

  }

  return Result;

}


template <typename ArgType>

ArgType PrivateGetDIAValue(IDiaSymbol *Symbol,

                           HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {

  ArgType Value;

  if (S_OK == (Symbol->*Method)(&Value))

    return static_cast<ArgType>(Value);


  return ArgType();

}


template <typename ArgType, typename RetType>

RetType PrivateGetDIAValue(IDiaSymbol *Symbol,

                           HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {

  ArgType Value;

  if (S_OK == (Symbol->*Method)(&Value))

    return static_cast<RetType>(Value);


  return RetType();

}


std::string

PrivateGetDIAValue(IDiaSymbol *Symbol,

                   HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) {

  return invokeBstrMethod(*Symbol, Method);

}


codeview::GUID

PrivateGetDIAValue(IDiaSymbol *Symbol,

                   HRESULT (__stdcall IDiaSymbol::*Method)(GUID *)) {

  GUID Result;

  if (S_OK != (Symbol->*Method)(&Result))

    return codeview::GUID();


  static_assert(sizeof(codeview::GUID) == sizeof(GUID),

                "GUID is the wrong size!");

  codeview::GUID IdResult;

  ::memcpy(&IdResult, &Result, sizeof(GUID));

  return IdResult;

}


template <typename PrintType, typename ArgType>

void DumpDIAValueAs(llvm::raw_ostream &OS, int Indent, StringRef Name,

                    IDiaSymbol *Symbol,

                    HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {

  ArgType Value;

  if (S_OK == (Symbol->*Method)(&Value))

    dumpSymbolField(OS, Name, static_cast<PrintType>(Value), Indent);

}


void DumpDIAIdValue(llvm::raw_ostream &OS, int Indent, StringRef Name,

                    IDiaSymbol *Symbol,

                    HRESULT (__stdcall IDiaSymbol::*Method)(DWORD *),

                    const IPDBSession &Session, PdbSymbolIdField FieldId,

                    PdbSymbolIdField ShowFlags, PdbSymbolIdField RecurseFlags) {

  DWORD Value;

  if (S_OK == (Symbol->*Method)(&Value))

    dumpSymbolIdField(OS, Name, Value, Indent, Session, FieldId, ShowFlags,

                      RecurseFlags);

}


template <typename ArgType>

void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,

                  IDiaSymbol *Symbol,

                  HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {

  ArgType Value;

  if (S_OK == (Symbol->*Method)(&Value))

    dumpSymbolField(OS, Name, Value, Indent);

}


void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,

                  IDiaSymbol *Symbol,

                  HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) {

  BSTR Value = nullptr;

  if (S_OK != (Symbol->*Method)(&Value))

    return;

  const char *Bytes = reinterpret_cast<const char *>(Value);

  ArrayRef<char> ByteArray(Bytes, ::SysStringByteLen(Value));

  std::string Result;

  if (llvm::convertUTF16ToUTF8String(ByteArray, Result))

    dumpSymbolField(OS, Name, Result, Indent);

  ::SysFreeString(Value);

}


void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,

                  IDiaSymbol *Symbol,

                  HRESULT (__stdcall IDiaSymbol::*Method)(VARIANT *)) {

  VARIANT Value;

  Value.vt = VT_EMPTY;

  if (S_OK != (Symbol->*Method)(&Value))

    return;

  Variant V = VariantFromVARIANT(Value);


  dumpSymbolField(OS, Name, V, Indent);

}

} // namespace


namespace llvm {

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const GUID &G) {

  StringRef GuidBytes(reinterpret_cast<const char *>(&G), sizeof(G));

  codeview::detail::GuidAdapter A(GuidBytes);

  A.format(OS, "");

  return OS;

}

} // namespace llvm


DIARawSymbol::DIARawSymbol(const DIASession &PDBSession,

                           CComPtr<IDiaSymbol> DiaSymbol)

    : Session(PDBSession), Symbol(DiaSymbol) {}


#define RAW_ID_METHOD_DUMP(Stream, Method, Session, FieldId, ShowFlags,        \

                           RecurseFlags)                                       \

  DumpDIAIdValue(Stream, Indent, StringRef{#Method}, Symbol,                   \

                 &IDiaSymbol::get_##Method, Session, FieldId, ShowFlags,       \

                 RecurseFlags);


#define RAW_METHOD_DUMP(Stream, Method)                                        \

  DumpDIAValue(Stream, Indent, StringRef{#Method}, Symbol,                     \

               &IDiaSymbol::get_##Method);


#define RAW_METHOD_DUMP_AS(Stream, Method, Type)                               \

  DumpDIAValueAs<Type>(Stream, Indent, StringRef{#Method}, Symbol,             \

                       &IDiaSymbol::get_##Method);


void DIARawSymbol::dump(raw_ostream &OS, int Indent,

                        PdbSymbolIdField ShowIdFields,

                        PdbSymbolIdField RecurseIdFields) const {

  RAW_ID_METHOD_DUMP(OS, symIndexId, Session, PdbSymbolIdField::SymIndexId,

                     ShowIdFields, RecurseIdFields);

  RAW_METHOD_DUMP_AS(OS, symTag, PDB_SymType);


  RAW_METHOD_DUMP(OS, access);

  RAW_METHOD_DUMP(OS, addressOffset);

  RAW_METHOD_DUMP(OS, addressSection);

  RAW_METHOD_DUMP(OS, age);

  RAW_METHOD_DUMP(OS, arrayIndexTypeId);

  RAW_METHOD_DUMP(OS, backEndMajor);

  RAW_METHOD_DUMP(OS, backEndMinor);

  RAW_METHOD_DUMP(OS, backEndBuild);

  RAW_METHOD_DUMP(OS, backEndQFE);

  RAW_METHOD_DUMP(OS, baseDataOffset);

  RAW_METHOD_DUMP(OS, baseDataSlot);

  RAW_METHOD_DUMP(OS, baseSymbolId);

  RAW_METHOD_DUMP_AS(OS, baseType, PDB_BuiltinType);

  RAW_METHOD_DUMP(OS, bitPosition);

  RAW_METHOD_DUMP_AS(OS, callingConvention, PDB_CallingConv);

  RAW_ID_METHOD_DUMP(OS, classParentId, Session, PdbSymbolIdField::ClassParent,

                     ShowIdFields, RecurseIdFields);

  RAW_METHOD_DUMP(OS, compilerName);

  RAW_METHOD_DUMP(OS, count);

  RAW_METHOD_DUMP(OS, countLiveRanges);

  RAW_METHOD_DUMP(OS, frontEndMajor);

  RAW_METHOD_DUMP(OS, frontEndMinor);

  RAW_METHOD_DUMP(OS, frontEndBuild);

  RAW_METHOD_DUMP(OS, frontEndQFE);

  RAW_ID_METHOD_DUMP(OS, lexicalParentId, Session,

                     PdbSymbolIdField::LexicalParent, ShowIdFields,

                     RecurseIdFields);

  RAW_METHOD_DUMP(OS, libraryName);

  RAW_METHOD_DUMP(OS, liveRangeStartAddressOffset);

  RAW_METHOD_DUMP(OS, liveRangeStartAddressSection);

  RAW_METHOD_DUMP(OS, liveRangeStartRelativeVirtualAddress);

  RAW_METHOD_DUMP(OS, localBasePointerRegisterId);

  RAW_METHOD_DUMP(OS, lowerBoundId);

  RAW_METHOD_DUMP(OS, memorySpaceKind);

  RAW_METHOD_DUMP(OS, name);

  RAW_METHOD_DUMP(OS, numberOfAcceleratorPointerTags);

  RAW_METHOD_DUMP(OS, numberOfColumns);

  RAW_METHOD_DUMP(OS, numberOfModifiers);

  RAW_METHOD_DUMP(OS, numberOfRegisterIndices);

  RAW_METHOD_DUMP(OS, numberOfRows);

  RAW_METHOD_DUMP(OS, objectFileName);

  RAW_METHOD_DUMP(OS, oemId);

  RAW_METHOD_DUMP(OS, oemSymbolId);

  RAW_METHOD_DUMP(OS, offsetInUdt);

  RAW_METHOD_DUMP(OS, platform);

  RAW_METHOD_DUMP(OS, rank);

  RAW_METHOD_DUMP(OS, registerId);

  RAW_METHOD_DUMP(OS, registerType);

  RAW_METHOD_DUMP(OS, relativeVirtualAddress);

  RAW_METHOD_DUMP(OS, samplerSlot);

  RAW_METHOD_DUMP(OS, signature);

  RAW_METHOD_DUMP(OS, sizeInUdt);

  RAW_METHOD_DUMP(OS, slot);

  RAW_METHOD_DUMP(OS, sourceFileName);

  RAW_METHOD_DUMP(OS, stride);

  RAW_METHOD_DUMP(OS, subTypeId);

  RAW_METHOD_DUMP(OS, symbolsFileName);

  RAW_METHOD_DUMP(OS, targetOffset);

  RAW_METHOD_DUMP(OS, targetRelativeVirtualAddress);

  RAW_METHOD_DUMP(OS, targetVirtualAddress);

  RAW_METHOD_DUMP(OS, targetSection);

  RAW_METHOD_DUMP(OS, textureSlot);

  RAW_METHOD_DUMP(OS, timeStamp);

  RAW_METHOD_DUMP(OS, token);

  RAW_ID_METHOD_DUMP(OS, typeId, Session, PdbSymbolIdField::Type, ShowIdFields,

                     RecurseIdFields);

  RAW_METHOD_DUMP(OS, uavSlot);

  RAW_METHOD_DUMP(OS, undecoratedName);

  RAW_ID_METHOD_DUMP(OS, unmodifiedTypeId, Session,

                     PdbSymbolIdField::UnmodifiedType, ShowIdFields,

                     RecurseIdFields);

  RAW_METHOD_DUMP(OS, upperBoundId);

  RAW_METHOD_DUMP(OS, virtualBaseDispIndex);

  RAW_METHOD_DUMP(OS, virtualBaseOffset);

  RAW_METHOD_DUMP(OS, virtualTableShapeId);

  RAW_METHOD_DUMP_AS(OS, dataKind, PDB_DataKind);

  RAW_METHOD_DUMP(OS, guid);

  RAW_METHOD_DUMP(OS, offset);

  RAW_METHOD_DUMP(OS, thisAdjust);

  RAW_METHOD_DUMP(OS, virtualBasePointerOffset);

  RAW_METHOD_DUMP_AS(OS, locationType, PDB_LocType);

  RAW_METHOD_DUMP(OS, machineType);

  RAW_METHOD_DUMP(OS, thunkOrdinal);

  RAW_METHOD_DUMP(OS, length);

  RAW_METHOD_DUMP(OS, liveRangeLength);

  RAW_METHOD_DUMP(OS, virtualAddress);

  RAW_METHOD_DUMP_AS(OS, udtKind, PDB_UdtType);

  RAW_METHOD_DUMP(OS, constructor);

  RAW_METHOD_DUMP(OS, customCallingConvention);

  RAW_METHOD_DUMP(OS, farReturn);

  RAW_METHOD_DUMP(OS, code);

  RAW_METHOD_DUMP(OS, compilerGenerated);

  RAW_METHOD_DUMP(OS, constType);

  RAW_METHOD_DUMP(OS, editAndContinueEnabled);

  RAW_METHOD_DUMP(OS, function);

  RAW_METHOD_DUMP(OS, stride);

  RAW_METHOD_DUMP(OS, noStackOrdering);

  RAW_METHOD_DUMP(OS, hasAlloca);

  RAW_METHOD_DUMP(OS, hasAssignmentOperator);

  RAW_METHOD_DUMP(OS, isCTypes);

  RAW_METHOD_DUMP(OS, hasCastOperator);

  RAW_METHOD_DUMP(OS, hasDebugInfo);

  RAW_METHOD_DUMP(OS, hasEH);

  RAW_METHOD_DUMP(OS, hasEHa);

  RAW_METHOD_DUMP(OS, hasInlAsm);

  RAW_METHOD_DUMP(OS, framePointerPresent);

  RAW_METHOD_DUMP(OS, inlSpec);

  RAW_METHOD_DUMP(OS, interruptReturn);

  RAW_METHOD_DUMP(OS, hasLongJump);

  RAW_METHOD_DUMP(OS, hasManagedCode);

  RAW_METHOD_DUMP(OS, hasNestedTypes);

  RAW_METHOD_DUMP(OS, noInline);

  RAW_METHOD_DUMP(OS, noReturn);

  RAW_METHOD_DUMP(OS, optimizedCodeDebugInfo);

  RAW_METHOD_DUMP(OS, overloadedOperator);

  RAW_METHOD_DUMP(OS, hasSEH);

  RAW_METHOD_DUMP(OS, hasSecurityChecks);

  RAW_METHOD_DUMP(OS, hasSetJump);

  RAW_METHOD_DUMP(OS, strictGSCheck);

  RAW_METHOD_DUMP(OS, isAcceleratorGroupSharedLocal);

  RAW_METHOD_DUMP(OS, isAcceleratorPointerTagLiveRange);

  RAW_METHOD_DUMP(OS, isAcceleratorStubFunction);

  RAW_METHOD_DUMP(OS, isAggregated);

  RAW_METHOD_DUMP(OS, intro);

  RAW_METHOD_DUMP(OS, isCVTCIL);

  RAW_METHOD_DUMP(OS, isConstructorVirtualBase);

  RAW_METHOD_DUMP(OS, isCxxReturnUdt);

  RAW_METHOD_DUMP(OS, isDataAligned);

  RAW_METHOD_DUMP(OS, isHLSLData);

  RAW_METHOD_DUMP(OS, isHotpatchable);

  RAW_METHOD_DUMP(OS, indirectVirtualBaseClass);

  RAW_METHOD_DUMP(OS, isInterfaceUdt);

  RAW_METHOD_DUMP(OS, intrinsic);

  RAW_METHOD_DUMP(OS, isLTCG);

  RAW_METHOD_DUMP(OS, isLocationControlFlowDependent);

  RAW_METHOD_DUMP(OS, isMSILNetmodule);

  RAW_METHOD_DUMP(OS, isMatrixRowMajor);

  RAW_METHOD_DUMP(OS, managed);

  RAW_METHOD_DUMP(OS, msil);

  RAW_METHOD_DUMP(OS, isMultipleInheritance);

  RAW_METHOD_DUMP(OS, isNaked);

  RAW_METHOD_DUMP(OS, nested);

  RAW_METHOD_DUMP(OS, isOptimizedAway);

  RAW_METHOD_DUMP(OS, packed);

  RAW_METHOD_DUMP(OS, isPointerBasedOnSymbolValue);

  RAW_METHOD_DUMP(OS, isPointerToDataMember);

  RAW_METHOD_DUMP(OS, isPointerToMemberFunction);

  RAW_METHOD_DUMP(OS, pure);

  RAW_METHOD_DUMP(OS, RValueReference);

  RAW_METHOD_DUMP(OS, isRefUdt);

  RAW_METHOD_DUMP(OS, reference);

  RAW_METHOD_DUMP(OS, restrictedType);

  RAW_METHOD_DUMP(OS, isReturnValue);

  RAW_METHOD_DUMP(OS, isSafeBuffers);

  RAW_METHOD_DUMP(OS, scoped);

  RAW_METHOD_DUMP(OS, isSdl);

  RAW_METHOD_DUMP(OS, isSingleInheritance);

  RAW_METHOD_DUMP(OS, isSplitted);

  RAW_METHOD_DUMP(OS, isStatic);

  RAW_METHOD_DUMP(OS, isStripped);

  RAW_METHOD_DUMP(OS, unalignedType);

  RAW_METHOD_DUMP(OS, notReached);

  RAW_METHOD_DUMP(OS, isValueUdt);

  RAW_METHOD_DUMP(OS, virtual);

  RAW_METHOD_DUMP(OS, virtualBaseClass);

  RAW_METHOD_DUMP(OS, isVirtualInheritance);

  RAW_METHOD_DUMP(OS, volatileType);

  RAW_METHOD_DUMP(OS, wasInlined);

  RAW_METHOD_DUMP(OS, unused);

  RAW_METHOD_DUMP(OS, value);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findChildren(PDB_SymType Type) const {

  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);


  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK !=

      Symbol->findChildrenEx(EnumVal, nullptr, nsNone, &DiaEnumerator)) {

    if (S_OK != Symbol->findChildren(EnumVal, nullptr, nsNone, &DiaEnumerator))

      return nullptr;

  }


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findChildren(PDB_SymType Type, StringRef Name,

                           PDB_NameSearchFlags Flags) const {

  llvm::SmallVector<UTF16, 32> Name16;

  llvm::convertUTF8ToUTF16String(Name, Name16);


  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);

  DWORD CompareFlags = static_cast<DWORD>(Flags);

  wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data());


  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK !=

      Symbol->findChildrenEx(EnumVal, Name16Str, CompareFlags, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findChildrenByAddr(PDB_SymType Type, StringRef Name,

                                 PDB_NameSearchFlags Flags, uint32_t Section,

                                 uint32_t Offset) const {

  llvm::SmallVector<UTF16, 32> Name16;

  llvm::convertUTF8ToUTF16String(Name, Name16);


  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);


  DWORD CompareFlags = static_cast<DWORD>(Flags);

  wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data());


  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK != Symbol->findChildrenExByAddr(EnumVal, Name16Str, CompareFlags,

                                           Section, Offset, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findChildrenByVA(PDB_SymType Type, StringRef Name,

                               PDB_NameSearchFlags Flags, uint64_t VA) const {

  llvm::SmallVector<UTF16, 32> Name16;

  llvm::convertUTF8ToUTF16String(Name, Name16);


  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);


  DWORD CompareFlags = static_cast<DWORD>(Flags);

  wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data());


  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK != Symbol->findChildrenExByVA(EnumVal, Name16Str, CompareFlags, VA,

                                         &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findChildrenByRVA(PDB_SymType Type, StringRef Name,

                                PDB_NameSearchFlags Flags, uint32_t RVA) const {

  llvm::SmallVector<UTF16, 32> Name16;

  llvm::convertUTF8ToUTF16String(Name, Name16);


  enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);

  DWORD CompareFlags = static_cast<DWORD>(Flags);

  wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data());


  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK != Symbol->findChildrenExByRVA(EnumVal, Name16Str, CompareFlags, RVA,

                                          &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findInlineFramesByAddr(uint32_t Section, uint32_t Offset) const {

  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK != Symbol->findInlineFramesByAddr(Section, Offset, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findInlineFramesByRVA(uint32_t RVA) const {

  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK != Symbol->findInlineFramesByRVA(RVA, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumSymbols>

DIARawSymbol::findInlineFramesByVA(uint64_t VA) const {

  CComPtr<IDiaEnumSymbols> DiaEnumerator;

  if (S_OK != Symbol->findInlineFramesByVA(VA, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);

}


std::unique_ptr<IPDBEnumLineNumbers> DIARawSymbol::findInlineeLines() const {

  CComPtr<IDiaEnumLineNumbers> DiaEnumerator;

  if (S_OK != Symbol->findInlineeLines(&DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator);

}


std::unique_ptr<IPDBEnumLineNumbers>

DIARawSymbol::findInlineeLinesByAddr(uint32_t Section, uint32_t Offset,

                                     uint32_t Length) const {

  CComPtr<IDiaEnumLineNumbers> DiaEnumerator;

  if (S_OK !=

      Symbol->findInlineeLinesByAddr(Section, Offset, Length, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator);

}


std::unique_ptr<IPDBEnumLineNumbers>

DIARawSymbol::findInlineeLinesByRVA(uint32_t RVA, uint32_t Length) const {

  CComPtr<IDiaEnumLineNumbers> DiaEnumerator;

  if (S_OK != Symbol->findInlineeLinesByRVA(RVA, Length, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator);

}


std::unique_ptr<IPDBEnumLineNumbers>

DIARawSymbol::findInlineeLinesByVA(uint64_t VA, uint32_t Length) const {

  CComPtr<IDiaEnumLineNumbers> DiaEnumerator;

  if (S_OK != Symbol->findInlineeLinesByVA(VA, Length, &DiaEnumerator))

    return nullptr;


  return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator);

}


void DIARawSymbol::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const {

  bytes.clear();


  DWORD DataSize = 0;

  Symbol->get_dataBytes(0, &DataSize, nullptr);

  if (DataSize == 0)

    return;


  bytes.resize(DataSize);

  Symbol->get_dataBytes(DataSize, &DataSize, bytes.data());

}


std::string DIARawSymbol::getUndecoratedNameEx(PDB_UndnameFlags Flags) const {

  CComBSTR Result16;

  if (S_OK != Symbol->get_undecoratedNameEx((DWORD)Flags, &Result16))

    return std::string();


  const char *SrcBytes = reinterpret_cast<const char *>(Result16.m_str);

  llvm::ArrayRef<char> SrcByteArray(SrcBytes, Result16.ByteLength());

  std::string Result8;

  if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8))

    return std::string();

  return Result8;

}


PDB_MemberAccess DIARawSymbol::getAccess() const {

  return PrivateGetDIAValue<DWORD, PDB_MemberAccess>(Symbol,

                                                     &IDiaSymbol::get_access);

}


uint32_t DIARawSymbol::getAddressOffset() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressOffset);

}


uint32_t DIARawSymbol::getAddressSection() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressSection);

}


uint32_t DIARawSymbol::getAge() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_age);

}


SymIndexId DIARawSymbol::getArrayIndexTypeId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_arrayIndexTypeId);

}


void DIARawSymbol::getBackEndVersion(VersionInfo &Version) const {

  Version.Major = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndMajor);

  Version.Minor = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndMinor);

  Version.Build = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndBuild);

  Version.QFE = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndQFE);

}


uint32_t DIARawSymbol::getBaseDataOffset() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataOffset);

}


uint32_t DIARawSymbol::getBaseDataSlot() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataSlot);

}


SymIndexId DIARawSymbol::getBaseSymbolId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseSymbolId);

}


PDB_BuiltinType DIARawSymbol::getBuiltinType() const {

  return PrivateGetDIAValue<DWORD, PDB_BuiltinType>(Symbol,

                                                    &IDiaSymbol::get_baseType);

}


uint32_t DIARawSymbol::getBitPosition() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_bitPosition);

}


PDB_CallingConv DIARawSymbol::getCallingConvention() const {

  return PrivateGetDIAValue<DWORD, PDB_CallingConv>(

      Symbol, &IDiaSymbol::get_callingConvention);

}


SymIndexId DIARawSymbol::getClassParentId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_classParentId);

}


std::string DIARawSymbol::getCompilerName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerName);

}


uint32_t DIARawSymbol::getCount() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_count);

}


uint32_t DIARawSymbol::getCountLiveRanges() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_countLiveRanges);

}


void DIARawSymbol::getFrontEndVersion(VersionInfo &Version) const {

  Version.Major = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndMajor);

  Version.Minor = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndMinor);

  Version.Build = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndBuild);

  Version.QFE = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndQFE);

}


PDB_Lang DIARawSymbol::getLanguage() const {

  return PrivateGetDIAValue<DWORD, PDB_Lang>(Symbol, &IDiaSymbol::get_language);

}


SymIndexId DIARawSymbol::getLexicalParentId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lexicalParentId);

}


std::string DIARawSymbol::getLibraryName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_libraryName);

}


uint32_t DIARawSymbol::getLiveRangeStartAddressOffset() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_liveRangeStartAddressOffset);

}


uint32_t DIARawSymbol::getLiveRangeStartAddressSection() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_liveRangeStartAddressSection);

}


uint32_t DIARawSymbol::getLiveRangeStartRelativeVirtualAddress() const {

  return PrivateGetDIAValue(

      Symbol, &IDiaSymbol::get_liveRangeStartRelativeVirtualAddress);

}


codeview::RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const {

  return PrivateGetDIAValue<DWORD, codeview::RegisterId>(

      Symbol, &IDiaSymbol::get_localBasePointerRegisterId);

}


SymIndexId DIARawSymbol::getLowerBoundId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lowerBoundId);

}


uint32_t DIARawSymbol::getMemorySpaceKind() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_memorySpaceKind);

}


std::string DIARawSymbol::getName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_name);

}


uint32_t DIARawSymbol::getNumberOfAcceleratorPointerTags() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_numberOfAcceleratorPointerTags);

}


uint32_t DIARawSymbol::getNumberOfColumns() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfColumns);

}


uint32_t DIARawSymbol::getNumberOfModifiers() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfModifiers);

}


uint32_t DIARawSymbol::getNumberOfRegisterIndices() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRegisterIndices);

}


uint32_t DIARawSymbol::getNumberOfRows() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRows);

}


std::string DIARawSymbol::getObjectFileName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_objectFileName);

}


uint32_t DIARawSymbol::getOemId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemId);

}


SymIndexId DIARawSymbol::getOemSymbolId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemSymbolId);

}


uint32_t DIARawSymbol::getOffsetInUdt() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offsetInUdt);

}


PDB_Cpu DIARawSymbol::getPlatform() const {

  return PrivateGetDIAValue<DWORD, PDB_Cpu>(Symbol, &IDiaSymbol::get_platform);

}


uint32_t DIARawSymbol::getRank() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_rank);

}


codeview::RegisterId DIARawSymbol::getRegisterId() const {

  return PrivateGetDIAValue<DWORD, codeview::RegisterId>(

      Symbol, &IDiaSymbol::get_registerId);

}


uint32_t DIARawSymbol::getRegisterType() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_registerType);

}


uint32_t DIARawSymbol::getRelativeVirtualAddress() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_relativeVirtualAddress);

}


uint32_t DIARawSymbol::getSamplerSlot() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_samplerSlot);

}


uint32_t DIARawSymbol::getSignature() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_signature);

}


uint32_t DIARawSymbol::getSizeInUdt() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sizeInUdt);

}


uint32_t DIARawSymbol::getSlot() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_slot);

}


std::string DIARawSymbol::getSourceFileName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sourceFileName);

}


std::unique_ptr<IPDBLineNumber> DIARawSymbol::getSrcLineOnTypeDefn() const {

  CComPtr<IDiaLineNumber> LineNumber;

  if (FAILED(Symbol->getSrcLineOnTypeDefn(&LineNumber)) || !LineNumber)

    return nullptr;


  return std::make_unique<DIALineNumber>(LineNumber);

}


uint32_t DIARawSymbol::getStride() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_stride);

}


SymIndexId DIARawSymbol::getSubTypeId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_subTypeId);

}


std::string DIARawSymbol::getSymbolsFileName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symbolsFileName);

}


SymIndexId DIARawSymbol::getSymIndexId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symIndexId);

}


uint32_t DIARawSymbol::getTargetOffset() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetOffset);

}


uint32_t DIARawSymbol::getTargetRelativeVirtualAddress() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_targetRelativeVirtualAddress);

}


uint64_t DIARawSymbol::getTargetVirtualAddress() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetVirtualAddress);

}


uint32_t DIARawSymbol::getTargetSection() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetSection);

}


uint32_t DIARawSymbol::getTextureSlot() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_textureSlot);

}


uint32_t DIARawSymbol::getTimeStamp() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_timeStamp);

}


uint32_t DIARawSymbol::getToken() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_token);

}


SymIndexId DIARawSymbol::getTypeId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_typeId);

}


uint32_t DIARawSymbol::getUavSlot() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_uavSlot);

}


std::string DIARawSymbol::getUndecoratedName() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_undecoratedName);

}


SymIndexId DIARawSymbol::getUnmodifiedTypeId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unmodifiedTypeId);

}


SymIndexId DIARawSymbol::getUpperBoundId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_upperBoundId);

}


Variant DIARawSymbol::getValue() const {

  VARIANT Value;

  Value.vt = VT_EMPTY;

  if (S_OK != Symbol->get_value(&Value))

    return Variant();


  return VariantFromVARIANT(Value);

}


uint32_t DIARawSymbol::getVirtualBaseDispIndex() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseDispIndex);

}


uint32_t DIARawSymbol::getVirtualBaseOffset() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseOffset);

}


SymIndexId DIARawSymbol::getVirtualTableShapeId() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualTableShapeId);

}


std::unique_ptr<PDBSymbolTypeBuiltin>

DIARawSymbol::getVirtualBaseTableType() const {

  CComPtr<IDiaSymbol> TableType;

  if (FAILED(Symbol->get_virtualBaseTableType(&TableType)) || !TableType)

    return nullptr;


  auto RawVT = std::make_unique<DIARawSymbol>(Session, TableType);

  auto Pointer =

      PDBSymbol::createAs<PDBSymbolTypePointer>(Session, std::move(RawVT));

  return unique_dyn_cast<PDBSymbolTypeBuiltin>(Pointer->getPointeeType());

}


PDB_DataKind DIARawSymbol::getDataKind() const {

  return PrivateGetDIAValue<DWORD, PDB_DataKind>(Symbol,

                                                 &IDiaSymbol::get_dataKind);

}


PDB_SymType DIARawSymbol::getSymTag() const {

  return PrivateGetDIAValue<DWORD, PDB_SymType>(Symbol,

                                                &IDiaSymbol::get_symTag);

}


codeview::GUID DIARawSymbol::getGuid() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_guid);

}


int32_t DIARawSymbol::getOffset() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offset);

}


int32_t DIARawSymbol::getThisAdjust() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_thisAdjust);

}


int32_t DIARawSymbol::getVirtualBasePointerOffset() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBasePointerOffset);

}


PDB_LocType DIARawSymbol::getLocationType() const {

  return PrivateGetDIAValue<DWORD, PDB_LocType>(Symbol,

                                                &IDiaSymbol::get_locationType);

}


PDB_Machine DIARawSymbol::getMachineType() const {

  return PrivateGetDIAValue<DWORD, PDB_Machine>(Symbol,

                                                &IDiaSymbol::get_machineType);

}


codeview::ThunkOrdinal DIARawSymbol::getThunkOrdinal() const {

  return PrivateGetDIAValue<DWORD, codeview::ThunkOrdinal>(

      Symbol, &IDiaSymbol::get_thunkOrdinal);

}


uint64_t DIARawSymbol::getLength() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_length);

}


uint64_t DIARawSymbol::getLiveRangeLength() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_liveRangeLength);

}


uint64_t DIARawSymbol::getVirtualAddress() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualAddress);

}


PDB_UdtType DIARawSymbol::getUdtKind() const {

  return PrivateGetDIAValue<DWORD, PDB_UdtType>(Symbol,

                                                &IDiaSymbol::get_udtKind);

}


bool DIARawSymbol::hasConstructor() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constructor);

}


bool DIARawSymbol::hasCustomCallingConvention() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_customCallingConvention);

}


bool DIARawSymbol::hasFarReturn() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_farReturn);

}


bool DIARawSymbol::isCode() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_code);

}


bool DIARawSymbol::isCompilerGenerated() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerGenerated);

}


bool DIARawSymbol::isConstType() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constType);

}


bool DIARawSymbol::isEditAndContinueEnabled() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_editAndContinueEnabled);

}


bool DIARawSymbol::isFunction() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_function);

}


bool DIARawSymbol::getAddressTaken() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressTaken);

}


bool DIARawSymbol::getNoStackOrdering() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noStackOrdering);

}


bool DIARawSymbol::hasAlloca() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAlloca);

}


bool DIARawSymbol::hasAssignmentOperator() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAssignmentOperator);

}


bool DIARawSymbol::hasCTypes() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCTypes);

}


bool DIARawSymbol::hasCastOperator() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasCastOperator);

}


bool DIARawSymbol::hasDebugInfo() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasDebugInfo);

}


bool DIARawSymbol::hasEH() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEH);

}


bool DIARawSymbol::hasEHa() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEHa);

}


bool DIARawSymbol::hasInlAsm() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasInlAsm);

}


bool DIARawSymbol::hasInlineAttribute() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_inlSpec);

}


bool DIARawSymbol::hasInterruptReturn() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_interruptReturn);

}


bool DIARawSymbol::hasFramePointer() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_framePointerPresent);

}


bool DIARawSymbol::hasLongJump() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasLongJump);

}


bool DIARawSymbol::hasManagedCode() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasManagedCode);

}


bool DIARawSymbol::hasNestedTypes() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasNestedTypes);

}


bool DIARawSymbol::hasNoInlineAttribute() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noInline);

}


bool DIARawSymbol::hasNoReturnAttribute() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noReturn);

}


bool DIARawSymbol::hasOptimizedCodeDebugInfo() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_optimizedCodeDebugInfo);

}


bool DIARawSymbol::hasOverloadedOperator() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_overloadedOperator);

}


bool DIARawSymbol::hasSEH() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSEH);

}


bool DIARawSymbol::hasSecurityChecks() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSecurityChecks);

}


bool DIARawSymbol::hasSetJump() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSetJump);

}


bool DIARawSymbol::hasStrictGSCheck() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_strictGSCheck);

}


bool DIARawSymbol::isAcceleratorGroupSharedLocal() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_isAcceleratorGroupSharedLocal);

}


bool DIARawSymbol::isAcceleratorPointerTagLiveRange() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_isAcceleratorPointerTagLiveRange);

}


bool DIARawSymbol::isAcceleratorStubFunction() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAcceleratorStubFunction);

}


bool DIARawSymbol::isAggregated() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAggregated);

}


bool DIARawSymbol::isIntroVirtualFunction() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intro);

}


bool DIARawSymbol::isCVTCIL() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCVTCIL);

}


bool DIARawSymbol::isConstructorVirtualBase() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isConstructorVirtualBase);

}


bool DIARawSymbol::isCxxReturnUdt() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCxxReturnUdt);

}


bool DIARawSymbol::isDataAligned() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isDataAligned);

}


bool DIARawSymbol::isHLSLData() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHLSLData);

}


bool DIARawSymbol::isHotpatchable() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHotpatchable);

}


bool DIARawSymbol::isIndirectVirtualBaseClass() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_indirectVirtualBaseClass);

}


bool DIARawSymbol::isInterfaceUdt() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isInterfaceUdt);

}


bool DIARawSymbol::isIntrinsic() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intrinsic);

}


bool DIARawSymbol::isLTCG() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isLTCG);

}


bool DIARawSymbol::isLocationControlFlowDependent() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_isLocationControlFlowDependent);

}


bool DIARawSymbol::isMSILNetmodule() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMSILNetmodule);

}


bool DIARawSymbol::isMatrixRowMajor() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMatrixRowMajor);

}


bool DIARawSymbol::isManagedCode() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_managed);

}


bool DIARawSymbol::isMSILCode() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_msil);

}


bool DIARawSymbol::isMultipleInheritance() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMultipleInheritance);

}


bool DIARawSymbol::isNaked() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isNaked);

}


bool DIARawSymbol::isNested() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_nested);

}


bool DIARawSymbol::isOptimizedAway() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isOptimizedAway);

}


bool DIARawSymbol::isPacked() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_packed);

}


bool DIARawSymbol::isPointerBasedOnSymbolValue() const {

  return PrivateGetDIAValue(Symbol,

                            &IDiaSymbol::get_isPointerBasedOnSymbolValue);

}


bool DIARawSymbol::isPointerToDataMember() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToDataMember);

}


bool DIARawSymbol::isPointerToMemberFunction() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToMemberFunction);

}


bool DIARawSymbol::isPureVirtual() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_pure);

}


bool DIARawSymbol::isRValueReference() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_RValueReference);

}


bool DIARawSymbol::isRefUdt() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isRefUdt);

}


bool DIARawSymbol::isReference() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_reference);

}


bool DIARawSymbol::isRestrictedType() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_restrictedType);

}


bool DIARawSymbol::isReturnValue() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isReturnValue);

}


bool DIARawSymbol::isSafeBuffers() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSafeBuffers);

}


bool DIARawSymbol::isScoped() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_scoped);

}


bool DIARawSymbol::isSdl() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSdl);

}


bool DIARawSymbol::isSingleInheritance() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSingleInheritance);

}


bool DIARawSymbol::isSplitted() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSplitted);

}


bool DIARawSymbol::isStatic() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStatic);

}


bool DIARawSymbol::hasPrivateSymbols() const {

  // hasPrivateSymbols is the opposite of isStripped, but we expose

  // hasPrivateSymbols as a more intuitive interface.

  return !PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStripped);

}


bool DIARawSymbol::isUnalignedType() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unalignedType);

}


bool DIARawSymbol::isUnreached() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_notReached);

}


bool DIARawSymbol::isValueUdt() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isValueUdt);

}


bool DIARawSymbol::isVirtual() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtual);

}


bool DIARawSymbol::isVirtualBaseClass() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseClass);

}


bool DIARawSymbol::isVirtualInheritance() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isVirtualInheritance);

}


bool DIARawSymbol::isVolatileType() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_volatileType);

}


bool DIARawSymbol::wasInlined() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_wasInlined);

}


std::string DIARawSymbol::getUnused() const {

  return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unused);

}

ArrayRef.h

A
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

ConvertUTF.h

DIAEnumLineNumbers.h

DIAEnumSymbols.h

PrivateGetDIAValue
ArgType PrivateGetDIAValue(IDiaFrameData *FrameData, HRESULT(__stdcall IDiaFrameData::*Method)(ArgType *))
Definition: DIAFrameData.cpp:20

DIALineNumber.h

RAW_METHOD_DUMP_AS
#define RAW_METHOD_DUMP_AS(Stream, Method, Type)
Definition: DIARawSymbol.cpp:214

RAW_METHOD_DUMP
#define RAW_METHOD_DUMP(Stream, Method)
Definition: DIARawSymbol.cpp:210

RAW_ID_METHOD_DUMP
#define RAW_ID_METHOD_DUMP(Stream, Method, Session, FieldId, ShowFlags, RecurseFlags)
Definition: DIARawSymbol.cpp:204

DIARawSymbol.h

DIASession.h

DIAUtils.h

invokeBstrMethod
std::string invokeBstrMethod(Obj &Object, HRESULT(__stdcall Obj::*Func)(BSTR *))
Definition: DIAUtils.h:16

function
Performs the initial survey of the specified function
Definition: DeadArgumentElimination.cpp:487

value
Given that RA is a live value
Definition: DeadArgumentElimination.cpp:715

Name
std::string Name
Definition: ELFObjHandler.cpp:77

Formatters.h

G
#define G(x, y, z)
Definition: MD5.cpp:56

PDBExtras.h

PDBSymbolTypeBuiltin.h

PDBSymbolTypePointer.h

PDBSymbolTypeVTableShape.h

PDBSymbolTypeVTable.h

name
static const char * name
Definition: SMEABIPass.cpp:50

STLExtras.h
This file contains some templates that are useful if you are working with the STL at all.

OS
raw_pwrite_stream & OS
Definition: SampleProfWriter.cpp:53

llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41

llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:623

llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:651

llvm::SmallVectorTemplateCommon::data
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:299

llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209

llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50

llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45

llvm::Value
LLVM Value Representation.
Definition: Value.h:74

llvm::codeview::detail::GuidAdapter
Definition: Formatters.h:29

llvm::pdb::DIARawSymbol::getNumberOfModifiers
uint32_t getNumberOfModifiers() const override
Definition: DIARawSymbol.cpp:705

llvm::pdb::DIARawSymbol::isDataAligned
bool isDataAligned() const override
Definition: DIARawSymbol.cpp:1100

llvm::pdb::DIARawSymbol::isCxxReturnUdt
bool isCxxReturnUdt() const override
Definition: DIARawSymbol.cpp:1096

llvm::pdb::DIARawSymbol::hasOptimizedCodeDebugInfo
bool hasOptimizedCodeDebugInfo() const override
Definition: DIARawSymbol.cpp:1042

llvm::pdb::DIARawSymbol::isScoped
bool isScoped() const override
Definition: DIARawSymbol.cpp:1210

llvm::pdb::DIARawSymbol::findChildrenByVA
std::unique_ptr< IPDBEnumSymbols > findChildrenByVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags, uint64_t VA) const override
Definition: DIARawSymbol.cpp:450

llvm::pdb::DIARawSymbol::getUpperBoundId
SymIndexId getUpperBoundId() const override
Definition: DIARawSymbol.cpp:843

llvm::pdb::DIARawSymbol::hasInterruptReturn
bool hasInterruptReturn() const override
Definition: DIARawSymbol.cpp:1014

llvm::pdb::DIARawSymbol::isStatic
bool isStatic() const override
Definition: DIARawSymbol.cpp:1226

llvm::pdb::DIARawSymbol::getTextureSlot
uint32_t getTextureSlot() const override
Definition: DIARawSymbol.cpp:815

llvm::pdb::DIARawSymbol::getVirtualBaseDispIndex
uint32_t getVirtualBaseDispIndex() const override
Definition: DIARawSymbol.cpp:856

llvm::pdb::DIARawSymbol::getAddressOffset
uint32_t getAddressOffset() const override
Definition: DIARawSymbol.cpp:580

llvm::pdb::DIARawSymbol::findInlineeLines
std::unique_ptr< IPDBEnumLineNumbers > findInlineeLines() const override
Definition: DIARawSymbol.cpp:513

llvm::pdb::DIARawSymbol::getFrontEndVersion
void getFrontEndVersion(VersionInfo &Version) const override
Definition: DIARawSymbol.cpp:645

llvm::pdb::DIARawSymbol::getTypeId
SymIndexId getTypeId() const override
Definition: DIARawSymbol.cpp:827

llvm::pdb::DIARawSymbol::hasEHa
bool hasEHa() const override
Definition: DIARawSymbol.cpp:1002

llvm::pdb::DIARawSymbol::getUndecoratedNameEx
std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override
Definition: DIARawSymbol.cpp:562

llvm::pdb::DIARawSymbol::isCVTCIL
bool isCVTCIL() const override
Definition: DIARawSymbol.cpp:1088

llvm::pdb::DIARawSymbol::findInlineeLinesByRVA
std::unique_ptr< IPDBEnumLineNumbers > findInlineeLinesByRVA(uint32_t RVA, uint32_t Length) const override
Definition: DIARawSymbol.cpp:533

llvm::pdb::DIARawSymbol::isOptimizedAway
bool isOptimizedAway() const override
Definition: DIARawSymbol.cpp:1161

llvm::pdb::DIARawSymbol::isVolatileType
bool isVolatileType() const override
Definition: DIARawSymbol.cpp:1260

llvm::pdb::DIARawSymbol::isInterfaceUdt
bool isInterfaceUdt() const override
Definition: DIARawSymbol.cpp:1116

llvm::pdb::DIARawSymbol::isEditAndContinueEnabled
bool isEditAndContinueEnabled() const override
Definition: DIARawSymbol.cpp:962

llvm::pdb::DIARawSymbol::getValue
Variant getValue() const override
Definition: DIARawSymbol.cpp:847

llvm::pdb::DIARawSymbol::getSignature
uint32_t getSignature() const override
Definition: DIARawSymbol.cpp:758

llvm::pdb::DIARawSymbol::isUnalignedType
bool isUnalignedType() const override
Definition: DIARawSymbol.cpp:1236

llvm::pdb::DIARawSymbol::getName
std::string getName() const override
Definition: DIARawSymbol.cpp:692

llvm::pdb::DIARawSymbol::hasLongJump
bool hasLongJump() const override
Definition: DIARawSymbol.cpp:1022

llvm::pdb::DIARawSymbol::hasCustomCallingConvention
bool hasCustomCallingConvention() const override
Definition: DIARawSymbol.cpp:942

llvm::pdb::DIARawSymbol::getDataKind
PDB_DataKind getDataKind() const override
Definition: DIARawSymbol.cpp:880

llvm::pdb::DIARawSymbol::getPlatform
PDB_Cpu getPlatform() const override
Definition: DIARawSymbol.cpp:733

llvm::pdb::DIARawSymbol::getCountLiveRanges
uint32_t getCountLiveRanges() const override
Definition: DIARawSymbol.cpp:641

llvm::pdb::DIARawSymbol::isHotpatchable
bool isHotpatchable() const override
Definition: DIARawSymbol.cpp:1108

llvm::pdb::DIARawSymbol::isReturnValue
bool isReturnValue() const override
Definition: DIARawSymbol.cpp:1202

llvm::pdb::DIARawSymbol::getBaseDataOffset
uint32_t getBaseDataOffset() const override
Definition: DIARawSymbol.cpp:603

llvm::pdb::DIARawSymbol::getAccess
PDB_MemberAccess getAccess() const override
Definition: DIARawSymbol.cpp:575

llvm::pdb::DIARawSymbol::findChildrenByAddr
std::unique_ptr< IPDBEnumSymbols > findChildrenByAddr(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags, uint32_t Section, uint32_t Offset) const override
Definition: DIARawSymbol.cpp:430

llvm::pdb::DIARawSymbol::getThisAdjust
int32_t getThisAdjust() const override
Definition: DIARawSymbol.cpp:898

llvm::pdb::DIARawSymbol::isIntroVirtualFunction
bool isIntroVirtualFunction() const override
Definition: DIARawSymbol.cpp:1084

llvm::pdb::DIARawSymbol::isAcceleratorGroupSharedLocal
bool isAcceleratorGroupSharedLocal() const override
Definition: DIARawSymbol.cpp:1066

llvm::pdb::DIARawSymbol::hasNoReturnAttribute
bool hasNoReturnAttribute() const override
Definition: DIARawSymbol.cpp:1038

llvm::pdb::DIARawSymbol::getLowerBoundId
SymIndexId getLowerBoundId() const override
Definition: DIARawSymbol.cpp:684

llvm::pdb::DIARawSymbol::hasNestedTypes
bool hasNestedTypes() const override
Definition: DIARawSymbol.cpp:1030

llvm::pdb::DIARawSymbol::hasCTypes
bool hasCTypes() const override
Definition: DIARawSymbol.cpp:986

llvm::pdb::DIARawSymbol::getSymbolsFileName
std::string getSymbolsFileName() const override
Definition: DIARawSymbol.cpp:790

llvm::pdb::DIARawSymbol::getNumberOfRows
uint32_t getNumberOfRows() const override
Definition: DIARawSymbol.cpp:713

llvm::pdb::DIARawSymbol::findInlineFramesByAddr
std::unique_ptr< IPDBEnumSymbols > findInlineFramesByAddr(uint32_t Section, uint32_t Offset) const override
Definition: DIARawSymbol.cpp:487

llvm::pdb::DIARawSymbol::getLanguage
PDB_Lang getLanguage() const override
Definition: DIARawSymbol.cpp:652

llvm::pdb::DIARawSymbol::wasInlined
bool wasInlined() const override
Definition: DIARawSymbol.cpp:1264

llvm::pdb::DIARawSymbol::getLiveRangeStartAddressSection
uint32_t getLiveRangeStartAddressSection() const override
Definition: DIARawSymbol.cpp:669

llvm::pdb::DIARawSymbol::isPacked
bool isPacked() const override
Definition: DIARawSymbol.cpp:1165

llvm::pdb::DIARawSymbol::getNoStackOrdering
bool getNoStackOrdering() const override
Definition: DIARawSymbol.cpp:974

llvm::pdb::DIARawSymbol::getAge
uint32_t getAge() const override
Definition: DIARawSymbol.cpp:588

llvm::pdb::DIARawSymbol::getBackEndVersion
void getBackEndVersion(VersionInfo &Version) const override
Definition: DIARawSymbol.cpp:596

llvm::pdb::DIARawSymbol::getSizeInUdt
uint32_t getSizeInUdt() const override
Definition: DIARawSymbol.cpp:762

llvm::pdb::DIARawSymbol::isLocationControlFlowDependent
bool isLocationControlFlowDependent() const override
Definition: DIARawSymbol.cpp:1128

llvm::pdb::DIARawSymbol::getCallingConvention
PDB_CallingConv getCallingConvention() const override
Definition: DIARawSymbol.cpp:624

llvm::pdb::DIARawSymbol::getUndecoratedName
std::string getUndecoratedName() const override
Definition: DIARawSymbol.cpp:835

llvm::pdb::DIARawSymbol::getTargetRelativeVirtualAddress
uint32_t getTargetRelativeVirtualAddress() const override
Definition: DIARawSymbol.cpp:802

llvm::pdb::DIARawSymbol::getArrayIndexTypeId
SymIndexId getArrayIndexTypeId() const override
Definition: DIARawSymbol.cpp:592

llvm::pdb::DIARawSymbol::DIARawSymbol
DIARawSymbol(const DIASession &PDBSession, CComPtr< IDiaSymbol > DiaSymbol)
Definition: DIARawSymbol.cpp:200

llvm::pdb::DIARawSymbol::isReference
bool isReference() const override
Definition: DIARawSymbol.cpp:1194

llvm::pdb::DIARawSymbol::isMultipleInheritance
bool isMultipleInheritance() const override
Definition: DIARawSymbol.cpp:1149

llvm::pdb::DIARawSymbol::isAggregated
bool isAggregated() const override
Definition: DIARawSymbol.cpp:1080

llvm::pdb::DIARawSymbol::isConstructorVirtualBase
bool isConstructorVirtualBase() const override
Definition: DIARawSymbol.cpp:1092

llvm::pdb::DIARawSymbol::isSplitted
bool isSplitted() const override
Definition: DIARawSymbol.cpp:1222

llvm::pdb::DIARawSymbol::getRegisterType
uint32_t getRegisterType() const override
Definition: DIARawSymbol.cpp:746

llvm::pdb::DIARawSymbol::getOffsetInUdt
uint32_t getOffsetInUdt() const override
Definition: DIARawSymbol.cpp:729

llvm::pdb::DIARawSymbol::getRelativeVirtualAddress
uint32_t getRelativeVirtualAddress() const override
Definition: DIARawSymbol.cpp:750

llvm::pdb::DIARawSymbol::findInlineeLinesByAddr
std::unique_ptr< IPDBEnumLineNumbers > findInlineeLinesByAddr(uint32_t Section, uint32_t Offset, uint32_t Length) const override
Definition: DIARawSymbol.cpp:522

llvm::pdb::DIARawSymbol::getUdtKind
PDB_UdtType getUdtKind() const override
Definition: DIARawSymbol.cpp:933

llvm::pdb::DIARawSymbol::isCompilerGenerated
bool isCompilerGenerated() const override
Definition: DIARawSymbol.cpp:954

llvm::pdb::DIARawSymbol::isIntrinsic
bool isIntrinsic() const override
Definition: DIARawSymbol.cpp:1120

llvm::pdb::DIARawSymbol::isManagedCode
bool isManagedCode() const override
Definition: DIARawSymbol.cpp:1141

llvm::pdb::DIARawSymbol::isMSILNetmodule
bool isMSILNetmodule() const override
Definition: DIARawSymbol.cpp:1133

llvm::pdb::DIARawSymbol::hasEH
bool hasEH() const override
Definition: DIARawSymbol.cpp:998

llvm::pdb::DIARawSymbol::hasConstructor
bool hasConstructor() const override
Definition: DIARawSymbol.cpp:938

llvm::pdb::DIARawSymbol::isVirtualInheritance
bool isVirtualInheritance() const override
Definition: DIARawSymbol.cpp:1256

llvm::pdb::DIARawSymbol::getNumberOfColumns
uint32_t getNumberOfColumns() const override
Definition: DIARawSymbol.cpp:701

llvm::pdb::DIARawSymbol::getTargetVirtualAddress
uint64_t getTargetVirtualAddress() const override
Definition: DIARawSymbol.cpp:807

llvm::pdb::DIARawSymbol::getSymTag
PDB_SymType getSymTag() const override
Definition: DIARawSymbol.cpp:885

llvm::pdb::DIARawSymbol::findInlineFramesByVA
std::unique_ptr< IPDBEnumSymbols > findInlineFramesByVA(uint64_t VA) const override
Definition: DIARawSymbol.cpp:505

llvm::pdb::DIARawSymbol::isNested
bool isNested() const override
Definition: DIARawSymbol.cpp:1157

llvm::pdb::DIARawSymbol::isVirtual
bool isVirtual() const override
Definition: DIARawSymbol.cpp:1248

llvm::pdb::DIARawSymbol::getVirtualTableShapeId
SymIndexId getVirtualTableShapeId() const override
Definition: DIARawSymbol.cpp:864

llvm::pdb::DIARawSymbol::isCode
bool isCode() const override
Definition: DIARawSymbol.cpp:950

llvm::pdb::DIARawSymbol::getUnused
std::string getUnused() const override
Definition: DIARawSymbol.cpp:1268

llvm::pdb::DIARawSymbol::isFunction
bool isFunction() const override
Definition: DIARawSymbol.cpp:966

llvm::pdb::DIARawSymbol::getOffset
int32_t getOffset() const override
Definition: DIARawSymbol.cpp:894

llvm::pdb::DIARawSymbol::hasAlloca
bool hasAlloca() const override
Definition: DIARawSymbol.cpp:978

llvm::pdb::DIARawSymbol::getCompilerName
std::string getCompilerName() const override
Definition: DIARawSymbol.cpp:633

llvm::pdb::DIARawSymbol::isAcceleratorStubFunction
bool isAcceleratorStubFunction() const override
Definition: DIARawSymbol.cpp:1076

llvm::pdb::DIARawSymbol::getBaseSymbolId
SymIndexId getBaseSymbolId() const override
Definition: DIARawSymbol.cpp:611

llvm::pdb::DIARawSymbol::hasNoInlineAttribute
bool hasNoInlineAttribute() const override
Definition: DIARawSymbol.cpp:1034

llvm::pdb::DIARawSymbol::isSdl
bool isSdl() const override
Definition: DIARawSymbol.cpp:1214

llvm::pdb::DIARawSymbol::getUnmodifiedTypeId
SymIndexId getUnmodifiedTypeId() const override
Definition: DIARawSymbol.cpp:839

llvm::pdb::DIARawSymbol::hasStrictGSCheck
bool hasStrictGSCheck() const override
Definition: DIARawSymbol.cpp:1062

llvm::pdb::DIARawSymbol::getGuid
codeview::GUID getGuid() const override
Definition: DIARawSymbol.cpp:890

llvm::pdb::DIARawSymbol::getNumberOfRegisterIndices
uint32_t getNumberOfRegisterIndices() const override
Definition: DIARawSymbol.cpp:709

llvm::pdb::DIARawSymbol::hasSEH
bool hasSEH() const override
Definition: DIARawSymbol.cpp:1050

llvm::pdb::DIARawSymbol::getVirtualBaseOffset
uint32_t getVirtualBaseOffset() const override
Definition: DIARawSymbol.cpp:860

llvm::pdb::DIARawSymbol::getSourceFileName
std::string getSourceFileName() const override
Definition: DIARawSymbol.cpp:770

llvm::pdb::DIARawSymbol::isUnreached
bool isUnreached() const override
Definition: DIARawSymbol.cpp:1240

llvm::pdb::DIARawSymbol::getSubTypeId
SymIndexId getSubTypeId() const override
Definition: DIARawSymbol.cpp:786

llvm::pdb::DIARawSymbol::hasOverloadedOperator
bool hasOverloadedOperator() const override
Definition: DIARawSymbol.cpp:1046

llvm::pdb::DIARawSymbol::getSrcLineOnTypeDefn
std::unique_ptr< IPDBLineNumber > getSrcLineOnTypeDefn() const override
Definition: DIARawSymbol.cpp:774

llvm::pdb::DIARawSymbol::getBitPosition
uint32_t getBitPosition() const override
Definition: DIARawSymbol.cpp:620

llvm::pdb::DIARawSymbol::isPointerBasedOnSymbolValue
bool isPointerBasedOnSymbolValue() const override
Definition: DIARawSymbol.cpp:1169

llvm::pdb::DIARawSymbol::getSlot
uint32_t getSlot() const override
Definition: DIARawSymbol.cpp:766

llvm::pdb::DIARawSymbol::getMemorySpaceKind
uint32_t getMemorySpaceKind() const override
Definition: DIARawSymbol.cpp:688

llvm::pdb::DIARawSymbol::getUavSlot
uint32_t getUavSlot() const override
Definition: DIARawSymbol.cpp:831

llvm::pdb::DIARawSymbol::findInlineFramesByRVA
std::unique_ptr< IPDBEnumSymbols > findInlineFramesByRVA(uint32_t RVA) const override
Definition: DIARawSymbol.cpp:496

llvm::pdb::DIARawSymbol::hasInlAsm
bool hasInlAsm() const override
Definition: DIARawSymbol.cpp:1006

llvm::pdb::DIARawSymbol::getOemId
uint32_t getOemId() const override
Definition: DIARawSymbol.cpp:721

llvm::pdb::DIARawSymbol::isRefUdt
bool isRefUdt() const override
Definition: DIARawSymbol.cpp:1190

llvm::pdb::DIARawSymbol::getTimeStamp
uint32_t getTimeStamp() const override
Definition: DIARawSymbol.cpp:819

llvm::pdb::DIARawSymbol::isSafeBuffers
bool isSafeBuffers() const override
Definition: DIARawSymbol.cpp:1206

llvm::pdb::DIARawSymbol::isPointerToDataMember
bool isPointerToDataMember() const override
Definition: DIARawSymbol.cpp:1174

llvm::pdb::DIARawSymbol::getOemSymbolId
SymIndexId getOemSymbolId() const override
Definition: DIARawSymbol.cpp:725

llvm::pdb::DIARawSymbol::isPureVirtual
bool isPureVirtual() const override
Definition: DIARawSymbol.cpp:1182

llvm::pdb::DIARawSymbol::isValueUdt
bool isValueUdt() const override
Definition: DIARawSymbol.cpp:1244

llvm::pdb::DIARawSymbol::getSamplerSlot
uint32_t getSamplerSlot() const override
Definition: DIARawSymbol.cpp:754

llvm::pdb::DIARawSymbol::isLTCG
bool isLTCG() const override
Definition: DIARawSymbol.cpp:1124

llvm::pdb::DIARawSymbol::isNaked
bool isNaked() const override
Definition: DIARawSymbol.cpp:1153

llvm::pdb::DIARawSymbol::getRegisterId
codeview::RegisterId getRegisterId() const override
Definition: DIARawSymbol.cpp:741

llvm::pdb::DIARawSymbol::isSingleInheritance
bool isSingleInheritance() const override
Definition: DIARawSymbol.cpp:1218

llvm::pdb::DIARawSymbol::isHLSLData
bool isHLSLData() const override
Definition: DIARawSymbol.cpp:1104

llvm::pdb::DIARawSymbol::hasSetJump
bool hasSetJump() const override
Definition: DIARawSymbol.cpp:1058

llvm::pdb::DIARawSymbol::getLiveRangeStartAddressOffset
uint32_t getLiveRangeStartAddressOffset() const override
Definition: DIARawSymbol.cpp:664

llvm::pdb::DIARawSymbol::getStride
uint32_t getStride() const override
Definition: DIARawSymbol.cpp:782

llvm::pdb::DIARawSymbol::getRank
uint32_t getRank() const override
Definition: DIARawSymbol.cpp:737

llvm::pdb::DIARawSymbol::isIndirectVirtualBaseClass
bool isIndirectVirtualBaseClass() const override
Definition: DIARawSymbol.cpp:1112

llvm::pdb::DIARawSymbol::hasFarReturn
bool hasFarReturn() const override
Definition: DIARawSymbol.cpp:946

llvm::pdb::DIARawSymbol::getNumberOfAcceleratorPointerTags
uint32_t getNumberOfAcceleratorPointerTags() const override
Definition: DIARawSymbol.cpp:696

llvm::pdb::DIARawSymbol::getAddressSection
uint32_t getAddressSection() const override
Definition: DIARawSymbol.cpp:584

llvm::pdb::DIARawSymbol::isConstType
bool isConstType() const override
Definition: DIARawSymbol.cpp:958

llvm::pdb::DIARawSymbol::getLength
uint64_t getLength() const override
Definition: DIARawSymbol.cpp:921

llvm::pdb::DIARawSymbol::findChildrenByRVA
std::unique_ptr< IPDBEnumSymbols > findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags, uint32_t RVA) const override
Definition: DIARawSymbol.cpp:469

llvm::pdb::DIARawSymbol::isPointerToMemberFunction
bool isPointerToMemberFunction() const override
Definition: DIARawSymbol.cpp:1178

llvm::pdb::DIARawSymbol::getBuiltinType
PDB_BuiltinType getBuiltinType() const override
Definition: DIARawSymbol.cpp:615

llvm::pdb::DIARawSymbol::findChildren
std::unique_ptr< IPDBEnumSymbols > findChildren(PDB_SymType Type) const override
Definition: DIARawSymbol.cpp:398

llvm::pdb::DIARawSymbol::getClassParentId
SymIndexId getClassParentId() const override
Definition: DIARawSymbol.cpp:629

llvm::pdb::DIARawSymbol::isAcceleratorPointerTagLiveRange
bool isAcceleratorPointerTagLiveRange() const override
Definition: DIARawSymbol.cpp:1071

llvm::pdb::DIARawSymbol::isVirtualBaseClass
bool isVirtualBaseClass() const override
Definition: DIARawSymbol.cpp:1252

llvm::pdb::DIARawSymbol::isRestrictedType
bool isRestrictedType() const override
Definition: DIARawSymbol.cpp:1198

llvm::pdb::DIARawSymbol::hasDebugInfo
bool hasDebugInfo() const override
Definition: DIARawSymbol.cpp:994

llvm::pdb::DIARawSymbol::getLocalBasePointerRegisterId
codeview::RegisterId getLocalBasePointerRegisterId() const override
Definition: DIARawSymbol.cpp:679

llvm::pdb::DIARawSymbol::getSymIndexId
SymIndexId getSymIndexId() const override
Definition: DIARawSymbol.cpp:794

llvm::pdb::DIARawSymbol::getObjectFileName
std::string getObjectFileName() const override
Definition: DIARawSymbol.cpp:717

llvm::pdb::DIARawSymbol::getLiveRangeLength
uint64_t getLiveRangeLength() const override
Definition: DIARawSymbol.cpp:925

llvm::pdb::DIARawSymbol::hasFramePointer
bool hasFramePointer() const override
Definition: DIARawSymbol.cpp:1018

llvm::pdb::DIARawSymbol::hasManagedCode
bool hasManagedCode() const override
Definition: DIARawSymbol.cpp:1026

llvm::pdb::DIARawSymbol::getLocationType
PDB_LocType getLocationType() const override
Definition: DIARawSymbol.cpp:906

llvm::pdb::DIARawSymbol::hasCastOperator
bool hasCastOperator() const override
Definition: DIARawSymbol.cpp:990

llvm::pdb::DIARawSymbol::isMatrixRowMajor
bool isMatrixRowMajor() const override
Definition: DIARawSymbol.cpp:1137

llvm::pdb::DIARawSymbol::getToken
uint32_t getToken() const override
Definition: DIARawSymbol.cpp:823

llvm::pdb::DIARawSymbol::hasPrivateSymbols
bool hasPrivateSymbols() const override
Definition: DIARawSymbol.cpp:1230

llvm::pdb::DIARawSymbol::getBaseDataSlot
uint32_t getBaseDataSlot() const override
Definition: DIARawSymbol.cpp:607

llvm::pdb::DIARawSymbol::getLexicalParentId
SymIndexId getLexicalParentId() const override
Definition: DIARawSymbol.cpp:656

llvm::pdb::DIARawSymbol::getVirtualBasePointerOffset
int32_t getVirtualBasePointerOffset() const override
Definition: DIARawSymbol.cpp:902

llvm::pdb::DIARawSymbol::getAddressTaken
bool getAddressTaken() const override
Definition: DIARawSymbol.cpp:970

llvm::pdb::DIARawSymbol::getLiveRangeStartRelativeVirtualAddress
uint32_t getLiveRangeStartRelativeVirtualAddress() const override
Definition: DIARawSymbol.cpp:674

llvm::pdb::DIARawSymbol::getDataBytes
void getDataBytes(llvm::SmallVector< uint8_t, 32 > &bytes) const override
Definition: DIARawSymbol.cpp:550

llvm::pdb::DIARawSymbol::isMSILCode
bool isMSILCode() const override
Definition: DIARawSymbol.cpp:1145

llvm::pdb::DIARawSymbol::getLibraryName
std::string getLibraryName() const override
Definition: DIARawSymbol.cpp:660

llvm::pdb::DIARawSymbol::hasInlineAttribute
bool hasInlineAttribute() const override
Definition: DIARawSymbol.cpp:1010

llvm::pdb::DIARawSymbol::hasAssignmentOperator
bool hasAssignmentOperator() const override
Definition: DIARawSymbol.cpp:982

llvm::pdb::DIARawSymbol::getVirtualAddress
uint64_t getVirtualAddress() const override
Definition: DIARawSymbol.cpp:929

llvm::pdb::DIARawSymbol::getCount
uint32_t getCount() const override
Definition: DIARawSymbol.cpp:637

llvm::pdb::DIARawSymbol::getThunkOrdinal
codeview::ThunkOrdinal getThunkOrdinal() const override
Definition: DIARawSymbol.cpp:916

llvm::pdb::DIARawSymbol::getTargetSection
uint32_t getTargetSection() const override
Definition: DIARawSymbol.cpp:811

llvm::pdb::DIARawSymbol::getMachineType
PDB_Machine getMachineType() const override
Definition: DIARawSymbol.cpp:911

llvm::pdb::DIARawSymbol::getVirtualBaseTableType
std::unique_ptr< PDBSymbolTypeBuiltin > getVirtualBaseTableType() const override
Definition: DIARawSymbol.cpp:869

llvm::pdb::DIARawSymbol::hasSecurityChecks
bool hasSecurityChecks() const override
Definition: DIARawSymbol.cpp:1054

llvm::pdb::DIARawSymbol::getTargetOffset
uint32_t getTargetOffset() const override
Definition: DIARawSymbol.cpp:798

llvm::pdb::DIARawSymbol::isRValueReference
bool isRValueReference() const override
Definition: DIARawSymbol.cpp:1186

llvm::pdb::DIARawSymbol::dump
void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields, PdbSymbolIdField RecurseIdFields) const override
Definition: DIARawSymbol.cpp:218

llvm::pdb::DIARawSymbol::findInlineeLinesByVA
std::unique_ptr< IPDBEnumLineNumbers > findInlineeLinesByVA(uint64_t VA, uint32_t Length) const override
Definition: DIARawSymbol.cpp:542

llvm::pdb::DIASession
Definition: DIASession.h:22

llvm::pdb::IPDBSession
IPDBSession defines an interface used to provide a context for querying debug information from a debu...
Definition: IPDBSession.h:25

llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52

uint32_t

uint64_t

llvm::AMDGPU::SDWA::DWORD
@ DWORD
Definition: SIDefines.h:886

llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83

llvm::M68k::MemAddrModeKind::V
@ V

llvm::codeview::RegisterId
RegisterId
Definition: CodeView.h:529

llvm::codeview::CPUType
CPUType
These values correspond to the CV_CPU_TYPE_e enumeration, and are documented here: https://msdn....
Definition: CodeView.h:76

llvm::codeview::CallingConvention
CallingConvention
These values correspond to the CV_call_e enumeration, and are documented at the following locations: ...
Definition: CodeView.h:184

llvm::codeview::ThunkOrdinal
ThunkOrdinal
These values correspond to the THUNK_ORDINAL enumeration.
Definition: CodeView.h:563

llvm::codeview::SourceLanguage
SourceLanguage
These values correspond to the CV_CFL_LANG enumeration in the Microsoft Debug Interface Access SDK,...
Definition: CodeView.h:146

llvm::ctx_profile::GUID
uint64_t GUID
Definition: CtxInstrContextNode.h:66

llvm::ms_demangle::QualifierMangleMode::Result
@ Result

llvm::pdb
Definition: LVCodeViewReader.h:44

llvm::pdb::PDB_Machine
PDB_Machine
Definition: PDBTypes.h:125

llvm::pdb::PDB_NameSearchFlags
PDB_NameSearchFlags
Defines flags used for enumerating child symbols.
Definition: PDBTypes.h:102

llvm::pdb::dumpSymbolField
void dumpSymbolField(raw_ostream &OS, StringRef Name, T Value, int Indent)
Definition: PDBExtras.h:47

llvm::pdb::PDB_BuiltinType
PDB_BuiltinType
These values correspond to the Basictype enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:335

llvm::pdb::PDB_BuiltinType::BSTR
@ BSTR

llvm::pdb::PDB_MemberAccess
PDB_MemberAccess
Definition: PDBTypes.h:385

llvm::pdb::PDB_UdtType
PDB_UdtType
These values correspond to the UdtKind enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:310

llvm::pdb::PDB_SymType
PDB_SymType
These values correspond to the SymTagEnum enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:243

llvm::pdb::PDB_LocType
PDB_LocType
These values correspond to the LocationType enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:292

llvm::pdb::PDB_DataKind
PDB_DataKind
These values correspond to the DataKind enumeration, and are documented here: https://msdn....
Definition: PDBTypes.h:228

llvm::pdb::PdbSymbolIdField
PdbSymbolIdField
Definition: IPDBRawSymbol.h:24

llvm::pdb::PdbSymbolIdField::LexicalParent
@ LexicalParent

llvm::pdb::PdbSymbolIdField::SymIndexId
@ SymIndexId

llvm::pdb::PdbSymbolIdField::UnmodifiedType
@ UnmodifiedType

llvm::pdb::PdbSymbolIdField::ClassParent
@ ClassParent

llvm::pdb::PdbSymbolIdField::Type
@ Type

llvm::pdb::PDB_UndnameFlags
PDB_UndnameFlags
These values correspond to the flags that can be combined to control the return of an undecorated nam...
Definition: PDBTypes.h:362

llvm::pdb::PDB_ColorItem::Offset
@ Offset

llvm::pdb::dumpSymbolIdField
void dumpSymbolIdField(raw_ostream &OS, StringRef Name, SymIndexId Value, int Indent, const IPDBSession &Session, PdbSymbolIdField FieldId, PdbSymbolIdField ShowFlags, PdbSymbolIdField RecurseFlags)
Definition: PDBSymbol.cpp:202

llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18

llvm::Length
@ Length
Definition: DWP.cpp:480

llvm::convertUTF16ToUTF8String
bool convertUTF16ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)
Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
Definition: ConvertUTFWrapper.cpp:84

llvm::count
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1921

llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292

llvm::convertUTF8ToUTF16String
bool convertUTF8ToUTF16String(StringRef SrcUTF8, SmallVectorImpl< UTF16 > &DstUTF16)
Converts a UTF-8 string into a UTF-16 string with native endianness.
Definition: ConvertUTFWrapper.cpp:200

llvm::Version
@ Version
Definition: PGOCtxProfWriter.h:22

raw_ostream.h

llvm::codeview::GUID
This represents the 'GUID' type from windows.h.
Definition: GUID.h:21

llvm::pdb::Variant
Definition: PDBTypes.h:411

llvm::pdb::VersionInfo
Definition: PDBTypes.h:387

llvm::rank
Utility type to build an inheritance chain that makes it easy to rank overload candidates.
Definition: STLExtras.h:1479