[llvm] r227257 - Add support for dumping debug tables to llvm-pdbdump.
Zachary Turner
zturner at google.com
Tue Jan 27 14:40:14 PST 2015
Author: zturner
Date: Tue Jan 27 16:40:14 2015
New Revision: 227257
URL: http://llvm.org/viewvc/llvm-project?rev=227257&view=rev
Log:
Add support for dumping debug tables to llvm-pdbdump.
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.
Added:
llvm/trunk/tools/llvm-pdbdump/DIAExtras.cpp
llvm/trunk/tools/llvm-pdbdump/DIAExtras.h
llvm/trunk/tools/llvm-pdbdump/DIASymbol.cpp
llvm/trunk/tools/llvm-pdbdump/DIASymbol.h
llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h
Modified:
llvm/trunk/tools/llvm-pdbdump/CMakeLists.txt
llvm/trunk/tools/llvm-pdbdump/COMExtras.h
llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp
Modified: llvm/trunk/tools/llvm-pdbdump/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/CMakeLists.txt?rev=227257&r1=227256&r2=227257&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/CMakeLists.txt (original)
+++ llvm/trunk/tools/llvm-pdbdump/CMakeLists.txt Tue Jan 27 16:40:14 2015
@@ -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()
Modified: llvm/trunk/tools/llvm-pdbdump/COMExtras.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/COMExtras.h?rev=227257&r1=227256&r2=227257&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/COMExtras.h (original)
+++ llvm/trunk/tools/llvm-pdbdump/COMExtras.h Tue Jan 27 16:40:14 2015
@@ -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<
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
Added: llvm/trunk/tools/llvm-pdbdump/DIAExtras.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/DIAExtras.cpp?rev=227257&view=auto
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/DIAExtras.cpp (added)
+++ llvm/trunk/tools/llvm-pdbdump/DIAExtras.cpp Tue Jan 27 16:40:14 2015
@@ -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;
+}
Added: llvm/trunk/tools/llvm-pdbdump/DIAExtras.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/DIAExtras.h?rev=227257&view=auto
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/DIAExtras.h (added)
+++ llvm/trunk/tools/llvm-pdbdump/DIAExtras.h Tue Jan 27 16:40:14 2015
@@ -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
Added: llvm/trunk/tools/llvm-pdbdump/DIASymbol.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/DIASymbol.cpp?rev=227257&view=auto
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/DIASymbol.cpp (added)
+++ llvm/trunk/tools/llvm-pdbdump/DIASymbol.cpp Tue Jan 27 16:40:14 2015
@@ -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);
+}
Added: llvm/trunk/tools/llvm-pdbdump/DIASymbol.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/DIASymbol.h?rev=227257&view=auto
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/DIASymbol.h (added)
+++ llvm/trunk/tools/llvm-pdbdump/DIASymbol.h Tue Jan 27 16:40:14 2015
@@ -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
Modified: llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp?rev=227257&r1=227256&r2=227257&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp (original)
+++ llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp Tue Jan 27 16:40:14 2015
@@ -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));
-}
-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);
+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));
}
+
+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
}
}
}
+ 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_[]) {
Added: llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h?rev=227257&view=auto
==============================================================================
--- llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h (added)
+++ llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h Tue Jan 27 16:40:14 2015
@@ -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
\ No newline at end of file
More information about the llvm-commits
mailing list