[DebugInfo/PDB] Adding getUndecoratedNameEx and IPDB interfaces for IDiaEnumTables and IDiaTable.

[asmith]

Summary

Initial changes to support debugging PECOFF/PDB files using LLDB through the DIA SDK

[zturner]

Nice! I'm looking forward to reviewing this tomorrow.

I'm adding it for you here, but please include llvm-commits@ as a subscriber in the future. Also check the To/Cc fields on this response when it hits your Inbox. If you don't see llvm-commits@ anywhere, you may need to abandon and re-create this revision (Phabricator can be finnicky)

[zturner]

Looks good, mostly just nitpicks. Can you also add a test for this? We've checked in an several actual PDBs into test/tools/llvm-pdbutil/Inputs, but you'd need to add a command line option to the pretty mode of llvm-pdbutil so that it can dump it. Perhaps making it a hidden option. Hopefully the PDBs that are checked in already will cause DIA to return something interesting for the tables.

include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h

99 ↗

(On Diff #121203)

Can we make this an enum, similar to how we have PDB_NameSearchFlags in this same file.

include/llvm/DebugInfo/PDB/IPDBRawSymbol.h

111 ↗

(On Diff #121203)

enum if possible

include/llvm/DebugInfo/PDB/PDBTypes.h

77–86 ↗

(On Diff #121203)

None of these values are well documented. I'm assuming you understand the format of the content in these tables, so if so would you mind adding a comment before the enumeration? Or if it depends too heavily on the enum value, a comment next to each value.

For example, I can hypothesize that the Symbols contains a chunk of CodeView records, but what does that correspond to in the underlying PDB? Is it literally direct access to the globals stream? or the publics stream? Or something else? Same for line numbers. It would be nice, while you're here, if you could expand a little bit on what people can expect to get out of these tables, because I honestly don't know. There's some vague hints about it here, but this page does not mention InputAssemblyFiles or Dbg at all, so it's unclear what we can expect to find in these tables.

250 ↗

(On Diff #121203)

Can this be a flags enum like PDB_NameSearchFlags instead of some #defines? We also don't need to adhere firmly to the Microsoft definition names, so we can camel-case them in traditional LLVM style.

lib/DebugInfo/PDB/DIA/DIATable.cpp

40 ↗

(On Diff #121203)

Can you do an early return here if it fails? Same with the rest of the cases, we can remove all the elses because each if will just return early.

[asmith]

Changes for style

[asmith]

We'll take a look at what we can do with llvm-pdbutil to test these changes. Right now we are only using publicly available information and I'm not sure I can say much more about what DIA SDK does beyond what you can already see online. I'll ask if there is some better information we can share.

[zturner]

In D39517#926109, @asmith wrote:

We'll take a look at what we can do with llvm-pdbutil to test these changes. Right now we are only using publicly available information and I'm not sure I can say much more about what DIA SDK does beyond what you can already see online. I'll ask if there is some better information we can share.

Sounds fair. I won't block over this for now, so let me look at the changes you made as they are.

Actually I think ignore my comment about the documentation. The contents (as in the internal format) is not documented, but that's obviously for good reason. And anyway, it's not really the internal format that's interesting, it's more the high level "what even is this?" And for that, I think we can figure that out by experimentation. All of these "tables" are really just com interfaces that enumerate something. We can investigate what they enumerate by just experimenting.

[asmith]

There is another set of changes for LLDB coming with lots of unit tests in a week or so. This is the practice code review :)

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIAEnumTables.h

+//===- DIAEnumTables.h - DIA Tables Enumerator Impl -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_DIA_DIAENUMTABLES_H
+#define LLVM_DEBUGINFO_PDB_DIA_DIAENUMTABLES_H
+
+#include "DIASupport.h"
+#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/IPDBTable.h"
+
+namespace llvm {
+namespace pdb {
+class IPDBTable;
+
+class DIAEnumTables : public IPDBEnumChildren<IPDBTable> {
+public:
+  explicit DIAEnumTables(CComPtr<IDiaEnumTables> DiaEnumerator);
+
+  uint32_t getChildCount() const override;
+  std::unique_ptr<IPDBTable> getChildAtIndex(uint32_t Index) const override;
+  std::unique_ptr<IPDBTable> getNext() override;
+  void reset() override;
+  DIAEnumTables *clone() const override;
+
+private:
+  CComPtr<IDiaEnumTables> Enumerator;
+};
+}
+}
+
+#endif // LLVM_DEBUGINFO_PDB_DIA_DIAENUMTABLES_H

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h

public:
   uint64_t getTargetVirtualAddress() const override;
   uint32_t getTargetSection() const override;
   uint32_t getTextureSlot() const override;
   uint32_t getTimeStamp() const override;
   uint32_t getToken() const override;
   uint32_t getTypeId() const override;
   uint32_t getUavSlot() const override;
   std::string getUndecoratedName() const override;
+  std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override;
   uint32_t getUnmodifiedTypeId() const override;
   uint32_t getUpperBoundId() const override;
   Variant getValue() const override;
   uint32_t getVirtualBaseDispIndex() const override;
   uint32_t getVirtualBaseOffset() const override;
   uint32_t getVirtualTableShapeId() const override;
   std::unique_ptr<PDBSymbolTypeBuiltin>
   getVirtualBaseTableType() const override;

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIASession.h

public:
   std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const override;
   std::unique_ptr<IPDBEnumSourceFiles> getSourceFilesForCompiland(
       const PDBSymbolCompiland &Compiland) const override;
   std::unique_ptr<IPDBSourceFile>
   getSourceFileById(uint32_t FileId) const override;
 
   std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const override;
 
+  std::unique_ptr<IPDBEnumTables> getEnumTables() const override;
 private:
   CComPtr<IDiaSession> Session;
 };
 }
 }
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIATable.h

+//===- DIATable.h - DIA implementation of IPDBTable -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_DIA_DIATABLE_H
+#define LLVM_DEBUGINFO_PDB_DIA_DIATABLE_H
+
+#include "DIASupport.h"
+#include "llvm/DebugInfo/PDB/IPDBTable.h"
+
+namespace llvm {
+namespace pdb {
+class DIATable : public IPDBTable {
+public:
+  explicit DIATable(CComPtr<IDiaTable> DiaTable);
+
+  uint32_t getItemCount() const override;
+  std::string getName() const override;
+  PDB_TableType getTableType() const override;
+
+private:
+  CComPtr<IDiaTable> Table;
+};
+}
+}
+
+#endif // LLVM_DEBUGINFO_PDB_DIA_DIATABLE_H

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h

public:
   virtual uint64_t getTargetVirtualAddress() const = 0;
   virtual uint32_t getTargetSection() const = 0;
   virtual uint32_t getTextureSlot() const = 0;
   virtual uint32_t getTimeStamp() const = 0;
   virtual uint32_t getToken() const = 0;
   virtual uint32_t getTypeId() const = 0;
   virtual uint32_t getUavSlot() const = 0;
   virtual std::string getUndecoratedName() const = 0;
+  virtual std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const = 0;
   virtual uint32_t getUnmodifiedTypeId() const = 0;
   virtual uint32_t getUpperBoundId() const = 0;
   virtual Variant getValue() const = 0;
   virtual uint32_t getVirtualBaseDispIndex() const = 0;
   virtual uint32_t getVirtualBaseOffset() const = 0;
   virtual std::unique_ptr<PDBSymbolTypeBuiltin>
   getVirtualBaseTableType() const = 0;
   virtual uint32_t getVirtualTableShapeId() const = 0;

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h

public:
 
   virtual std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const = 0;
   virtual std::unique_ptr<IPDBEnumSourceFiles>
   getSourceFilesForCompiland(const PDBSymbolCompiland &Compiland) const = 0;
   virtual std::unique_ptr<IPDBSourceFile>
   getSourceFileById(uint32_t FileId) const = 0;
 
   virtual std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const = 0;
+
+  virtual std::unique_ptr<IPDBEnumTables> getEnumTables() const = 0;
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBTable.h

+//===- IPDBTable.h - Base Interface for a PDB Symbol Context ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_IPDBTABLE_H
+#define LLVM_DEBUGINFO_PDB_IPDBTABLE_H
+
+#include "PDBTypes.h"
+
+namespace llvm {
+namespace pdb {
+class IPDBTable {
+public:
+  virtual ~IPDBTable();
+
+  virtual std::string getName() const = 0;
+  virtual uint32_t getItemCount() const = 0;
+  virtual PDB_TableType getTableType() const = 0;
+};
+}
+}
+
+#endif // LLVM_DEBUGINFO_PDB_IPDBTABLE_H

llvm/trunk/include/llvm/DebugInfo/PDB/Native/NativeRawSymbol.h

public:
   uint64_t getTargetVirtualAddress() const override;
   uint32_t getTargetSection() const override;
   uint32_t getTextureSlot() const override;
   uint32_t getTimeStamp() const override;
   uint32_t getToken() const override;
   uint32_t getTypeId() const override;
   uint32_t getUavSlot() const override;
   std::string getUndecoratedName() const override;
+  std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override;
   uint32_t getUnmodifiedTypeId() const override;
   uint32_t getUpperBoundId() const override;
   Variant getValue() const override;
   uint32_t getVirtualBaseDispIndex() const override;
   uint32_t getVirtualBaseOffset() const override;
   uint32_t getVirtualTableShapeId() const override;
   std::unique_ptr<PDBSymbolTypeBuiltin>
   getVirtualBaseTableType() const override;

llvm/trunk/include/llvm/DebugInfo/PDB/Native/NativeSession.h

public:
   std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const override;
   std::unique_ptr<IPDBEnumSourceFiles> getSourceFilesForCompiland(
       const PDBSymbolCompiland &Compiland) const override;
   std::unique_ptr<IPDBSourceFile>
   getSourceFileById(uint32_t FileId) const override;
 
   std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const override;
 
+  std::unique_ptr<IPDBEnumTables> getEnumTables() const override;
+
   PDBFile &getPDBFile() { return *Pdb; }
   const PDBFile &getPDBFile() const { return *Pdb; }
 
 private:
   std::unique_ptr<PDBFile> Pdb;
   std::unique_ptr<BumpPtrAllocator> Allocator;
   std::vector<std::unique_ptr<NativeRawSymbol>> SymbolCache;
   DenseMap<codeview::TypeIndex, SymIndexId> TypeIndexToSymbolId;
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h

 #include <functional>
 
 namespace llvm {
 namespace pdb {
 
 class IPDBDataStream;
 class IPDBLineNumber;
 class IPDBSourceFile;
+class IPDBTable;
 class PDBSymDumper;
 class PDBSymbol;
 class PDBSymbolExe;
 class PDBSymbolCompiland;
 class PDBSymbolCompilandDetails;
 class PDBSymbolCompilandEnv;
 class PDBSymbolFunc;
 class PDBSymbolBlock;

 class PDBSymbolTypeManaged;
 class PDBSymbolTypeDimension;
 class PDBSymbolUnknown;
 
 using IPDBEnumSymbols = IPDBEnumChildren<PDBSymbol>;
 using IPDBEnumSourceFiles = IPDBEnumChildren<IPDBSourceFile>;
 using IPDBEnumDataStreams = IPDBEnumChildren<IPDBDataStream>;
 using IPDBEnumLineNumbers = IPDBEnumChildren<IPDBLineNumber>;
+using IPDBEnumTables = IPDBEnumChildren<IPDBTable>;
 
 /// Specifies which PDB reader implementation is to be used.  Only a value
 /// of PDB_ReaderType::DIA is currently supported, but Native is in the works.
 enum class PDB_ReaderType {
   DIA = 0,
   Native = 1,
 };
 
 /// An enumeration indicating the type of data contained in this table.
 enum class PDB_TableType {
+  TableInvalid = 0,
   Symbols,
   SourceFiles,
   LineNumbers,
   SectionContribs,
   Segments,
   InjectedSources,
-  FrameData
+  FrameData,
+  InputAssemblyFiles,
+  Dbg
 };
 
 /// Defines flags used for enumerating child symbols.  This corresponds to the
 /// NameSearchOptions enumeration which is documented here:
 /// https://msdn.microsoft.com/en-us/library/yat28ads.aspx
 enum PDB_NameSearchFlags {
   NS_Default = 0x0,
   NS_CaseSensitive = 0x1,
enum class PDB_BuiltinType {
   Date = 26,
   Variant = 27,
   Complex = 28,
   Bitfield = 29,
   BSTR = 30,
   HResult = 31
 };
 
+/// These values correspond to the flags that can be combined to control the
+/// return of an undecorated name for a C++ decorated name, and are documented
+/// here: https://msdn.microsoft.com/en-us/library/kszfk0fs.aspx
+enum PDB_UndnameFlags: uint32_t {
+  Undname_Complete = 0x0,
+  Undname_NoLeadingUnderscores = 0x1,
+  Undname_NoMsKeywords = 0x2,
+  Undname_NoFuncReturns = 0x4,
+  Undname_NoAllocModel = 0x8,
+  Undname_NoAllocLang = 0x10,
+  Undname_Reserved1 = 0x20,
+  Undname_Reserved2 = 0x40,
+  Undname_NoThisType = 0x60,
+  Undname_NoAccessSpec = 0x80,
+  Undname_NoThrowSig = 0x100,
+  Undname_NoMemberType = 0x200,
+  Undname_NoReturnUDTModel = 0x400,
+  Undname_32BitDecode = 0x800,
+  Undname_NameOnly = 0x1000,
+  Undname_TypeOnly = 0x2000,
+  Undname_HaveParams = 0x4000,
+  Undname_NoECSU = 0x8000,
+  Undname_NoIdentCharCheck = 0x10000,
+  Undname_NoPTR64 = 0x20000
+};
+
 enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 };
 
 struct VersionInfo {
   uint32_t Major;
   uint32_t Minor;
   uint32_t Build;
   uint32_t QFE;
 };

llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt

if(LLVM_ENABLE_DIA_SDK)
   file(TO_CMAKE_PATH "${LIBPDB_LINK_FOLDERS}\\diaguids.lib" LIBPDB_ADDITIONAL_LIBRARIES)
 
   add_pdb_impl_folder(DIA
     DIA/DIADataStream.cpp
     DIA/DIAEnumDebugStreams.cpp
     DIA/DIAEnumLineNumbers.cpp
     DIA/DIAEnumSourceFiles.cpp
     DIA/DIAEnumSymbols.cpp
+    DIA/DIAEnumTables.cpp
     DIA/DIAError.cpp
     DIA/DIALineNumber.cpp
     DIA/DIARawSymbol.cpp
     DIA/DIASession.cpp
     DIA/DIASourceFile.cpp
+    DIA/DIATable.cpp
     )
 
     set(LIBPDB_ADDITIONAL_HEADER_DIRS "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/PDB/DIA")
 endif()
 
 add_pdb_impl_folder(Native
   Native/DbiModuleDescriptor.cpp
   Native/DbiModuleDescriptorBuilder.cpp

llvm/trunk/lib/DebugInfo/PDB/DIA/DIAEnumTables.cpp

+//===- DIAEnumTables.cpp - DIA Table Enumerator Impl ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/PDB/DIA/DIAEnumTables.h"
+#include "llvm/DebugInfo/PDB/DIA/DIATable.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+
+DIAEnumTables::DIAEnumTables(
+  CComPtr<IDiaEnumTables> DiaEnumerator)
+  : Enumerator(DiaEnumerator) {}
+
+uint32_t DIAEnumTables::getChildCount() const {
+  LONG Count = 0;
+  return (S_OK == Enumerator->get_Count(&Count)) ? Count : 0;
+}
+
+std::unique_ptr<IPDBTable>
+DIAEnumTables::getChildAtIndex(uint32_t Index) const {
+  CComPtr<IDiaTable> Item;
+  VARIANT Var;
+  Var.vt = VT_UINT;
+  Var.uintVal = Index;
+  if (S_OK != Enumerator->Item(Var, &Item))
+    return nullptr;
+
+  return std::unique_ptr<IPDBTable>(new DIATable(Item));
+}
+
+std::unique_ptr<IPDBTable> DIAEnumTables::getNext() {
+  CComPtr<IDiaTable> Item;
+  ULONG CeltFetched = 0;
+  if (S_OK != Enumerator->Next(1, &Item, &CeltFetched))
+    return nullptr;
+
+  return std::unique_ptr<IPDBTable>(new DIATable(Item));
+}
+
+void DIAEnumTables::reset() { Enumerator->Reset(); }
+
+DIAEnumTables *DIAEnumTables::clone() const {
+  CComPtr<IDiaEnumTables> EnumeratorClone;
+  if (S_OK != Enumerator->Clone(&EnumeratorClone))
+    return nullptr;
+  return new DIAEnumTables(EnumeratorClone);
+}

llvm/trunk/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp

void DIARawSymbol::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const {
   Symbol->get_dataBytes(0, &DataSize, nullptr);
   if (DataSize == 0)
     return;
 
   bytes.resize(DataSize);
   Symbol->get_dataBytes(DataSize, &DataSize, bytes.data());
 }
 
+std::string
+DIARawSymbol::getUndecoratedNameEx(PDB_UndnameFlags Flags) const {
+  CComBSTR Result16;
+  if (S_OK != Symbol->get_undecoratedNameEx((DWORD)Flags, &Result16))
+    return std::string();
+
+  const char *SrcBytes = reinterpret_cast<const char *>(Result16.m_str);
+  llvm::ArrayRef<char> SrcByteArray(SrcBytes, Result16.ByteLength());
+  std::string Result8;
+  if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8))
+    return std::string();
+  return Result8;
+}
+
 PDB_MemberAccess DIARawSymbol::getAccess() const {
   return PrivateGetDIAValue<DWORD, PDB_MemberAccess>(Symbol,
                                                      &IDiaSymbol::get_access);
 }
 
 uint32_t DIARawSymbol::getAddressOffset() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressOffset);
 }

