6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-08 18:30:04 +00:00
Code Issues Projects Releases Wiki Activity

Add support for dumping debug tables to llvm-pdbdump.

Browse Source 
PDB stores some of its data in streams and some in tables.
This patch teaches llvm-pdbdump to dump basic summary data
for the debug tables.

In support of this, this patch also adds some DIA helper
classes, such as a wrapper around an IDiaSymbol interface,
as well as helpers for outputting various enumerations to
a raw_ostream.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@227257 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Zachary Turner 2015-01-27 22:40:14 +00:00
parent c232e7f8fb
commit 0f9950ed0c
8 changed files with 1678 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tools/llvm-pdbdump/CMakeLists.txt
View File

@ -21,6 +21,8 @@ if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
add_llvm_tool(llvm-pdbdump
llvm-pdbdump.cpp
DIAExtras.cpp
DIASymbol.cpp
)
target_link_libraries(llvm-pdbdump diaguids)
endif()

9
tools/llvm-pdbdump/COMExtras.h
View File

@ -12,6 +12,7 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/ConvertUTF.h"
#include <tuple>
@ -279,6 +280,14 @@ make_com_data_record_enumerator(CComPtr<EnumeratorType> Enumerator) {
return com_data_record_enumerator<EnumeratorType>(Enumerator);
}
inline bool BSTRToUTF8(BSTR String16, std::string &String8) {
UINT ByteLength = ::SysStringByteLen(String16);
char *Bytes = reinterpret_cast<char *>(String16);
String8.clear();
return llvm::convertUTF16ToUTF8String(ArrayRef<char>(Bytes, ByteLength),
String8);
}
} // namespace windows
} // namespace sys
} // namespace llvm

176
tools/llvm-pdbdump/DIAExtras.cpp Normal file
View File

@ -0,0 +1,176 @@
//===- DIAExtras.cpp - Helper classes and functions for DIA C++ ---------*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm-pdbdump.h"
#include "DIAExtras.h"
using namespace llvm;
using namespace llvm::sys::windows;
#define PRINT_ENUM_VALUE_CASE(Value) \
case Value: \
outs() << #Value; \
break;
raw_ostream &llvm::operator<<(raw_ostream &Stream, DiaSymTagEnum SymTag) {
switch (SymTag) {
PRINT_ENUM_VALUE_CASE(SymTagNull)
PRINT_ENUM_VALUE_CASE(SymTagExe)
PRINT_ENUM_VALUE_CASE(SymTagCompiland)
PRINT_ENUM_VALUE_CASE(SymTagCompilandDetails)
PRINT_ENUM_VALUE_CASE(SymTagCompilandEnv)
PRINT_ENUM_VALUE_CASE(SymTagFunction)
PRINT_ENUM_VALUE_CASE(SymTagBlock)
PRINT_ENUM_VALUE_CASE(SymTagData)
PRINT_ENUM_VALUE_CASE(SymTagAnnotation)
PRINT_ENUM_VALUE_CASE(SymTagLabel)
PRINT_ENUM_VALUE_CASE(SymTagPublicSymbol)
PRINT_ENUM_VALUE_CASE(SymTagUDT)
PRINT_ENUM_VALUE_CASE(SymTagEnum)
PRINT_ENUM_VALUE_CASE(SymTagFunctionType)
PRINT_ENUM_VALUE_CASE(SymTagPointerType)
PRINT_ENUM_VALUE_CASE(SymTagArrayType)
PRINT_ENUM_VALUE_CASE(SymTagBaseType)
PRINT_ENUM_VALUE_CASE(SymTagTypedef)
PRINT_ENUM_VALUE_CASE(SymTagBaseClass)
PRINT_ENUM_VALUE_CASE(SymTagFriend)
PRINT_ENUM_VALUE_CASE(SymTagFunctionArgType)
PRINT_ENUM_VALUE_CASE(SymTagFuncDebugStart)
PRINT_ENUM_VALUE_CASE(SymTagFuncDebugEnd)
PRINT_ENUM_VALUE_CASE(SymTagUsingNamespace)
PRINT_ENUM_VALUE_CASE(SymTagVTableShape)
PRINT_ENUM_VALUE_CASE(SymTagVTable)
PRINT_ENUM_VALUE_CASE(SymTagCustom)
PRINT_ENUM_VALUE_CASE(SymTagThunk)
PRINT_ENUM_VALUE_CASE(SymTagCustomType)
PRINT_ENUM_VALUE_CASE(SymTagManagedType)
PRINT_ENUM_VALUE_CASE(SymTagDimension)
PRINT_ENUM_VALUE_CASE(SymTagCallSite)
PRINT_ENUM_VALUE_CASE(SymTagInlineSite)
PRINT_ENUM_VALUE_CASE(SymTagBaseInterface)
PRINT_ENUM_VALUE_CASE(SymTagVectorType)
PRINT_ENUM_VALUE_CASE(SymTagMatrixType)
PRINT_ENUM_VALUE_CASE(SymTagHLSLType)
#if (_MSC_FULL_VER >= 180031101)
PRINT_ENUM_VALUE_CASE(SymTagCaller)
PRINT_ENUM_VALUE_CASE(SymTagCallee)
#endif
PRINT_ENUM_VALUE_CASE(SymTagMax)
}
outs() << " {" << (DWORD)SymTag << "}";
return Stream;
}
raw_ostream &llvm::operator<<(raw_ostream &Stream, CV_CPU_TYPE_e CpuType) {
switch (CpuType) {
PRINT_ENUM_VALUE_CASE(CV_CFL_8080)
PRINT_ENUM_VALUE_CASE(CV_CFL_8086)
PRINT_ENUM_VALUE_CASE(CV_CFL_80286)
PRINT_ENUM_VALUE_CASE(CV_CFL_80386)
PRINT_ENUM_VALUE_CASE(CV_CFL_80486)
PRINT_ENUM_VALUE_CASE(CV_CFL_PENTIUM)
PRINT_ENUM_VALUE_CASE(CV_CFL_PENTIUMPRO)
PRINT_ENUM_VALUE_CASE(CV_CFL_PENTIUMIII)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPS)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPS16)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPS32)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPS64)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPSI)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPSII)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPSIII)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPSIV)
PRINT_ENUM_VALUE_CASE(CV_CFL_MIPSV)
PRINT_ENUM_VALUE_CASE(CV_CFL_M68000)
PRINT_ENUM_VALUE_CASE(CV_CFL_M68010)
PRINT_ENUM_VALUE_CASE(CV_CFL_M68020)
PRINT_ENUM_VALUE_CASE(CV_CFL_M68030)
PRINT_ENUM_VALUE_CASE(CV_CFL_M68040)
PRINT_ENUM_VALUE_CASE(CV_CFL_ALPHA)
PRINT_ENUM_VALUE_CASE(CV_CFL_ALPHA_21164)
PRINT_ENUM_VALUE_CASE(CV_CFL_ALPHA_21164A)
PRINT_ENUM_VALUE_CASE(CV_CFL_ALPHA_21264)
PRINT_ENUM_VALUE_CASE(CV_CFL_ALPHA_21364)
PRINT_ENUM_VALUE_CASE(CV_CFL_PPC601)
PRINT_ENUM_VALUE_CASE(CV_CFL_PPC603)
PRINT_ENUM_VALUE_CASE(CV_CFL_PPC604)
PRINT_ENUM_VALUE_CASE(CV_CFL_PPC620)
PRINT_ENUM_VALUE_CASE(CV_CFL_PPCFP)
PRINT_ENUM_VALUE_CASE(CV_CFL_PPCBE)
PRINT_ENUM_VALUE_CASE(CV_CFL_SH3)
PRINT_ENUM_VALUE_CASE(CV_CFL_SH3E)
PRINT_ENUM_VALUE_CASE(CV_CFL_SH3DSP)
PRINT_ENUM_VALUE_CASE(CV_CFL_SH4)
PRINT_ENUM_VALUE_CASE(CV_CFL_SHMEDIA)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM3)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM4)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM4T)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM5)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM5T)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM6)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM_XMAC)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM_WMMX)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM7)
PRINT_ENUM_VALUE_CASE(CV_CFL_OMNI)
PRINT_ENUM_VALUE_CASE(CV_CFL_IA64)
PRINT_ENUM_VALUE_CASE(CV_CFL_IA64_2)
PRINT_ENUM_VALUE_CASE(CV_CFL_CEE)
PRINT_ENUM_VALUE_CASE(CV_CFL_AM33)
PRINT_ENUM_VALUE_CASE(CV_CFL_M32R)
PRINT_ENUM_VALUE_CASE(CV_CFL_TRICORE)
PRINT_ENUM_VALUE_CASE(CV_CFL_X64)
PRINT_ENUM_VALUE_CASE(CV_CFL_EBC)
PRINT_ENUM_VALUE_CASE(CV_CFL_THUMB)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARMNT)
#if (_MSC_FULL_VER >= 180031101)
PRINT_ENUM_VALUE_CASE(CV_CFL_ARM64)
#endif
PRINT_ENUM_VALUE_CASE(CV_CFL_D3D11_SHADER)
}
outs() << " {" << llvm::format_hex((DWORD)CpuType, 2, true) << "}";
return Stream;
}
raw_ostream &llvm::operator<<(raw_ostream &Stream,
MachineTypeEnum MachineType) {
switch (MachineType) {
PRINT_ENUM_VALUE_CASE(MachineTypeUnknown)
PRINT_ENUM_VALUE_CASE(MachineTypeX86)
PRINT_ENUM_VALUE_CASE(MachineTypeR3000)
PRINT_ENUM_VALUE_CASE(MachineTypeR4000)
PRINT_ENUM_VALUE_CASE(MachineTypeR10000)
PRINT_ENUM_VALUE_CASE(MachineTypeWCEMIPSv2)
PRINT_ENUM_VALUE_CASE(MachineTypeAlpha)
PRINT_ENUM_VALUE_CASE(MachineTypeSH3)
PRINT_ENUM_VALUE_CASE(MachineTypeSH3DSP)
PRINT_ENUM_VALUE_CASE(MachineTypeSH3E)
PRINT_ENUM_VALUE_CASE(MachineTypeSH4)
PRINT_ENUM_VALUE_CASE(MachineTypeSH5)
PRINT_ENUM_VALUE_CASE(MachineTypeArm)
PRINT_ENUM_VALUE_CASE(MachineTypeThumb)
PRINT_ENUM_VALUE_CASE(MachineTypeArmNT)
PRINT_ENUM_VALUE_CASE(MachineTypeAM33)
PRINT_ENUM_VALUE_CASE(MachineTypePowerPC)
PRINT_ENUM_VALUE_CASE(MachineTypePowerPCFP)
PRINT_ENUM_VALUE_CASE(MachineTypeIa64)
PRINT_ENUM_VALUE_CASE(MachineTypeMips16)
PRINT_ENUM_VALUE_CASE(MachineTypeAlpha64)
PRINT_ENUM_VALUE_CASE(MachineTypeMipsFpu)
PRINT_ENUM_VALUE_CASE(MachineTypeMipsFpu16)
PRINT_ENUM_VALUE_CASE(MachineTypeTriCore)
PRINT_ENUM_VALUE_CASE(MachineTypeCEF)
PRINT_ENUM_VALUE_CASE(MachineTypeEBC)
PRINT_ENUM_VALUE_CASE(MachineTypeAmd64)
PRINT_ENUM_VALUE_CASE(MachineTypeM32R)
PRINT_ENUM_VALUE_CASE(MachineTypeCEE)
}
outs() << " {" << llvm::format_hex((DWORD)MachineType, 2, true) << "}";
return Stream;
}

