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.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@227257 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/tools/llvm-pdbdump/CMakeLists.txt b/tools/llvm-pdbdump/CMakeLists.txt
index bc1c0f8c39cffb9205a80c103cfe68b365885e50..49f828cf200839159a458b463d4aa7ab6686b122 100644 (file)
--- a/tools/llvm-pdbdump/CMakeLists.txt
+++ b/tools/llvm-pdbdump/CMakeLists.txt
@@ -21,6 +21,8 @@ if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
 \r
   add_llvm_tool(llvm-pdbdump\r
     llvm-pdbdump.cpp\r
+    DIAExtras.cpp\r
+    DIASymbol.cpp\r
     )\r
   target_link_libraries(llvm-pdbdump diaguids)\r
 endif()\r

diff --git a/tools/llvm-pdbdump/COMExtras.h b/tools/llvm-pdbdump/COMExtras.h
index 7a48ee5887d6d0f19a9f4f1487b6815fde0e2fe7..913d179ce413a1d0de461811a88b705a4da597f7 100644 (file)
--- a/tools/llvm-pdbdump/COMExtras.h
+++ b/tools/llvm-pdbdump/COMExtras.h
@@ -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

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

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

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

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

diff --git a/tools/llvm-pdbdump/llvm-pdbdump.cpp b/tools/llvm-pdbdump/llvm-pdbdump.cpp
index a29f85395d8d6f76a51ae67b685b7d6dc0049fc9..855691ce255b849360955f2094c7d0019f87fec4 100644 (file)
--- a/tools/llvm-pdbdump/llvm-pdbdump.cpp
+++ b/tools/llvm-pdbdump/llvm-pdbdump.cpp
@@ -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 *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_[]) {

diff --git a/tools/llvm-pdbdump/llvm-pdbdump.h b/tools/llvm-pdbdump/llvm-pdbdump.h
new file mode 100644 (file)
index 0000000..c8656a0
--- /dev/null
+++ b/tools/llvm-pdbdump/llvm-pdbdump.h
@@ -0,0 +1,32 @@
+//===- llvm-pdbdump.h - Common includes for llvm-pdbdump --------*- C++ -*-===//\r
+//\r
+//                     The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+// Common defines and header includes for all llvm-pdbdump.  The definitions\r
+// here configure the necessary #defines and include system headers in the\r
+// proper order for using DIA.\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H\r
+#define LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H\r
+\r
+#define NTDDI_VERSION NTDDI_VISTA\r
+#define _WIN32_WINNT _WIN32_WINNT_VISTA\r
+#define WINVER _WIN32_WINNT_VISTA\r
+#ifndef NOMINMAX\r
+#define NOMINMAX\r
+#endif\r
+\r
+// atlbase.h has to come before windows.h\r
+#include <atlbase.h>\r
+#include <windows.h>\r
+\r
+// DIA headers must come after windows headers.\r
+#include <cvconst.h>\r
+#include <dia2.h>\r
+\r
+#endif
\ No newline at end of file