llvm/trunk/lib/DebugInfo/PDB/DIA/DIASession.cpp

 //===- DIASession.cpp - DIA implementation of IPDBSession -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/DebugInfo/PDB/DIA/DIASession.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/PDB/DIA/DIAEnumDebugStreams.h"
 #include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h"
 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSourceFiles.h"
+#include "llvm/DebugInfo/PDB/DIA/DIAEnumTables.h"
 #include "llvm/DebugInfo/PDB/DIA/DIAError.h"
 #include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"
 #include "llvm/DebugInfo/PDB/DIA/DIASourceFile.h"
 #include "llvm/DebugInfo/PDB/DIA/DIASupport.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"

 
 std::unique_ptr<IPDBEnumDataStreams> DIASession::getDebugStreams() const {
   CComPtr<IDiaEnumDebugStreams> DiaEnumerator;
   if (S_OK != Session->getEnumDebugStreams(&DiaEnumerator))
     return nullptr;
 
   return llvm::make_unique<DIAEnumDebugStreams>(DiaEnumerator);
 }
+
+std::unique_ptr<IPDBEnumTables> DIASession::getEnumTables() const {
+  CComPtr<IDiaEnumTables> DiaEnumerator;
+  if (S_OK != Session->getEnumTables(&DiaEnumerator))
+    return nullptr;
+
+  return llvm::make_unique<DIAEnumTables>(DiaEnumerator);
+}