127
tools/llvm-pdbdump/DIAExtras.h Normal file
View File

@ -0,0 +1,127 @@
//===- DIAExtras.h - Helper classes and functions for accessing DIA C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Defines helper types, classes, and functions for working with DIA.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVMPDBDUMP_DIAEXTRAS_H
#define LLVM_TOOLS_LLVMPDBDUMP_DIAEXTRAS_H
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/raw_ostream.h"
#include "COMExtras.h"
namespace llvm {
namespace sys {
namespace windows {
typedef llvm::SmallString<16> DIAString;
template <class T> class DIAResult {
public:
DIAResult() : IsValid(false) {}
DIAResult(const T &ResultValue) : Result(ResultValue), IsValid(true) {}
bool hasValue() const { return IsValid; }
T value() const { return Result; }
void dump(StringRef Name, unsigned IndentLevel) const {
if (!hasValue())
return;
outs().indent(IndentLevel);
outs() << Name << ": " << value() << "\n";
}
private:
T Result;
bool IsValid;
};
template <>
void DIAResult<BOOL>::dump(StringRef Name, unsigned IndentLevel) const {
if (!hasValue())
return;
outs().indent(IndentLevel);
outs() << Name << ": " << (value() ? "true" : "false") << "\n";
}
template <>
void DIAResult<GUID>::dump(StringRef Name, unsigned IndentLevel) const {
if (!hasValue())
return;
std::string Guid8;
CComBSTR GuidBSTR(value());
BSTRToUTF8(GuidBSTR.m_str, Guid8);
outs().indent(IndentLevel);
outs() << Name << ": " << Guid8 << "\n";
}
// MSDN documents the IDiaSymbol::get_machineType method as returning a value
// from the CV_CPU_TYPE_e enumeration. This documentation is wrong, however,
// and this method actually returns a value from the IMAGE_FILE_xxx set of
// defines from winnt.h. These correspond to the platform magic number in
// the COFF file. This enumeration is built from the set of values in winnt.h
enum MachineTypeEnum {
MachineTypeUnknown = IMAGE_FILE_MACHINE_UNKNOWN,
MachineTypeX86 = IMAGE_FILE_MACHINE_I386,
MachineTypeR3000 = IMAGE_FILE_MACHINE_R3000,
MachineTypeR4000 = IMAGE_FILE_MACHINE_R4000,
MachineTypeR10000 = IMAGE_FILE_MACHINE_R10000,
MachineTypeWCEMIPSv2 = IMAGE_FILE_MACHINE_WCEMIPSV2,
MachineTypeAlpha = IMAGE_FILE_MACHINE_ALPHA,
MachineTypeSH3 = IMAGE_FILE_MACHINE_SH3,
MachineTypeSH3DSP = IMAGE_FILE_MACHINE_SH3DSP,
MachineTypeSH3E = IMAGE_FILE_MACHINE_SH3E,
MachineTypeSH4 = IMAGE_FILE_MACHINE_SH4,
MachineTypeSH5 = IMAGE_FILE_MACHINE_SH5,
MachineTypeArm = IMAGE_FILE_MACHINE_ARM,
MachineTypeThumb = IMAGE_FILE_MACHINE_THUMB,
MachineTypeArmNT = IMAGE_FILE_MACHINE_ARMNT,
MachineTypeAM33 = IMAGE_FILE_MACHINE_AM33,
MachineTypePowerPC = IMAGE_FILE_MACHINE_POWERPC,
MachineTypePowerPCFP = IMAGE_FILE_MACHINE_POWERPCFP,
MachineTypeIa64 = IMAGE_FILE_MACHINE_IA64,
MachineTypeMips16 = IMAGE_FILE_MACHINE_MIPS16,
MachineTypeAlpha64 = IMAGE_FILE_MACHINE_ALPHA64,
MachineTypeMipsFpu = IMAGE_FILE_MACHINE_MIPSFPU,
MachineTypeMipsFpu16 = IMAGE_FILE_MACHINE_MIPSFPU16,
MachineTypeTriCore = IMAGE_FILE_MACHINE_TRICORE,
MachineTypeCEF = IMAGE_FILE_MACHINE_CEF,
MachineTypeEBC = IMAGE_FILE_MACHINE_EBC,
MachineTypeAmd64 = IMAGE_FILE_MACHINE_AMD64,
MachineTypeM32R = IMAGE_FILE_MACHINE_M32R,
MachineTypeCEE = IMAGE_FILE_MACHINE_CEE,
};
// SymTagEnum has the unfortunate property that it is not only the name of
// the enum, but also the name of one of the values of the enum. So that we
// don't have to always type "enum SymTagEnum", we typedef this to a different
// name so that we can refer to it more easily.
typedef enum SymTagEnum DiaSymTagEnum;
typedef CComPtr<IDiaSymbol> DiaSymbolPtr;
} // namespace windows
} // namespace sys
} // namespace llvm
namespace llvm {
class raw_ostream;
raw_ostream &operator<<(raw_ostream &Stream,
llvm::sys::windows::DiaSymTagEnum SymTag);
raw_ostream &operator<<(raw_ostream &Stream, CV_CPU_TYPE_e CpuType);
raw_ostream &operator<<(raw_ostream &Stream,
llvm::sys::windows::MachineTypeEnum CpuType);
}
#endif

968
tools/llvm-pdbdump/DIASymbol.cpp Normal file
View File