llvm/trunk/lib/DebugInfo/PDB/DIA/DIATable.cpp

+//===- DIATable.cpp - DIA implementation of IPDBTable -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/PDB/DIA/DIATable.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/ConvertUTF.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+
+DIATable::DIATable(CComPtr<IDiaTable> DiaTable)
+  : Table(DiaTable) {}
+
+uint32_t DIATable::getItemCount() const {
+  LONG Count = 0;
+  return (S_OK == Table->get_Count(&Count)) ? Count : 0;
+}
+
+std::string DIATable::getName() const {
+  CComBSTR Name16;
+  if (S_OK != Table->get_name(&Name16))
+    return std::string();
+
+  std::string Name8;
+  llvm::ArrayRef<char> Name16Bytes(reinterpret_cast<char *>(Name16.m_str),
+                                   Name16.ByteLength());
+  if (!llvm::convertUTF16ToUTF8String(Name16Bytes, Name8))
+    return std::string();
+  return Name8;
+}
+
+PDB_TableType DIATable::getTableType() const {
+  CComBSTR Name16;
+  if (S_OK != Table->get_name(&Name16))
+    return PDB_TableType::TableInvalid;
+
+  if (Name16 == DiaTable_Symbols)
+    return PDB_TableType::Symbols;
+  if (Name16 == DiaTable_SrcFiles)
+    return PDB_TableType::SourceFiles;
+  if (Name16 == DiaTable_Sections)
+    return PDB_TableType::SectionContribs;
+  if (Name16 == DiaTable_LineNums)
+    return PDB_TableType::LineNumbers;
+  if (Name16 == DiaTable_SegMap)
+    return PDB_TableType::Segments;
+  if (Name16 == DiaTable_InjSrc)
+    return PDB_TableType::InjectedSources;
+  if (Name16 == DiaTable_FrameData)
+    return PDB_TableType::FrameData;
+  if (Name16 == DiaTable_InputAssemblyFiles)
+    return PDB_TableType::InputAssemblyFiles;
+  if (Name16 == DiaTable_Dbg)
+    return PDB_TableType::Dbg;
+}

llvm/trunk/lib/DebugInfo/PDB/Native/NativeRawSymbol.cpp

 uint32_t NativeRawSymbol::getUavSlot() const {
   return 0;
 }
 
 std::string NativeRawSymbol::getUndecoratedName() const {
   return {};
 }
 
+std::string NativeRawSymbol::getUndecoratedNameEx(
+    PDB_UndnameFlags Flags) const {
+  return {};
+}
+
 uint32_t NativeRawSymbol::getUnmodifiedTypeId() const {
   return 0;
 }
 
 uint32_t NativeRawSymbol::getUpperBoundId() const {
   return 0;
 }
 

llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp

 std::unique_ptr<IPDBSourceFile>
 NativeSession::getSourceFileById(uint32_t FileId) const {
   return nullptr;
 }
 
 std::unique_ptr<IPDBEnumDataStreams> NativeSession::getDebugStreams() const {
   return nullptr;
 }
+
+std::unique_ptr<IPDBEnumTables> NativeSession::getEnumTables() const {
+  return nullptr;
+}

llvm/trunk/lib/DebugInfo/PDB/PDBInterfaceAnchors.cpp

 // the vtable is only generated in this object file, and not in every object
 // file that incldues the corresponding header.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/IPDBDataStream.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
+#include "llvm/DebugInfo/PDB/IPDBTable.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 IPDBSession::~IPDBSession() = default;
 
 IPDBDataStream::~IPDBDataStream() = default;
 
 IPDBRawSymbol::~IPDBRawSymbol() = default;
 
 IPDBLineNumber::~IPDBLineNumber() = default;