@ -0,0 +1,968 @@
//===- DIASymbol.cpp - Dump debug info from a PDB file ----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm-pdbdump.h"
#include "DIASymbol.h"
using namespace llvm::sys::windows;
DIASymbol::DIASymbol(IDiaSymbol *DiaSymbol) : Symbol(DiaSymbol) {
Symbol->AddRef();
}
DIASymbol::~DIASymbol() { Symbol->Release(); }
void DIASymbol::fullDump(int IndentLevel) {
getLexicalParent().dump("Lexical parent", IndentLevel);
getClassParent().dump("Class parent", IndentLevel);
getType().dump("Type", IndentLevel);
getArrayIndexType().dump("Array index type", IndentLevel);
getVirtualTableShape().dump("Vtable shape", IndentLevel);
getLowerBound().dump("Lower bound", IndentLevel);
getUpperBound().dump("Upper bound", IndentLevel);
getObjectPointerType().dump("Object pointer type", IndentLevel);
getContainer().dump("Container", IndentLevel);
getVirtualBaseTableType().dump("Virtual base table type", IndentLevel);
getUnmodifiedType().dump("Unmodified type", IndentLevel);
getSubType().dump("Sub type", IndentLevel);
getBaseSymbol().dump("Base symbol", IndentLevel);
#if (_MSC_FULL_VER >= 180031101)
// These methods are only available on VS 2013 SP4 and higher.
isPGO().dump("Is PGO", IndentLevel);
hasValidPGOCounts().dump("Has valid PGO counts", IndentLevel);
isOptimizedForSpeed().dump("Is optimized for speed", IndentLevel);
getPGOEntryCount().dump("PGO entry count", IndentLevel);
getPGOEdgeCount().dump("PGO edge count", IndentLevel);
getPGODynamicInstructionCount().dump("PGO dynamic instruction count",
IndentLevel);
getStaticSize().dump("Static size", IndentLevel);
getFinalLiveStaticSize().dump("Final live static size", IndentLevel);
getPhaseName().dump("Phase name", IndentLevel);
hasControlFlowCheck().dump("Has control flow check", IndentLevel);
#endif
getAccess().dump("Access", IndentLevel);
getAddressOffset().dump("Address Offset", IndentLevel);
getAddressSection().dump("Address Section", IndentLevel);
getAddressTaken().dump("Address Taken", IndentLevel);
getAge().dump("Age", IndentLevel);
getArrayIndexTypeId().dump("Array Index Type Id", IndentLevel);
getBackEndMajor().dump("Back End Major", IndentLevel);
getBackEndMinor().dump("Back End Minor", IndentLevel);
getBackEndBuild().dump("Back End Build", IndentLevel);
getBaseDataOffset().dump("Base Data Offset", IndentLevel);
getBaseDataSlot().dump("Base Data Slot", IndentLevel);
getBaseSymbolId().dump("Base Symbol Id", IndentLevel);
getBaseType().dump("Base Type", IndentLevel);
getBitPosition().dump("Bit Position", IndentLevel);
getBuiltInKind().dump("Built In Kind", IndentLevel);
getCallingConvention().dump("Calling Convention", IndentLevel);
getClassParentId().dump("Class Parent Id", IndentLevel);
isCode().dump("Code", IndentLevel);
isCompilerGenerated().dump("Compiler Generated", IndentLevel);
getCompilerName().dump("Compiler Name", IndentLevel);
hasConstructor().dump("Constructor", IndentLevel);
isConstType().dump("Const Type", IndentLevel);
getCount().dump("Count", IndentLevel);
getCountLiveRanges().dump("Count Live Ranges", IndentLevel);
hasCustomCallingConvention().dump("Custom Calling Convention", IndentLevel);
getDataKind().dump("Data Kind", IndentLevel);
isEditAndContinueEnabled().dump("Edit and Continue Enabled", IndentLevel);
hasFarReturn().dump("Far Return", IndentLevel);
getFrontEndMajor().dump("Front End Major", IndentLevel);
getFrontEndMinor().dump("Front End Minor", IndentLevel);
getFrontEndBuild().dump("Front End Build", IndentLevel);
isFunction().dump("Function", IndentLevel);
getGuid().dump("GUID", IndentLevel);
hasAlloca().dump("Has Alloca", IndentLevel);
hasAssignmentOperator().dump("Has Assignment Operator", IndentLevel);
hasCastOperator().dump("Has Cast Operator", IndentLevel);
hasDebugInfo().dump("Has Debug Info", IndentLevel);
hasEH().dump("Has EH", IndentLevel);
hasEHa().dump("Has EHa", IndentLevel);
hasInlAsm().dump("Has Inline Asm", IndentLevel);
hasLongJump().dump("Has longjmp", IndentLevel);
hasManagedCode().dump("Has Managed Code", IndentLevel);
hasNestedTypes().dump("Has Nested Types", IndentLevel);
hasSecurityChecks().dump("Has Security Checks", IndentLevel);
hasSEH().dump("Has SEH", IndentLevel);
hasSetJump().dump("Has setjmp", IndentLevel);
isIndirectVirtualBaseClass().dump("Is indirect virtual base", IndentLevel);
hasInlineAttribute().dump("Has inline declspec", IndentLevel);
hasInterruptReturn().dump("Has interrupt return", IndentLevel);
isBaseVirtualFunction().dump("Is base virtual function", IndentLevel);
isAcceleratorGroupSharedLocal().dump("Is Accelerator Group Shared Local",
IndentLevel);
isAcceleratorPointerTagLiveRange().dump(
"Is Accelerator Pointer Tag Live Range", IndentLevel);
isAcceleratorStubFunction().dump("Is Accelerator Stub Function", IndentLevel);
isAggregated().dump("Is aggregated", IndentLevel);
hasCTypes().dump("Has C types", IndentLevel);
isCVTCIL().dump("Was converted from MSIL", IndentLevel);
isDataAligned().dump("Is data aligned", IndentLevel);
isHLSLData().dump("Is HLSL data", IndentLevel);
isHotpatchable().dump("Is hot-patchable", IndentLevel);
isLTCG().dump("Is LTCG", IndentLevel);
isMatrixRowMajor().dump("Is matrix row major", IndentLevel);
isMSILNetmodule().dump("Is MSIL .netmodule", IndentLevel);
isMultipleInheritance().dump("Is multiple inheritance", IndentLevel);
isNaked().dump("Is naked", IndentLevel);
isOptimizedAway().dump("Is optimized away", IndentLevel);
isPointerBasedOnSymbolValue().dump("Is pointer based on symbol value",
IndentLevel);
isPointerToDataMember().dump("Is pointer to data member", IndentLevel);
isPointerToMemberFunction().dump("Is pointer to member function",
IndentLevel);
isReturnValue().dump("Is return value", IndentLevel);
isSdl().dump("Is SDL", IndentLevel);
isSingleInheritance().dump("Is single inheritance", IndentLevel);
isSplitted().dump("Is splitted", IndentLevel);
isStatic().dump("Is staic", IndentLevel);
isStripped().dump("Is stripped", IndentLevel);
isVirtualInheritance().dump("Is virtual inheritance", IndentLevel);
getLanguage().dump("Language", IndentLevel);
getLength().dump("Length", IndentLevel);
getLexicalParentId().dump("Lexical parent id", IndentLevel);
getLibraryName().dump("Library name", IndentLevel);
getLiveRangeLength().dump("Live range length", IndentLevel);
getLiveRangeStartAddressSection().dump("Live range start address section",
IndentLevel);
getLiveRangeStartAddressOffset().dump("Live range start address offset",
IndentLevel);
getLiveRangeStartRelativeVirtualAddress().dump("Live range start address RVA",
IndentLevel);
getLocationType().dump("Location type", IndentLevel);
getLowerBoundId().dump("Lower bound id", IndentLevel);
getMachineType().dump("Machine type", IndentLevel);
isManagedRef().dump("Managed", IndentLevel);
getMemorySpaceKind().dump("Memory space kind", IndentLevel);
isMsilRef().dump("MSIL", IndentLevel);
getName().dump("Name", IndentLevel);
isNested().dump("Nested", IndentLevel);
hasNoInlineAttribute().dump("Has noinline declspec", IndentLevel);
hasNoReturnAttribute().dump("Has noreturn declspec", IndentLevel);
getNoStackOrdering().dump("No stack ordering", IndentLevel);
isUnreached().dump("Not reached", IndentLevel);
getNumberOfAcceleratorPointerTags().dump("Number of accelerator pointer tags",
IndentLevel);
getNumberOfModifiers().dump("Number of modifiers", IndentLevel);
getNumberOfRegisterIndices().dump("Number of register indices", IndentLevel);
getNumberOfRows().dump("Number of rows", IndentLevel);
getNumberOfColumns().dump("Number of columns", IndentLevel);
getObjectFileName().dump("Object file name", IndentLevel);
getOemSymbolId().dump("OEM symbol id", IndentLevel);
getOffset().dump("Offset", IndentLevel);
hasOptimizedCodeDebugInfo().dump("Optimized code debug info", IndentLevel);
hasOverloadedOperator().dump("Overloaded operator", IndentLevel);
isPacked().dump("Packed", IndentLevel);
getPlatform().dump("Platform", IndentLevel);
isPureVirtual().dump("Pure", IndentLevel);
getRank().dump("Rank", IndentLevel);
isReference().dump("Reference", IndentLevel);
getRegisterId().dump("Register ID", IndentLevel);
getRegisterType().dump("Register type", IndentLevel);
getRelativeVirtualAddress().dump("RVA", IndentLevel);
isRestrictedType().dump("Restricted type", IndentLevel);
getSamplerSlot().dump("Sampler slot", IndentLevel);
isScoped().dump("Scoped", IndentLevel);
getSignature().dump("Signature", IndentLevel);
getSizeInUdt().dump("Size in UDT", IndentLevel);
getSlot().dump("Slot", IndentLevel);
getSourceFileName().dump("Source file name", IndentLevel);
getStride().dump("Stride", IndentLevel);
getSubTypeId().dump("Sub type ID", IndentLevel);
getSymbolsFileName().dump("File name", IndentLevel);
getSymIndexId().dump("Sym index ID", IndentLevel);
getSymTag().dump("Sym tag", IndentLevel);
getTargetOffset().dump("Target offset", IndentLevel);
getTargetRelativeVirtualAddress().dump("Target RVA", IndentLevel);
getTargetSection().dump("Target section", IndentLevel);
getTargetVirtualAddress().dump("Target virtual address", IndentLevel);
getTextureSlot().dump("Texture slot", IndentLevel);
getThisAdjust().dump("This adjust", IndentLevel);
getThunkOrdinal().dump("Thunk ordinal", IndentLevel);
getTimeStamp().dump("Time stamp", IndentLevel);
getToken().dump("Token", IndentLevel);
getUavSlot().dump("UAV slot", IndentLevel);
getUdtKind().dump("UDT kind", IndentLevel);
isUnalignedType().dump("Unaligned type", IndentLevel);
getUndecoratedName().dump("Undecorated name", IndentLevel);
getUnmodifiedTypeId().dump("Unmodified type id", IndentLevel);
getUpperBoundId().dump("Upper bound id", IndentLevel);
isVirtual().dump("Virtual", IndentLevel);
getVirtualAddress().dump("Virtual address", IndentLevel);
isVirtualBaseClass().dump("Virtual base class", IndentLevel);
getVirtualBaseDispIndex().dump("Virtual base disp index", IndentLevel);
getVirtualBaseOffset().dump("Virtual base offset", IndentLevel);
getVirtualBasePointerOffset().dump("Virtual base pointer offset",
IndentLevel);
getVirtualTableShapeId().dump("Vtable shape ID", IndentLevel);
isVolatileType().dump("Volatile type", IndentLevel);
}
#if (_MSC_FULL_VER >= 180031101)
DIAResult<BOOL> DIASymbol::isPGO() {
return InternalGetDIAValue(&IDiaSymbol::get_isPGO);
}
DIAResult<BOOL> DIASymbol::hasValidPGOCounts() {
return InternalGetDIAValue(&IDiaSymbol::get_hasValidPGOCounts);
}
DIAResult<BOOL> DIASymbol::isOptimizedForSpeed() {
return InternalGetDIAValue(&IDiaSymbol::get_isOptimizedForSpeed);
}
DIAResult<DWORD> DIASymbol::getPGOEntryCount() {
return InternalGetDIAValue(&IDiaSymbol::get_PGOEntryCount);
}
DIAResult<DWORD> DIASymbol::getPGOEdgeCount() {
return InternalGetDIAValue(&IDiaSymbol::get_PGOEdgeCount);
}
DIAResult<ULONGLONG> DIASymbol::getPGODynamicInstructionCount() {
return InternalGetDIAValue(&IDiaSymbol::get_PGODynamicInstructionCount);
}
DIAResult<DWORD> DIASymbol::getStaticSize() {
return InternalGetDIAValue(&IDiaSymbol::get_staticSize);
}
DIAResult<DWORD> DIASymbol::getFinalLiveStaticSize() {
return InternalGetDIAValue(&IDiaSymbol::get_finalLiveStaticSize);
}
DIAResult<DIAString> DIASymbol::getPhaseName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_phaseName);
}
DIAResult<BOOL> DIASymbol::hasControlFlowCheck() {
return InternalGetDIAValue(&IDiaSymbol::get_hasControlFlowCheck);
}
#endif
DIAResult<DiaSymbolPtr> DIASymbol::getClassParent() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_classParent);
}
DIAResult<DiaSymbolPtr> DIASymbol::getType() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(&IDiaSymbol::get_type);
}
DIAResult<DiaSymbolPtr> DIASymbol::getArrayIndexType() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_arrayIndexType);
}
DIAResult<DiaSymbolPtr> DIASymbol::getVirtualTableShape() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_virtualTableShape);
}
DIAResult<DiaSymbolPtr> DIASymbol::getLowerBound() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_lowerBound);
}
DIAResult<DiaSymbolPtr> DIASymbol::getUpperBound() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_upperBound);
}
DIAResult<DiaSymbolPtr> DIASymbol::getObjectPointerType() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_objectPointerType);
}
DIAResult<DiaSymbolPtr> DIASymbol::getContainer() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_container);
}
DIAResult<DiaSymbolPtr> DIASymbol::getVirtualBaseTableType() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_virtualBaseTableType);
}
DIAResult<DiaSymbolPtr> DIASymbol::getUnmodifiedType() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_unmodifiedType);
}
DIAResult<DiaSymbolPtr> DIASymbol::getSubType() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_subType);
}
DIAResult<DiaSymbolPtr> DIASymbol::getBaseSymbol() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_baseSymbol);
}
DIAResult<DWORD> DIASymbol::getAccess() {
return InternalGetDIAValue(&IDiaSymbol::get_access);
}
DIAResult<DWORD> DIASymbol::getAddressOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_addressOffset);
}
DIAResult<DWORD> DIASymbol::getAddressSection() {
return InternalGetDIAValue(&IDiaSymbol::get_addressSection);
}
DIAResult<BOOL> DIASymbol::getAddressTaken() {
return InternalGetDIAValue(&IDiaSymbol::get_addressTaken);
}
DIAResult<DWORD> DIASymbol::getAge() {
return InternalGetDIAValue(&IDiaSymbol::get_age);
}
DIAResult<DWORD> DIASymbol::getArrayIndexTypeId() {
return InternalGetDIAValue(&IDiaSymbol::get_arrayIndexTypeId);
}
DIAResult<DWORD> DIASymbol::getBackEndMajor() {
return InternalGetDIAValue(&IDiaSymbol::get_backEndMajor);
}
DIAResult<DWORD> DIASymbol::getBackEndMinor() {
return InternalGetDIAValue(&IDiaSymbol::get_backEndMinor);
}
DIAResult<DWORD> DIASymbol::getBackEndBuild() {
return InternalGetDIAValue(&IDiaSymbol::get_backEndBuild);
}
DIAResult<DWORD> DIASymbol::getBackEndQFE() {
return InternalGetDIAValue(&IDiaSymbol::get_backEndQFE);
}
DIAResult<DWORD> DIASymbol::getBaseDataOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_baseDataOffset);
}
DIAResult<DWORD> DIASymbol::getBaseDataSlot() {
return InternalGetDIAValue(&IDiaSymbol::get_baseDataSlot);
}
DIAResult<DWORD> DIASymbol::getBaseSymbolId() {
return InternalGetDIAValue(&IDiaSymbol::get_baseSymbolId);
}
DIAResult<DWORD> DIASymbol::getBaseType() {
return InternalGetDIAValue(&IDiaSymbol::get_baseType);
}
DIAResult<DWORD> DIASymbol::getBitPosition() {
return InternalGetDIAValue(&IDiaSymbol::get_bitPosition);
}
DIAResult<DWORD> DIASymbol::getBuiltInKind() {
return InternalGetDIAValue(&IDiaSymbol::get_builtInKind);
}
DIAResult<CV_call_e> DIASymbol::getCallingConvention() {
return InternalGetDIAValue<DWORD, CV_call_e>(
&IDiaSymbol::get_callingConvention);
}
DIAResult<DWORD> DIASymbol::getClassParentId() {
return InternalGetDIAValue(&IDiaSymbol::get_classParentId);
}
DIAResult<BOOL> DIASymbol::isCode() {
return InternalGetDIAValue(&IDiaSymbol::get_code);
}
DIAResult<BOOL> DIASymbol::isCompilerGenerated() {
return InternalGetDIAValue(&IDiaSymbol::get_compilerGenerated);
}
DIAResult<DIAString> DIASymbol::getCompilerName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_compilerName);
}
DIAResult<BOOL> DIASymbol::hasConstructor() {
return InternalGetDIAValue(&IDiaSymbol::get_constructor);
}
DIAResult<BOOL> DIASymbol::isConstType() {
return InternalGetDIAValue(&IDiaSymbol::get_constType);
}
DIAResult<DWORD> DIASymbol::getCount() {
return InternalGetDIAValue(&IDiaSymbol::get_count);
}
DIAResult<DWORD> DIASymbol::getCountLiveRanges() {
return InternalGetDIAValue(&IDiaSymbol::get_countLiveRanges);
}
DIAResult<BOOL> DIASymbol::hasCustomCallingConvention() {
return InternalGetDIAValue(&IDiaSymbol::get_customCallingConvention);
}
DIAResult<DataKind> DIASymbol::getDataKind() {
return InternalGetDIAValue<DWORD, DataKind>(&IDiaSymbol::get_dataKind);
}
DIAResult<BOOL> DIASymbol::isEditAndContinueEnabled() {
return InternalGetDIAValue(&IDiaSymbol::get_editAndContinueEnabled);
}
DIAResult<BOOL> DIASymbol::hasFarReturn() {
return InternalGetDIAValue(&IDiaSymbol::get_farReturn);
}
DIAResult<DWORD> DIASymbol::getFrontEndMajor() {
return InternalGetDIAValue(&IDiaSymbol::get_frontEndMajor);
}
DIAResult<DWORD> DIASymbol::getFrontEndMinor() {
return InternalGetDIAValue(&IDiaSymbol::get_frontEndMinor);
}
DIAResult<DWORD> DIASymbol::getFrontEndBuild() {
return InternalGetDIAValue(&IDiaSymbol::get_frontEndBuild);
}
DIAResult<DWORD> DIASymbol::getFrontEndQFE() {
return InternalGetDIAValue(&IDiaSymbol::get_frontEndQFE);
}
DIAResult<BOOL> DIASymbol::isFunction() {
return InternalGetDIAValue(&IDiaSymbol::get_function);
}
DIAResult<GUID> DIASymbol::getGuid() {
return InternalGetDIAValue(&IDiaSymbol::get_guid);
}
DIAResult<BOOL> DIASymbol::hasAlloca() {
return InternalGetDIAValue(&IDiaSymbol::get_hasAlloca);
}
DIAResult<BOOL> DIASymbol::hasAssignmentOperator() {
return InternalGetDIAValue(&IDiaSymbol::get_hasAssignmentOperator);
}
DIAResult<BOOL> DIASymbol::hasCastOperator() {
return InternalGetDIAValue(&IDiaSymbol::get_hasCastOperator);
}
DIAResult<BOOL> DIASymbol::hasDebugInfo() {
return InternalGetDIAValue(&IDiaSymbol::get_hasDebugInfo);
}
DIAResult<BOOL> DIASymbol::hasEH() {
return InternalGetDIAValue(&IDiaSymbol::get_hasEH);
}
DIAResult<BOOL> DIASymbol::hasEHa() {
return InternalGetDIAValue(&IDiaSymbol::get_hasEHa);
}
DIAResult<BOOL> DIASymbol::hasInlAsm() {
return InternalGetDIAValue(&IDiaSymbol::get_hasInlAsm);
}
DIAResult<BOOL> DIASymbol::hasLongJump() {
return InternalGetDIAValue(&IDiaSymbol::get_hasLongJump);
}
DIAResult<BOOL> DIASymbol::hasManagedCode() {
return InternalGetDIAValue(&IDiaSymbol::get_hasManagedCode);
}
DIAResult<BOOL> DIASymbol::hasNestedTypes() {
return InternalGetDIAValue(&IDiaSymbol::get_hasNestedTypes);
}
DIAResult<BOOL> DIASymbol::hasSecurityChecks() {
return InternalGetDIAValue(&IDiaSymbol::get_hasSecurityChecks);
}
DIAResult<BOOL> DIASymbol::hasSEH() {
return InternalGetDIAValue(&IDiaSymbol::get_hasSEH);
}
DIAResult<BOOL> DIASymbol::hasSetJump() {
return InternalGetDIAValue(&IDiaSymbol::get_hasSetJump);
}
DIAResult<BOOL> DIASymbol::isIndirectVirtualBaseClass() {
return InternalGetDIAValue(&IDiaSymbol::get_indirectVirtualBaseClass);
}
DIAResult<BOOL> DIASymbol::hasInlineAttribute() {
return InternalGetDIAValue(&IDiaSymbol::get_inlSpec);
}
DIAResult<BOOL> DIASymbol::hasInterruptReturn() {
return InternalGetDIAValue(&IDiaSymbol::get_interruptReturn);
}
DIAResult<BOOL> DIASymbol::isBaseVirtualFunction() {
return InternalGetDIAValue(&IDiaSymbol::get_intro);
}
DIAResult<BOOL> DIASymbol::isIntrinsic() {
return InternalGetDIAValue(&IDiaSymbol::get_intrinsic);
}
DIAResult<BOOL> DIASymbol::isAcceleratorGroupSharedLocal() {
return InternalGetDIAValue(&IDiaSymbol::get_isAcceleratorGroupSharedLocal);
}
DIAResult<BOOL> DIASymbol::isAcceleratorPointerTagLiveRange() {
return InternalGetDIAValue(&IDiaSymbol::get_isAcceleratorPointerTagLiveRange);
}
DIAResult<BOOL> DIASymbol::isAcceleratorStubFunction() {
return InternalGetDIAValue(&IDiaSymbol::get_isAcceleratorStubFunction);
}
DIAResult<BOOL> DIASymbol::isAggregated() {
return InternalGetDIAValue(&IDiaSymbol::get_isAggregated);
}
DIAResult<BOOL> DIASymbol::isConstructorVirtualBase() {
return InternalGetDIAValue(&IDiaSymbol::get_isConstructorVirtualBase);
}
DIAResult<BOOL> DIASymbol::hasStrictGSCheck() {
return InternalGetDIAValue(&IDiaSymbol::get_strictGSCheck);
}
DIAResult<BOOL> DIASymbol::isLocationControlFlowDependent() {
return InternalGetDIAValue(&IDiaSymbol::get_isLocationControlFlowDependent);
}
DIAResult<BOOL> DIASymbol::hasCTypes() {
return InternalGetDIAValue(&IDiaSymbol::get_isCTypes);
}
DIAResult<BOOL> DIASymbol::isCVTCIL() {
return InternalGetDIAValue(&IDiaSymbol::get_isCVTCIL);
}
DIAResult<BOOL> DIASymbol::isDataAligned() {
return InternalGetDIAValue(&IDiaSymbol::get_isDataAligned);
}
DIAResult<BOOL> DIASymbol::isHLSLData() {
return InternalGetDIAValue(&IDiaSymbol::get_isHLSLData);
}
DIAResult<BOOL> DIASymbol::isHotpatchable() {
return InternalGetDIAValue(&IDiaSymbol::get_isHotpatchable);
}
DIAResult<BOOL> DIASymbol::isLTCG() {
return InternalGetDIAValue(&IDiaSymbol::get_isLTCG);
}
DIAResult<BOOL> DIASymbol::isMatrixRowMajor() {
return InternalGetDIAValue(&IDiaSymbol::get_isMatrixRowMajor);
}
DIAResult<BOOL> DIASymbol::isMSILNetmodule() {
return InternalGetDIAValue(&IDiaSymbol::get_isMSILNetmodule);
}
DIAResult<BOOL> DIASymbol::isMultipleInheritance() {
return InternalGetDIAValue(&IDiaSymbol::get_isMultipleInheritance);
}
DIAResult<BOOL> DIASymbol::isNaked() {
return InternalGetDIAValue(&IDiaSymbol::get_isNaked);
}
DIAResult<BOOL> DIASymbol::isOptimizedAway() {
return InternalGetDIAValue(&IDiaSymbol::get_isOptimizedAway);
}
DIAResult<BOOL> DIASymbol::isPointerBasedOnSymbolValue() {
return InternalGetDIAValue(&IDiaSymbol::get_isPointerBasedOnSymbolValue);
}
DIAResult<BOOL> DIASymbol::isPointerToDataMember() {
return InternalGetDIAValue(&IDiaSymbol::get_isPointerToDataMember);
}
DIAResult<BOOL> DIASymbol::isPointerToMemberFunction() {
return InternalGetDIAValue(&IDiaSymbol::get_isPointerToMemberFunction);
}
DIAResult<BOOL> DIASymbol::isReturnValue() {
return InternalGetDIAValue(&IDiaSymbol::get_isReturnValue);
}
DIAResult<BOOL> DIASymbol::isSdl() {
return InternalGetDIAValue(&IDiaSymbol::get_isSdl);
}
DIAResult<BOOL> DIASymbol::isSingleInheritance() {
return InternalGetDIAValue(&IDiaSymbol::get_isSingleInheritance);
}
DIAResult<BOOL> DIASymbol::isSplitted() {
return InternalGetDIAValue(&IDiaSymbol::get_isSplitted);
}
DIAResult<BOOL> DIASymbol::isStatic() {
return InternalGetDIAValue(&IDiaSymbol::get_isStatic);
}
DIAResult<BOOL> DIASymbol::isStripped() {
return InternalGetDIAValue(&IDiaSymbol::get_isStripped);
}
DIAResult<BOOL> DIASymbol::isVirtualInheritance() {
return InternalGetDIAValue(&IDiaSymbol::get_isVirtualInheritance);
}
DIAResult<CV_CFL_LANG> DIASymbol::getLanguage() {
return InternalGetDIAValue<DWORD, CV_CFL_LANG>(&IDiaSymbol::get_language);
}
DIAResult<BOOL> DIASymbol::isSafeBuffers() {
return InternalGetDIAValue(&IDiaSymbol::get_isSafeBuffers);
}
DIAResult<ULONGLONG> DIASymbol::getLength() {
return InternalGetDIAValue(&IDiaSymbol::get_length);
}
DIAResult<DWORD> DIASymbol::getLexicalParentId() {
return InternalGetDIAValue(&IDiaSymbol::get_lexicalParentId);
}
DIAResult<DiaSymbolPtr> DIASymbol::getLexicalParent() {
return InternalGetDIAValue<IDiaSymbol *, DiaSymbolPtr>(
&IDiaSymbol::get_lexicalParent);
}
DIAResult<DWORD> DIASymbol::getLocalBasePointerRegisterId() {
return InternalGetDIAValue(&IDiaSymbol::get_localBasePointerRegisterId);
}
DIAResult<DIAString> DIASymbol::getLibraryName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_libraryName);
}
DIAResult<ULONGLONG> DIASymbol::getLiveRangeLength() {
return InternalGetDIAValue(&IDiaSymbol::get_liveRangeLength);
}
DIAResult<DWORD> DIASymbol::getLiveRangeStartAddressSection() {
return InternalGetDIAValue(&IDiaSymbol::get_liveRangeStartAddressSection);
}
DIAResult<DWORD> DIASymbol::getLiveRangeStartAddressOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_liveRangeStartAddressOffset);
}
DIAResult<DWORD> DIASymbol::getLiveRangeStartRelativeVirtualAddress() {
return InternalGetDIAValue(
&IDiaSymbol::get_liveRangeStartRelativeVirtualAddress);
}
DIAResult<LocationType> DIASymbol::getLocationType() {
return InternalGetDIAValue<DWORD, LocationType>(
&IDiaSymbol::get_locationType);
}
DIAResult<DWORD> DIASymbol::getLowerBoundId() {
return InternalGetDIAValue(&IDiaSymbol::get_lowerBoundId);
}
DIAResult<MachineTypeEnum> DIASymbol::getMachineType() {
return InternalGetDIAValue<DWORD, MachineTypeEnum>(
&IDiaSymbol::get_machineType);
}
DIAResult<BOOL> DIASymbol::isManagedRef() {
return InternalGetDIAValue(&IDiaSymbol::get_managed);
}
DIAResult<DWORD> DIASymbol::getMemorySpaceKind() {
return InternalGetDIAValue(&IDiaSymbol::get_memorySpaceKind);
}
DIAResult<BOOL> DIASymbol::isMsilRef() {
return InternalGetDIAValue(&IDiaSymbol::get_msil);
}
DIAResult<DIAString> DIASymbol::getName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_name);
}
DIAResult<BOOL> DIASymbol::isNested() {
return InternalGetDIAValue(&IDiaSymbol::get_nested);
}
DIAResult<BOOL> DIASymbol::hasNoInlineAttribute() {
return InternalGetDIAValue(&IDiaSymbol::get_noInline);
}
DIAResult<BOOL> DIASymbol::hasNoReturnAttribute() {
return InternalGetDIAValue(&IDiaSymbol::get_noReturn);
}
DIAResult<BOOL> DIASymbol::getNoStackOrdering() {
return InternalGetDIAValue(&IDiaSymbol::get_noStackOrdering);
}
DIAResult<BOOL> DIASymbol::isUnreached() {
return InternalGetDIAValue(&IDiaSymbol::get_notReached);
}
DIAResult<DWORD> DIASymbol::getNumberOfAcceleratorPointerTags() {
return InternalGetDIAValue(&IDiaSymbol::get_numberOfAcceleratorPointerTags);
}
DIAResult<DWORD> DIASymbol::getNumberOfModifiers() {
return InternalGetDIAValue(&IDiaSymbol::get_numberOfModifiers);
}
DIAResult<DWORD> DIASymbol::getNumberOfRegisterIndices() {
return InternalGetDIAValue(&IDiaSymbol::get_numberOfRegisterIndices);
}
DIAResult<DWORD> DIASymbol::getNumberOfRows() {
return InternalGetDIAValue(&IDiaSymbol::get_numberOfRows);
}
DIAResult<DWORD> DIASymbol::getNumberOfColumns() {
return InternalGetDIAValue(&IDiaSymbol::get_numberOfColumns);
}
DIAResult<DIAString> DIASymbol::getObjectFileName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_objectFileName);
}
DIAResult<DWORD> DIASymbol::getOemSymbolId() {
return InternalGetDIAValue(&IDiaSymbol::get_oemSymbolId);
}
DIAResult<LONG> DIASymbol::getOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_offset);
}
DIAResult<DWORD> DIASymbol::getOffsetInUdt() {
return InternalGetDIAValue(&IDiaSymbol::get_offsetInUdt);
}
DIAResult<BOOL> DIASymbol::hasOptimizedCodeDebugInfo() {
return InternalGetDIAValue(&IDiaSymbol::get_optimizedCodeDebugInfo);
}
DIAResult<BOOL> DIASymbol::hasOverloadedOperator() {
return InternalGetDIAValue(&IDiaSymbol::get_overloadedOperator);
}
DIAResult<BOOL> DIASymbol::isPacked() {
return InternalGetDIAValue(&IDiaSymbol::get_packed);
}
DIAResult<CV_CPU_TYPE_e> DIASymbol::getPlatform() {
return InternalGetDIAValue<DWORD, CV_CPU_TYPE_e>(&IDiaSymbol::get_platform);
}
DIAResult<BOOL> DIASymbol::isPureVirtual() {
return InternalGetDIAValue(&IDiaSymbol::get_pure);
}
DIAResult<DWORD> DIASymbol::getRank() {
return InternalGetDIAValue(&IDiaSymbol::get_rank);
}
DIAResult<BOOL> DIASymbol::isReference() {
return InternalGetDIAValue(&IDiaSymbol::get_reference);
}
DIAResult<BOOL> DIASymbol::isRValueReference() {
return InternalGetDIAValue(&IDiaSymbol::get_RValueReference);
}
DIAResult<DWORD> DIASymbol::getRegisterId() {
return InternalGetDIAValue(&IDiaSymbol::get_registerId);
}
DIAResult<DWORD> DIASymbol::getRegisterType() {
return InternalGetDIAValue(&IDiaSymbol::get_registerType);
}
DIAResult<DWORD> DIASymbol::getRelativeVirtualAddress() {
return InternalGetDIAValue(&IDiaSymbol::get_relativeVirtualAddress);
}
DIAResult<BOOL> DIASymbol::isRestrictedType() {
return InternalGetDIAValue(&IDiaSymbol::get_restrictedType);
}
DIAResult<DWORD> DIASymbol::getSamplerSlot() {
return InternalGetDIAValue(&IDiaSymbol::get_samplerSlot);
}
DIAResult<BOOL> DIASymbol::isScoped() {
return InternalGetDIAValue(&IDiaSymbol::get_scoped);
}
DIAResult<BOOL> DIASymbol::isRefUdt() {
return InternalGetDIAValue(&IDiaSymbol::get_isRefUdt);
}
DIAResult<BOOL> DIASymbol::isValueUdt() {
return InternalGetDIAValue(&IDiaSymbol::get_isValueUdt);
}
DIAResult<BOOL> DIASymbol::isInterfaceUdt() {
return InternalGetDIAValue(&IDiaSymbol::get_isInterfaceUdt);
}
DIAResult<BOOL> DIASymbol::isCxxReturnUdt() {
return InternalGetDIAValue(&IDiaSymbol::get_isCxxReturnUdt);
}
DIAResult<DWORD> DIASymbol::getSignature() {
return InternalGetDIAValue(&IDiaSymbol::get_signature);
}
DIAResult<DWORD> DIASymbol::getSizeInUdt() {
return InternalGetDIAValue(&IDiaSymbol::get_sizeInUdt);
}
DIAResult<DWORD> DIASymbol::getSlot() {
return InternalGetDIAValue(&IDiaSymbol::get_slot);
}
DIAResult<DIAString> DIASymbol::getSourceFileName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_sourceFileName);
}
DIAResult<DWORD> DIASymbol::getStride() {
return InternalGetDIAValue(&IDiaSymbol::get_stride);
}
DIAResult<DWORD> DIASymbol::getSubTypeId() {
return InternalGetDIAValue(&IDiaSymbol::get_subTypeId);
}
DIAResult<DIAString> DIASymbol::getSymbolsFileName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_symbolsFileName);
}
DIAResult<DWORD> DIASymbol::getSymIndexId() {
return InternalGetDIAValue(&IDiaSymbol::get_symIndexId);
}
DIAResult<DiaSymTagEnum> DIASymbol::getSymTag() {
return InternalGetDIAValue<DWORD, DiaSymTagEnum>(&IDiaSymbol::get_symTag);
}
DIAResult<DWORD> DIASymbol::getTargetOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_targetOffset);
}
DIAResult<DWORD> DIASymbol::getTargetRelativeVirtualAddress() {
return InternalGetDIAValue(&IDiaSymbol::get_targetRelativeVirtualAddress);
}
DIAResult<DWORD> DIASymbol::getTargetSection() {
return InternalGetDIAValue(&IDiaSymbol::get_targetSection);
}
DIAResult<ULONGLONG> DIASymbol::getTargetVirtualAddress() {
return InternalGetDIAValue(&IDiaSymbol::get_targetVirtualAddress);
}
DIAResult<DWORD> DIASymbol::getTextureSlot() {
return InternalGetDIAValue(&IDiaSymbol::get_textureSlot);
}
DIAResult<LONG> DIASymbol::getThisAdjust() {
return InternalGetDIAValue(&IDiaSymbol::get_thisAdjust);
}
DIAResult<THUNK_ORDINAL> DIASymbol::getThunkOrdinal() {
return InternalGetDIAValue<DWORD, THUNK_ORDINAL>(
&IDiaSymbol::get_thunkOrdinal);
}
DIAResult<DWORD> DIASymbol::getTimeStamp() {
return InternalGetDIAValue(&IDiaSymbol::get_timeStamp);
}
DIAResult<DWORD> DIASymbol::getToken() {
return InternalGetDIAValue(&IDiaSymbol::get_token);
}
DIAResult<DWORD> DIASymbol::getUavSlot() {
return InternalGetDIAValue(&IDiaSymbol::get_uavSlot);
}
DIAResult<UdtKind> DIASymbol::getUdtKind() {
return InternalGetDIAValue<DWORD, UdtKind>(&IDiaSymbol::get_udtKind);
}
DIAResult<BOOL> DIASymbol::isUnalignedType() {
return InternalGetDIAValue(&IDiaSymbol::get_unalignedType);
}
DIAResult<DIAString> DIASymbol::getUndecoratedName() {
return InternalGetDIAStringValue(&IDiaSymbol::get_undecoratedName);
}
DIAResult<DWORD> DIASymbol::getUnmodifiedTypeId() {
return InternalGetDIAValue(&IDiaSymbol::get_unmodifiedTypeId);
}
DIAResult<DWORD> DIASymbol::getUpperBoundId() {
return InternalGetDIAValue(&IDiaSymbol::get_upperBoundId);
}
DIAResult<BOOL> DIASymbol::isVirtual() {
return InternalGetDIAValue(&IDiaSymbol::get_virtual);
}
DIAResult<ULONGLONG> DIASymbol::getVirtualAddress() {
return InternalGetDIAValue(&IDiaSymbol::get_virtualAddress);
}
DIAResult<BOOL> DIASymbol::isVirtualBaseClass() {
return InternalGetDIAValue(&IDiaSymbol::get_virtualBaseClass);
}
DIAResult<DWORD> DIASymbol::getVirtualBaseDispIndex() {
return InternalGetDIAValue(&IDiaSymbol::get_virtualBaseDispIndex);
}
DIAResult<DWORD> DIASymbol::getVirtualBaseOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_virtualBaseOffset);
}
DIAResult<LONG> DIASymbol::getVirtualBasePointerOffset() {
return InternalGetDIAValue(&IDiaSymbol::get_virtualBasePointerOffset);
}
DIAResult<DWORD> DIASymbol::getVirtualTableShapeId() {
return InternalGetDIAValue(&IDiaSymbol::get_virtualTableShapeId);
}
DIAResult<BOOL> DIASymbol::isVolatileType() {
return InternalGetDIAValue(&IDiaSymbol::get_volatileType);
}