+
+IPDBTable::~IPDBTable() = default;

llvm/trunk/unittests/DebugInfo/PDB/PDBApiTest.cpp

 //===- llvm/unittest/DebugInfo/PDB/PDBApiTest.cpp -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <unordered_map>
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
+#include "llvm/DebugInfo/PDB/IPDBTable.h"
 
 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolAnnotation.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
class MockSession : public IPDBSession {
   std::unique_ptr<IPDBEnumSourceFiles> getSourceFilesForCompiland(
       const PDBSymbolCompiland &Compiland) const override {
     return nullptr;
   }
 
   std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const override {
     return nullptr;
   }
+
+  std::unique_ptr<IPDBEnumTables> getEnumTables() const override {
+    return nullptr;
+  }
 };
 
 class MockRawSymbol : public IPDBRawSymbol {
 public:
   MockRawSymbol(PDB_SymType SymType)
       : Type(SymType) {}
 
   void dump(raw_ostream &OS, int Indent) const override {}
public:
   }
 
   void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const override {}
   void getFrontEndVersion(VersionInfo &Version) const override {}
   void getBackEndVersion(VersionInfo &Version) const override {}
 
   PDB_SymType getSymTag() const override { return Type; }
 
+  std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override {
+    return {};
+  }
+
   MOCK_SYMBOL_ACCESSOR(getAccess)
   MOCK_SYMBOL_ACCESSOR(getAddressOffset)
   MOCK_SYMBOL_ACCESSOR(getAddressSection)
   MOCK_SYMBOL_ACCESSOR(getAge)
   MOCK_SYMBOL_ACCESSOR(getArrayIndexTypeId)
   MOCK_SYMBOL_ACCESSOR(getBaseDataOffset)
   MOCK_SYMBOL_ACCESSOR(getBaseDataSlot)
   MOCK_SYMBOL_ACCESSOR(getBaseSymbolId)