282
tools/llvm-pdbdump/DIASymbol.h Normal file
View File

@ -0,0 +1,282 @@
//===- DIASymbol.h - Dump debug info from a PDB file ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Provides a wrapper around the IDiaSymbol interface. IDiaSymbol is used to
// represent any kind of symbol from functions, to compilands, to source files.
// It provides a monolithic interface of close to 200 operations, and the set
// of operations that are valid depends on the type of the symbol. Since it is
// not clearly documented which set of operations is valid for which type of
// symbol, the best way of figuring it out is to dump every method for every
// symbol, and see which methods return errors. This wrapper provides a clean
// way of doing this without involving needing to embed lots of unsightly
// HRESULT checking at every callsite.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVMPDBDUMP_DIASYMBOL_H
#define LLVM_TOOLS_LLVMPDBDUMP_DIASYMBOL_H
#include "DIAExtras.h"
#include "llvm/ADT/SmallString.h"
namespace llvm {
namespace sys {
namespace windows {
class DIASymbol {
public:
DIASymbol(IDiaSymbol *DiaSymbol);
~DIASymbol();
/// Dumps the value of every property (if it exists) with a default name.
/// This is useful for understanding what symbol types support what methods
/// during development time.
void fullDump(int IndentLevel);
// TODO: The following methods are present on IDiaSymbol but do not yet have
// wrapper methods.
//
// HRESULT get_value(VARIANT *pRetVal) = 0;
// HRESULT get_undecoratedNameEx(DWORD undecorateOptions, BSTR *name) = 0;
// HRESULT getSrcLineOnTypeDefn(IDiaLineNumber **ppResult) = 0;
// HRESULT get_dataBytes(DWORD cbData, DWORD *pcbData, BYTE *pbData) = 0;
// HRESULT get_types(DWORD cTypes, DWORD *pcTypes, IDiaSymbol **pTypes) = 0;
// HRESULT get_typeIds(DWORD cTypeIds, DWORD *pcTypeIds, DWORD *pdwTypeIds) = 0;
// HRESULT get_numericProperties(DWORD cnt, DWORD *pcnt,
// DWORD *pProperties) = 0;
// HRESULT get_modifierValues(DWORD cnt, DWORD *pcnt, WORD *pModifiers) = 0;
// HRESULT get_acceleratorPointerTags(DWORD cnt, DWORD *pcnt, DWORD
// *pPointerTags) = 0;
// HRESULT get_hfaFloat(BOOL *pRetVal) = 0;
// HRESULT get_hfaDouble(BOOL *pRetVal) = 0;
// HRESULT get_paramBasePointerRegisterId(DWORD *pRetVal) = 0;
// HRESULT get_isWinRTPointer(BOOL *pRetVal) = 0;
#if (_MSC_FULL_VER >= 180031101)
// These methods are only available on VS 2013 SP 4 and higher.
DIAResult<BOOL> isPGO();
DIAResult<BOOL> hasValidPGOCounts();
DIAResult<BOOL> isOptimizedForSpeed();
DIAResult<DWORD> getPGOEntryCount();
DIAResult<DWORD> getPGOEdgeCount();
DIAResult<ULONGLONG> getPGODynamicInstructionCount();
DIAResult<DWORD> getStaticSize();
DIAResult<DWORD> getFinalLiveStaticSize();
DIAResult<DIAString> getPhaseName();
DIAResult<BOOL> hasControlFlowCheck();
#endif
DIAResult<DiaSymbolPtr> getLexicalParent();
DIAResult<DiaSymbolPtr> getClassParent();
DIAResult<DiaSymbolPtr> getType();
DIAResult<DiaSymbolPtr> getArrayIndexType();
DIAResult<DiaSymbolPtr> getVirtualTableShape();
DIAResult<DiaSymbolPtr> getLowerBound();
DIAResult<DiaSymbolPtr> getUpperBound();
DIAResult<DiaSymbolPtr> getObjectPointerType();
DIAResult<DiaSymbolPtr> getContainer();
DIAResult<DiaSymbolPtr> getVirtualBaseTableType();
DIAResult<DiaSymbolPtr> getUnmodifiedType();
DIAResult<DiaSymbolPtr> getSubType();
DIAResult<DiaSymbolPtr> getBaseSymbol();
DIAResult<DWORD> getAccess();
DIAResult<DWORD> getAddressOffset();
DIAResult<DWORD> getAddressSection();
DIAResult<DWORD> getAge();
DIAResult<DWORD> getArrayIndexTypeId();
DIAResult<DWORD> getBackEndBuild();
DIAResult<DWORD> getBackEndMajor();
DIAResult<DWORD> getBackEndMinor();
DIAResult<DWORD> getBackEndQFE();
DIAResult<DWORD> getBaseDataOffset();
DIAResult<DWORD> getBaseDataSlot();
DIAResult<DWORD> getBaseSymbolId();
DIAResult<DWORD> getBaseType();
DIAResult<DWORD> getBitPosition();
DIAResult<DWORD> getBuiltInKind();
DIAResult<CV_call_e> getCallingConvention();
DIAResult<DWORD> getClassParentId();
DIAResult<DIAString> getCompilerName();
DIAResult<DWORD> getCount();
DIAResult<DWORD> getCountLiveRanges();
DIAResult<DWORD> getFrontEndBuild();
DIAResult<DWORD> getFrontEndMajor();
DIAResult<DWORD> getFrontEndMinor();
DIAResult<DWORD> getFrontEndQFE();
DIAResult<CV_CFL_LANG> getLanguage();
DIAResult<DWORD> getLexicalParentId();
DIAResult<DIAString> getLibraryName();
DIAResult<DWORD> getLiveRangeStartAddressOffset();
DIAResult<DWORD> getLiveRangeStartAddressSection();
DIAResult<DWORD> getLiveRangeStartRelativeVirtualAddress();
DIAResult<DWORD> getLocalBasePointerRegisterId();
DIAResult<DWORD> getLowerBoundId();
DIAResult<DWORD> getMemorySpaceKind();
DIAResult<DIAString> getName();
DIAResult<DWORD> getNumberOfAcceleratorPointerTags();
DIAResult<DWORD> getNumberOfColumns();
DIAResult<DWORD> getNumberOfModifiers();
DIAResult<DWORD> getNumberOfRegisterIndices();
DIAResult<DWORD> getNumberOfRows();
DIAResult<DIAString> getObjectFileName();
DIAResult<DWORD> getOemSymbolId();
DIAResult<DWORD> getOffsetInUdt();
DIAResult<CV_CPU_TYPE_e> getPlatform();
DIAResult<DWORD> getRank();
DIAResult<DWORD> getRegisterId();
DIAResult<DWORD> getRegisterType();
DIAResult<DWORD> getRelativeVirtualAddress();
DIAResult<DWORD> getSamplerSlot();
DIAResult<DWORD> getSignature();
DIAResult<DWORD> getSizeInUdt();
DIAResult<DWORD> getSlot();
DIAResult<DIAString> getSourceFileName();
DIAResult<DWORD> getStride();
DIAResult<DWORD> getSubTypeId();
DIAResult<DIAString> getSymbolsFileName();
DIAResult<DWORD> getSymIndexId();
DIAResult<DWORD> getTargetOffset();
DIAResult<DWORD> getTargetRelativeVirtualAddress();
DIAResult<DWORD> getTargetSection();
DIAResult<DWORD> getTextureSlot();
DIAResult<DWORD> getTimeStamp();
DIAResult<DWORD> getToken();
DIAResult<DWORD> getUavSlot();
DIAResult<DIAString> getUndecoratedName();
DIAResult<DWORD> getUnmodifiedTypeId();
DIAResult<DWORD> getUpperBoundId();
DIAResult<DWORD> getVirtualBaseDispIndex();
DIAResult<DWORD> getVirtualBaseOffset();
DIAResult<DWORD> getVirtualTableShapeId();
DIAResult<DataKind> getDataKind();
DIAResult<DiaSymTagEnum> getSymTag();
DIAResult<GUID> getGuid();
DIAResult<LONG> getOffset();
DIAResult<LONG> getThisAdjust();
DIAResult<LONG> getVirtualBasePointerOffset();
DIAResult<LocationType> getLocationType();
DIAResult<MachineTypeEnum> getMachineType();
DIAResult<THUNK_ORDINAL> getThunkOrdinal();
DIAResult<ULONGLONG> getLength();
DIAResult<ULONGLONG> getLiveRangeLength();
DIAResult<ULONGLONG> getTargetVirtualAddress();
DIAResult<ULONGLONG> getVirtualAddress();
DIAResult<UdtKind> getUdtKind();
DIAResult<BOOL> hasConstructor();
DIAResult<BOOL> hasCustomCallingConvention();
DIAResult<BOOL> hasFarReturn();
DIAResult<BOOL> isCode();
DIAResult<BOOL> isCompilerGenerated();
DIAResult<BOOL> isConstType();
DIAResult<BOOL> isEditAndContinueEnabled();
DIAResult<BOOL> isFunction();
DIAResult<BOOL> getAddressTaken();
DIAResult<BOOL> getNoStackOrdering();
DIAResult<BOOL> hasAlloca();
DIAResult<BOOL> hasAssignmentOperator();
DIAResult<BOOL> hasCTypes();
DIAResult<BOOL> hasCastOperator();
DIAResult<BOOL> hasDebugInfo();
DIAResult<BOOL> hasEH();
DIAResult<BOOL> hasEHa();
DIAResult<BOOL> hasInlAsm();
DIAResult<BOOL> hasInlineAttribute();
DIAResult<BOOL> hasInterruptReturn();
DIAResult<BOOL> hasLongJump();
DIAResult<BOOL> hasManagedCode();
DIAResult<BOOL> hasNestedTypes();
DIAResult<BOOL> hasNoInlineAttribute();
DIAResult<BOOL> hasNoReturnAttribute();
DIAResult<BOOL> hasOptimizedCodeDebugInfo();
DIAResult<BOOL> hasOverloadedOperator();
DIAResult<BOOL> hasSEH();
DIAResult<BOOL> hasSecurityChecks();
DIAResult<BOOL> hasSetJump();
DIAResult<BOOL> hasStrictGSCheck();
DIAResult<BOOL> isAcceleratorGroupSharedLocal();
DIAResult<BOOL> isAcceleratorPointerTagLiveRange();
DIAResult<BOOL> isAcceleratorStubFunction();
DIAResult<BOOL> isAggregated();
DIAResult<BOOL> isBaseVirtualFunction();
DIAResult<BOOL> isCVTCIL();
DIAResult<BOOL> isConstructorVirtualBase();
DIAResult<BOOL> isCxxReturnUdt();
DIAResult<BOOL> isDataAligned();
DIAResult<BOOL> isHLSLData();
DIAResult<BOOL> isHotpatchable();
DIAResult<BOOL> isIndirectVirtualBaseClass();
DIAResult<BOOL> isInterfaceUdt();
DIAResult<BOOL> isIntrinsic();
DIAResult<BOOL> isLTCG();
DIAResult<BOOL> isLocationControlFlowDependent();
DIAResult<BOOL> isMSILNetmodule();
DIAResult<BOOL> isManagedRef();
DIAResult<BOOL> isMatrixRowMajor();
DIAResult<BOOL> isMsilRef();
DIAResult<BOOL> isMultipleInheritance();
DIAResult<BOOL> isNaked();
DIAResult<BOOL> isNested();
DIAResult<BOOL> isOptimizedAway();
DIAResult<BOOL> isPacked();
DIAResult<BOOL> isPointerBasedOnSymbolValue();
DIAResult<BOOL> isPointerToDataMember();
DIAResult<BOOL> isPointerToMemberFunction();
DIAResult<BOOL> isPureVirtual();
DIAResult<BOOL> isRValueReference();
DIAResult<BOOL> isRefUdt();
DIAResult<BOOL> isReference();
DIAResult<BOOL> isRestrictedType();
DIAResult<BOOL> isReturnValue();
DIAResult<BOOL> isSafeBuffers();
DIAResult<BOOL> isScoped();
DIAResult<BOOL> isSdl();
DIAResult<BOOL> isSingleInheritance();
DIAResult<BOOL> isSplitted();
DIAResult<BOOL> isStatic();
DIAResult<BOOL> isStripped();
DIAResult<BOOL> isUnalignedType();
DIAResult<BOOL> isUnreached();
DIAResult<BOOL> isValueUdt();
DIAResult<BOOL> isVirtual();
DIAResult<BOOL> isVirtualBaseClass();
DIAResult<BOOL> isVirtualInheritance();
DIAResult<BOOL> isVolatileType();
private:
template <class T, class U = T>
DIAResult<U>
InternalGetDIAValue(HRESULT (__stdcall IDiaSymbol::*Method)(T *)) {
T Value;
if (S_OK == (Symbol->*Method)(&Value))
return DIAResult<U>(U(Value));
else
return DIAResult<U>();
}
DIAResult<DIAString>
InternalGetDIAStringValue(HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) {
BSTR String16;
if (S_OK == (Symbol->*Method)(&String16)) {
std::string String8;
llvm::sys::windows::BSTRToUTF8(String16, String8);
SysFreeString(String16);
return DIAResult<DIAString>(DIAString(String8));
} else
return DIAResult<DIAString>();
}
IDiaSymbol *Symbol;
};
} // namespace windows
} // namespace sys
} // namespace llvm
#endif

104
tools/llvm-pdbdump/llvm-pdbdump.cpp
View File

@ -13,19 +13,7 @@
//
//===----------------------------------------------------------------------===//
#define NTDDI_VERSION NTDDI_VISTA
#define _WIN32_WINNT _WIN32_WINNT_VISTA
#define WINVER _WIN32_WINNT_VISTA
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <atlbase.h>
#include <windows.h>
#include <dia2.h>
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ConvertUTF.h"
@ -36,7 +24,10 @@
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"
#include "llvm-pdbdump.h"
#include "COMExtras.h"
#include "DIAExtras.h"
#include "DIASymbol.h"
using namespace llvm;
using namespace llvm::sys::windows;
@ -54,21 +45,56 @@ cl::opt<bool> StreamData("stream-data",
cl::desc("Dumps stream record data as bytes"));
cl::alias StreamDataShort("S", cl::desc("Alias for --stream-data"),
cl::aliasopt(StreamData));
cl::opt<bool> Tables("tables",
cl::desc("Display summary information for all of the "
"debug tables in the input file"));
cl::alias TablesShort("t", cl::desc("Alias for --tables"),
cl::aliasopt(Tables));
}
namespace {
bool BSTRToUTF8(BSTR String16, std::string &String8) {
UINT ByteLength = ::SysStringByteLen(String16);
char *Bytes = reinterpret_cast<char *>(String16);
String8.clear();
return llvm::convertUTF16ToUTF8String(ArrayRef<char>(Bytes, ByteLength),
String8);
}
static void dumpBasicFileInfo(StringRef Path, IDiaSession *Session) {
CComPtr<IDiaSymbol> GlobalScope;
HRESULT hr = Session->get_globalScope(&GlobalScope);
DIASymbol GlobalScopeSymbol(GlobalScope);
if (S_OK == hr)
GlobalScopeSymbol.getSymbolsFileName().dump("File", 0);
else
outs() << "File: " << Path << "\n";
HANDLE FileHandle = ::CreateFile(
Path.data(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
LARGE_INTEGER FileSize;
if (INVALID_HANDLE_VALUE != FileHandle) {
outs().indent(2);
if (::GetFileSizeEx(FileHandle, &FileSize))
outs() << "Size: " << FileSize.QuadPart << " bytes\n";
else
outs() << "Size: (Unable to obtain file size)\n";
FILETIME ModifiedTime;
outs().indent(2);
if (::GetFileTime(FileHandle, nullptr, nullptr, &ModifiedTime)) {
ULARGE_INTEGER TimeInteger;
TimeInteger.LowPart = ModifiedTime.dwLowDateTime;
TimeInteger.HighPart = ModifiedTime.dwHighDateTime;
llvm::sys::TimeValue Time;
Time.fromWin32Time(TimeInteger.QuadPart);
outs() << "Timestamp: " << Time.str() << "\n";
} else {
outs() << "Timestamp: (Unable to obtain time stamp)\n";
}
::CloseHandle(FileHandle);
}
if (S_OK == hr)
GlobalScopeSymbol.fullDump(2);
outs() << "\n";
outs().flush();
}
static void dumpDataStreams(IDiaSession *session) {
static void dumpDataStreams(IDiaSession *Session) {
CComPtr<IDiaEnumDebugStreams> DebugStreams = nullptr;
if (FAILED(session->getEnumDebugStreams(&DebugStreams)))
if (FAILED(Session->getEnumDebugStreams(&DebugStreams)))
return;
LONG Count = 0;
@ -104,6 +130,34 @@ static void dumpDataStreams(IDiaSession *session) {
}
}
}
outs() << "\n";
outs().flush();
}
static void dumpDebugTables(IDiaSession *Session) {
CComPtr<IDiaEnumTables> EnumTables = nullptr;
if (SUCCEEDED(Session->getEnumTables(&EnumTables))) {
LONG Count = 0;
if (FAILED(EnumTables->get_Count(&Count)))
return;
outs() << "Debug Tables [count=" << Count << "]\n";
std::string Name8;
for (auto Table : make_com_enumerator(EnumTables)) {
BSTR Name16;
if (FAILED(Table->get_name(&Name16)))
continue;
if (BSTRToUTF8(Name16, Name8))
outs() << " " << Name8;
::SysFreeString(Name16);
if (SUCCEEDED(Table->get_Count(&Count))) {
outs() << " [" << Count << " items]\n";
} else
outs() << "\n";
}
}
outs() << "\n";
outs().flush();
}
@ -122,9 +176,15 @@ static void dumpInput(StringRef Path) {
CComPtr<IDiaSession> session;
if (FAILED(source->openSession(&session)))
return;
dumpBasicFileInfo(Path, session);
if (opts::Streams || opts::StreamData) {
dumpDataStreams(session);
}
if (opts::Tables) {
dumpDebugTables(session);
}
}
int main(int argc_, const char *argv_[]) {

32
tools/llvm-pdbdump/llvm-pdbdump.h Normal file
View File

@ -0,0 +1,32 @@
//===- llvm-pdbdump.h - Common includes for llvm-pdbdump --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Common defines and header includes for all llvm-pdbdump. The definitions
// here configure the necessary #defines and include system headers in the
// proper order for using DIA.
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
#define LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
#define NTDDI_VERSION NTDDI_VISTA
#define _WIN32_WINNT _WIN32_WINNT_VISTA
#define WINVER _WIN32_WINNT_VISTA
#ifndef NOMINMAX
#define NOMINMAX
#endif
// atlbase.h has to come before windows.h
#include <atlbase.h>
#include <windows.h>
// DIA headers must come after windows headers.
#include <cvconst.h>
#include <dia2.h>
#endif