[PDB] Add the ability to resolve forward references

[zturner]

Summary

Some records point to an LF_CLASS, LF_UNION, LF_STRUCTURE, or LF_ENUM which is a forward reference and doesn't contain complete debug information. In these cases, we'd like to be able to quickly locate the full record. The TPI stream stores an array of pre-computed record hash values, one for each type record. If we pre-process this on startup, we can build a mapping from hash value -> {list of possible matching type indices}. Since hashes of full records are only based on the name and or unique name and not the full record contents, we can then use forward ref record to compute the hash of what *would* be the full record by just hashing the name, use this to get the list of possible matches, and iterate those looking for a match on name or unique name.

llvm-pdbutil is updated to resolve forward references for the purposes of testing (plus it's just useful).

[zturner]

Remove the exe and obj file.

[zturner]

This was originally a combination of several patches which I tried to split up into smaller functionality. Apparently I didn't do a very good job. Removed a bunch of code that shouldn't have been in this patch.

[rnk]

llvm/include/llvm/DebugInfo/PDB/Native/TpiHashing.h

60

You will probably have to name the union field for this to build with all supported compilers.

llvm/include/llvm/DebugInfo/PDB/Native/TpiStream.h

87

Nested C++ containers don't usually perform the best. Here come some obnoxious data structure micro-optimization suggestions down below!

llvm/lib/DebugInfo/PDB/Native/TpiStream.cpp

146

How about this:

1. Allocate an array of TypeIndex of size TypeIndexEnd - TypeIndexBegin, i.e. an array of all the type indices in the hash table.
2. Make HashMap a std::vector<std::pair<unsigned, unsigned>>, where these are begin/end indices of ranges into the previous array. We can write a helper that takes a hash value and returns an ArrayRef<TypeIndex> using these two arrays.
3. Build a temporary array of pairs of HashValue+TypeIndex, and sort it by hash value.
4. Iterate over the sorted array of hash values and type indices. Push each type index onto the array. When the hash value changes, store a pair of begin/end indices for the type indices that share this hash code into the HashMap.

157

If HV >= Header->NumHashBuckets, I would report an error or just drop the type. We could hash the type ourselves as a recovery, but it's a corrupt input file, anything but UB or crashing works.

[zturner]

It’s true that nested containers don’t usually perform well, but in this
case the outer vector *never* resizes. So it seems like it should be ok?

[rnk]

In D52283#1239983, @zturner wrote:

It’s true that nested containers don’t usually perform well, but in this
case the outer vector *never* resizes. So it seems like it should be ok?

I'd be fine with the simple code, sure. We want the PDB to load fast, though, being cache friendly is the best way to do that, IMO. :)

[zturner]

I can probably also just use the pdb::HashTable class where the key is the
actual hash value. I’ll go with the vector first since it’s simple and
obviously correct then try to change it to something more efficient in a
followup

llvm/include/llvm/DebugInfo/CodeView/TypeIndexDiscovery.h

 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
+
+class TypeCollection;
+
 enum class TiRefKind { TypeRef, IndexRef };
 struct TiReference {
   TiRefKind Kind;
   uint32_t Offset;
   uint32_t Count;
 };
 
 void discoverTypeIndices(ArrayRef<uint8_t> RecordData,
                          SmallVectorImpl<TiReference> &Refs);
 void discoverTypeIndices(const CVType &Type,
                          SmallVectorImpl<TiReference> &Refs);
 void discoverTypeIndices(const CVType &Type,
                          SmallVectorImpl<TypeIndex> &Indices);
 void discoverTypeIndices(ArrayRef<uint8_t> RecordData,
                          SmallVectorImpl<TypeIndex> &Indices);
 
 /// Discover type indices in symbol records. Returns false if this is an unknown
 /// record.
 bool discoverTypeIndicesInSymbol(const CVSymbol &Symbol,
                                  SmallVectorImpl<TiReference> &Refs);
 bool discoverTypeIndicesInSymbol(ArrayRef<uint8_t> RecordData,
                                  SmallVectorImpl<TiReference> &Refs);
 bool discoverTypeIndicesInSymbol(ArrayRef<uint8_t> RecordData,
                                  SmallVectorImpl<TypeIndex> &Indices);
+
+bool isForwardRef(CVType CVT);
+Optional<TypeIndex> findFullDeclForForwardRef(TypeIndex ForwardTI,
+                                              TypeCollection &Types);
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/HashTable.h

 template <typename T> struct PdbHashTraits {};
 
 template <> struct PdbHashTraits<uint32_t> {
   uint32_t hashLookupKey(uint32_t N) const { return N; }
   uint32_t storageKeyToLookupKey(uint32_t N) const { return N; }
   uint32_t lookupKeyToStorageKey(uint32_t N) { return N; }
 };
 
+template <> struct PdbHashTraits<support::ulittle32_t> {
+  support::ulittle32_t hashLookupKey(uint32_t N) const {
+    return support::ulittle32_t{N};
+  }
+  support::ulittle32_t storageKeyToLookupKey(uint32_t N) const {
+    return support::ulittle32_t{N};
+  }
+  support::ulittle32_t lookupKeyToStorageKey(uint32_t N) {
+    return support::ulittle32_t{N};
+  }
+};
+
 template <typename ValueT, typename TraitsT = PdbHashTraits<ValueT>>
 class HashTable {
   using iterator = HashTableIterator<ValueT, TraitsT>;
   friend iterator;
 
   struct Header {
     support::ulittle32_t Size;
     support::ulittle32_t Capacity;

llvm/include/llvm/DebugInfo/PDB/Native/RawTypes.h

struct SrcHeaderBlockEntry {
   support::ulittle32_t ObjNI;    // String table index of object name.
   support::ulittle32_t VFileNI;  // String table index of virtual file name.
   uint8_t Compression;           // PDB_SourceCompression enumeration.
   uint8_t IsVirtual;             // Is this a virtual file (injected)?
   short Padding;                 // Pad to 4 bytes.
   char Reserved[8];
 };
 
-constexpr int I = sizeof(SrcHeaderBlockEntry);
 static_assert(sizeof(SrcHeaderBlockEntry) == 40, "Incorrect struct size!");
 
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/TpiHashing.h

 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 
 Expected<uint32_t> hashTypeRecord(const llvm::codeview::CVType &Type);
 
+struct TagRecordHash {
+  explicit TagRecordHash(codeview::ClassRecord CR, uint32_t Full,
+                         uint32_t Forward)
+      : Class(std::move(CR)), FullRecordHash(Full), ForwardDeclHash(Forward) {
+    State = 0;
+  }
+
+  explicit TagRecordHash(codeview::EnumRecord ER, uint32_t Full,
+                         uint32_t Forward)
+      : Enum(std::move(ER)), FullRecordHash(Full), ForwardDeclHash(Forward) {
+    State = 1;
+  }
+
+  explicit TagRecordHash(codeview::UnionRecord UR, uint32_t Full,
+                         uint32_t Forward)
+      : Union(std::move(UR)), FullRecordHash(Full), ForwardDeclHash(Forward) {
+    State = 2;
+  }
+
+  uint32_t FullRecordHash;
+  uint32_t ForwardDeclHash;
+
+  codeview::TagRecord &getRecord() {
+    switch (State) {
+    case 0:
+      return Class;
+    case 1:
+      return Enum;
+    case 2:
+      return Union;
+    }
+    llvm_unreachable("unreachable!");
+  }
+
+private:
+  union {
+    codeview::ClassRecord Class;
+    codeview::EnumRecord Enum;
+    codeview::UnionRecord Union;
+  };
+
+  uint8_t State = 0;
+};
+
+/// Given a CVType referring to a class, structure, union, or enum, compute
+/// the hash of its forward decl and full decl.
+Expected<TagRecordHash> hashTagRecord(const codeview::CVType &Type);
+
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_TPIHASHING_H

llvm/include/llvm/DebugInfo/PDB/Native/TpiStream.h

public:
   FixedStreamArray<codeview::TypeIndexOffset> getTypeIndexOffsets() const;
   HashTable<support::ulittle32_t> &getHashAdjusters();
 
   codeview::CVTypeRange types(bool *HadError) const;
   const codeview::CVTypeArray &typeArray() const { return TypeRecords; }
 
   codeview::LazyRandomTypeCollection &typeCollection() { return *Types; }
 
+  Expected<codeview::TypeIndex>
+  findFullDeclForForwardRef(codeview::TypeIndex ForwardRefTI) const;
+
   BinarySubstreamRef getTypeRecordsSubstream() const;
 
   Error commit();
 
+  void buildHashMap();
+
+  bool supportsTypeLookup() const;
+
 private:
   PDBFile &Pdb;
   std::unique_ptr<msf::MappedBlockStream> Stream;
 
   std::unique_ptr<codeview::LazyRandomTypeCollection> Types;
 
   BinarySubstreamRef TypeRecordsSubstream;
 
   codeview::CVTypeArray TypeRecords;
 
   std::unique_ptr<BinaryStream> HashStream;
   FixedStreamArray<support::ulittle32_t> HashValues;
   FixedStreamArray<codeview::TypeIndexOffset> TypeIndexOffsets;
   HashTable<support::ulittle32_t> HashAdjusters;
 
+  std::vector<std::vector<codeview::TypeIndex>> HashMap;
+
   const TpiStreamHeader *Header;
 };
 }
 }
 
 #endif

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

 class raw_ostream;
 
 namespace pdb {
 
 using TagStats = std::unordered_map<PDB_SymType, int>;
 
 raw_ostream &operator<<(raw_ostream &OS, const PDB_VariantType &Value);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_CallingConv &Conv);
+raw_ostream &operator<<(raw_ostream &OS, const PDB_BuiltinType &Type);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_DataKind &Data);
 raw_ostream &operator<<(raw_ostream &OS, const codeview::RegisterId &Reg);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_LocType &Loc);
 raw_ostream &operator<<(raw_ostream &OS, const codeview::ThunkOrdinal &Thunk);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_Checksum &Checksum);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_Lang &Lang);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_SymType &Tag);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_MemberAccess &Access);

llvm/lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp

 //===- TypeIndexDiscovery.cpp -----------------------------------*- 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/CodeView/TypeIndexDiscovery.h"
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/DebugInfo/CodeView/TypeCollection.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 static inline MethodKind getMethodKind(uint16_t Attrs) {
   Attrs &= uint16_t(MethodOptions::MethodKindMask);
   Attrs >>= 2;

 bool llvm::codeview::discoverTypeIndicesInSymbol(
     ArrayRef<uint8_t> RecordData, SmallVectorImpl<TypeIndex> &Indices) {
   SmallVector<TiReference, 2> Refs;
   if (!discoverTypeIndicesInSymbol(RecordData, Refs))
     return false;
   resolveTypeIndexReferences(RecordData, Refs, Indices);
   return true;
 }
+
+static bool isTagType(const CVType &CVT) {
+  switch (CVT.kind()) {
+  case LF_CLASS:
+  case LF_STRUCTURE:
+  case LF_INTERFACE:
+  case LF_UNION:
+  case LF_ENUM:
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool llvm::codeview::isForwardRef(CVType CVT) {
+  switch (CVT.kind()) {
+  case LF_CLASS:
+  case LF_STRUCTURE:
+  case LF_INTERFACE: {
+    ClassRecord CR;
+    cantFail(TypeDeserializer::deserializeAs<ClassRecord>(CVT, CR));
+    return CR.isForwardRef();
+  }
+  case LF_UNION: {
+    UnionRecord UR;
+    cantFail(TypeDeserializer::deserializeAs<UnionRecord>(CVT, UR));
+    return UR.isForwardRef();
+  }
+  case LF_ENUM: {
+    EnumRecord ER;
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(CVT, ER));
+    return ER.isForwardRef();
+  }
+  default:
+    return false;
+  }
+}
+
+static std::string getUniqueName(CVType CVT) {
+  switch (CVT.kind()) {
+  case LF_CLASS:
+  case LF_STRUCTURE:
+  case LF_INTERFACE: {
+    ClassRecord CR;
+    cantFail(TypeDeserializer::deserializeAs<ClassRecord>(CVT, CR));
+    return CR.UniqueName;
+  }
+  case LF_UNION: {
+    UnionRecord UR;
+    cantFail(TypeDeserializer::deserializeAs<UnionRecord>(CVT, UR));
+    return UR.UniqueName;
+  }
+  case LF_ENUM: {
+    EnumRecord ER;
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(CVT, ER));
+    return ER.UniqueName;
+  }
+  default:
+    return {};
+  }
+}
+
+Optional<TypeIndex>
+llvm::codeview::findFullDeclForForwardRef(TypeIndex ForwardTI,
+                                          TypeCollection &Types) {
+  assert(Types.contains(ForwardTI));
+
+  CVType CVT = Types.getType(ForwardTI);
+  assert(isTagType(CVT) && "TypeIndex is not a tag type!");
+
+  if (!isForwardRef(CVT))
+    return ForwardTI;
+
+  // Stash the unique name in the forward decl and scan forward until we find
+  // another type with the same leaf kind and unique name.
+  std::string UniqueName = getUniqueName(CVT);
+
+  Optional<TypeIndex> TI{ForwardTI};
+  while (TI) {
+    CVType Candidate = Types.getType(*TI);
+    if (Candidate.kind() == CVT.kind() && !isForwardRef(Candidate) &&
+        UniqueName == getUniqueName(Candidate))
+      return *TI;
+    TI = Types.getNext(*TI);
+  }
+  return None;
+}

llvm/lib/DebugInfo/PDB/Native/TpiHashing.cpp

static Expected<uint32_t> getHashForUdt(const CVType &Rec) {
   T Deserialized;
   if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
                                                Deserialized))
     return std::move(E);
   return getHashForUdt(Deserialized, Rec.data());
 }
 
 template <typename T>
+static Expected<TagRecordHash> getTagRecordHashForUdt(const CVType &Rec) {
+  T Deserialized;
+  if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
+                                               Deserialized))
+    return std::move(E);
+
+  ClassOptions Opts = Deserialized.getOptions();
+
+  bool ForwardRef = bool(Opts & ClassOptions::ForwardReference);
+
+  uint32_t ThisRecordHash = getHashForUdt(Deserialized, Rec.data());
+
+  // If we don't have a forward ref we can't compute the hash of it from the
+  // full record because it requires hashing the entire buffer.
+  if (!ForwardRef)
+    return TagRecordHash{std::move(Deserialized), ThisRecordHash, 0};
+
+  bool Scoped = bool(Opts & ClassOptions::Scoped);
+
+  StringRef NameToHash =
+      Scoped ? Deserialized.getUniqueName() : Deserialized.getName();
+  uint32_t FullHash = hashStringV1(NameToHash);
+  return TagRecordHash{std::move(Deserialized), FullHash, ThisRecordHash};
+}
+
+template <typename T>
 static Expected<uint32_t> getSourceLineHash(const CVType &Rec) {
   T Deserialized;
   if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
                                                Deserialized))
     return std::move(E);
   char Buf[4];
   support::endian::write32le(Buf, Deserialized.getUDT().getIndex());
   return hashStringV1(StringRef(Buf, 4));
 }
 
+Expected<TagRecordHash> llvm::pdb::hashTagRecord(const codeview::CVType &Type) {
+  switch (Type.kind()) {
+  case LF_CLASS:
+  case LF_STRUCTURE:
+  case LF_INTERFACE:
+    return getTagRecordHashForUdt<ClassRecord>(Type);
+  case LF_UNION:
+    return getTagRecordHashForUdt<UnionRecord>(Type);
+  case LF_ENUM:
+    return getTagRecordHashForUdt<EnumRecord>(Type);
+  default:
+    assert(false && "Type is not a tag record!");
+  }
+  return make_error<StringError>("Invalid record type",
+                                 inconvertibleErrorCode());
+}
+
 Expected<uint32_t> llvm::pdb::hashTypeRecord(const CVType &Rec) {
   switch (Rec.kind()) {
   case LF_CLASS:
   case LF_STRUCTURE:
   case LF_INTERFACE:
     return getHashForUdt<ClassRecord>(Rec);
   case LF_UNION:
     return getHashForUdt<UnionRecord>(Rec);

llvm/lib/DebugInfo/PDB/Native/TpiStream.cpp

 //===- TpiStream.cpp - PDB Type Info (TPI) Stream 2 Access ----------------===//
 //
 //                     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/Native/TpiStream.h"
 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
+#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
+#include "llvm/DebugInfo/PDB/Native/Hash.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"

 
 uint16_t TpiStream::getTypeHashStreamAuxIndex() const {
   return Header->HashAuxStreamIndex;
 }
 
 uint32_t TpiStream::getNumHashBuckets() const { return Header->NumHashBuckets; }
 uint32_t TpiStream::getHashKeySize() const { return Header->HashKeySize; }
 
+void TpiStream::buildHashMap() {
+  if (!HashMap.empty())
+    return;
+  if (HashValues.empty())
+    return;
+
+  HashMap.resize(Header->NumHashBuckets);
+
+  TypeIndex TIB{Header->TypeIndexBegin};
+  TypeIndex TIE{Header->TypeIndexEnd};
+  while (TIB < TIE) {
+    uint32_t HV = HashValues[TIB.toArrayIndex()];
+    HashMap[HV].push_back(TIB++);
+  }
+}
+
+bool TpiStream::supportsTypeLookup() const { return !HashMap.empty(); }
+
+Expected<TypeIndex>
+TpiStream::findFullDeclForForwardRef(TypeIndex ForwardRefTI) const {
+  CVType F = Types->getType(ForwardRefTI);
+  if (!isForwardRef(F))
+    return ForwardRefTI;
+
+  Expected<TagRecordHash> ForwardTRH = hashTagRecord(F);
+  if (!ForwardTRH)
+    return ForwardTRH.takeError();
+
+  TagRecordHash Copy = std::move(*ForwardTRH);
+  uint32_t BucketIdx = ForwardTRH->FullRecordHash % Header->NumHashBuckets;
+
+  for (TypeIndex TI : HashMap[BucketIdx]) {
+    CVType CVT = Types->getType(TI);
+    if (CVT.kind() != F.kind())
+      continue;
+
+    Expected<TagRecordHash> FullTRH = hashTagRecord(CVT);
+    if (!FullTRH)
+      return FullTRH.takeError();
+    if (ForwardTRH->FullRecordHash != FullTRH->FullRecordHash)
+      continue;
+    TagRecord &ForwardTR = ForwardTRH->getRecord();
+    TagRecord &FullTR = FullTRH->getRecord();
+
+    if (!ForwardTR.hasUniqueName()) {
+      if (ForwardTR.getName() == FullTR.getName())
+        return TI;
+      continue;
+    }
+
+    if (!FullTR.hasUniqueName())
+      continue;
+    if (ForwardTR.getUniqueName() == FullTR.getUniqueName())
+      return TI;
+  }
+  return ForwardRefTI;
+}
+
 BinarySubstreamRef TpiStream::getTypeRecordsSubstream() const {
   return TypeRecordsSubstream;
 }
 
 FixedStreamArray<support::ulittle32_t> TpiStream::getHashValues() const {
   return HashValues;
 }
 

llvm/lib/DebugInfo/PDB/PDBExtras.cpp

switch (Type) {
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, UInt64, OS)
     default:
       OS << "Unknown";
   }
   return OS;
 }
 
 raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+                                   const PDB_BuiltinType &Type) {
+  switch (Type) {
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, None, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Void, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Char, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, WCharT, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Int, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, UInt, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Float, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, BCD, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Bool, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Long, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, ULong, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Currency, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Date, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Variant, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Complex, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Bitfield, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, BSTR, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, HResult, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Char16, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_BuiltinType, Char32, OS)
+  default:
+    OS << "Unknown";
+  }
+
+  return OS;
+}
+
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
                                    const PDB_CallingConv &Conv) {
   OS << "__";
   switch (Conv) {
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_CallingConv, NearC      , "cdecl", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_CallingConv, FarC       , "cdecl", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_CallingConv, NearPascal , "pascal", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_CallingConv, FarPascal  , "pascal", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_CallingConv, NearFast   , "fastcall", OS)

llvm/test/DebugInfo/PDB/Inputs/every-class.cpp

+// Build with "cl.exe /Z7 /GR- /GS- /GX- every-class.cpp /link /debug:full /nodefaultlib /incremental:no /entry:main"
+
+#include <stdint.h>
+
+// clang-format off
+void *__purecall = 0;
+
+void __cdecl operator delete(void *, unsigned int) {}
+void __cdecl operator delete(void *, unsigned __int64) {}
+
+struct Nothing {};
+struct Constructor { Constructor() {} };
+struct Assignment {
+  Assignment &operator=(Assignment Other) { return *this; }
+};
+struct Cast {
+  operator int() { return 42; }
+};
+
+struct Nested {
+  struct F {};
+};
+struct Operator {
+  int operator+(int X) { return 42; }
+};
+
+class Class {};
+
+union Union {};
+
+enum class Enum {A};
+
+
+template<typename T> void f(T t) {}
+
+int main(int argc, char **argv) {
+  struct Scoped {};
+  
+  struct { } Anonymous;
+
+  f(Nothing{});
+  f(Constructor{});
+  f(Assignment{});
+  f(Cast{});
+  f(Nested{});
+  f(Operator{});
+  f(Nested::F{});
+  f(Scoped{});
+  f(Class{});
+  f(Union{});
+  f(Anonymous);
+  f(Enum::A);
+  
+
+  f<const Nothing>(Nothing{});
+  f<volatile Nothing>(Nothing{});
+  f<const volatile Nothing>(Nothing{});
+  f<__unaligned Nothing>(Nothing{});
+
+  return 0;
+}

llvm/test/DebugInfo/PDB/every-type.test

 The test input (every-type.pdb) is generated from some short and trivial C++ code
 that exercises the entire type system to generate every possible type record that
 we claim to understand.  We then test this in two ways:
   1) We just dump the output for the purposes of readability.  This tests that we
      we can dump every possible type record.
   2) We dump the output to yaml, and then re-generate a PDB with the same type
      stream, and then run test 1 on the new PDB.  This verifies that the PDB
      hasn't changed.
 
 
 RUN: llvm-pdbutil dump -type-index=0x101A,0x102C,0x103D,0x104D,0x1098,0x10AA,0x10AC \
-RUN:   -dependents %p/Inputs/every-type.pdb | FileCheck --check-prefix=TYPES %s
+RUN:   -dont-resolve-forward-refs -dependents %p/Inputs/every-type.pdb \
+RUN:   | FileCheck --check-prefix=TYPES %s
 
 RUN: llvm-pdbutil pdb2yaml -tpi-stream -ipi-stream %p/Inputs/every-type.pdb > %t.pdb.yaml
 RUN: llvm-pdbutil yaml2pdb -pdb=%t.yaml.pdb %t.pdb.yaml
 RUN: llvm-pdbutil dump -type-index=0x101A,0x102C,0x103D,0x104D,0x1098,0x10AA,0x10AC \
-RUN:   -dependents %t.yaml.pdb | FileCheck --check-prefix=TYPES %s
+RUN:   -dependents -dont-resolve-forward-refs %t.yaml.pdb \
+RUN:   | FileCheck --check-prefix=TYPES %s
 
 TYPES:                           Types (TPI Stream)
 TYPES-NEXT: ============================================================
 TYPES-NEXT:   Showing 7 records and their dependents (72 records total)
 TYPES-NEXT:   0x1007 | LF_MODIFIER [size = 12]
 TYPES-NEXT:            referent = 0x0074 (int), modifiers = const
 TYPES-NEXT:   0x1008 | LF_CLASS [size = 48] `FooClass`
 TYPES-NEXT:            unique name: `.?AVFooClass@@`

llvm/test/DebugInfo/PDB/pdb-resolve-forward-refs.test

+; RUN: llvm-pdbutil dump -types %p/Inputs/every-class.pdb \
+; RUN:   | FileCheck %s
+
+; CHECK:                      Types (TPI Stream)                     
+; CHECK: ============================================================
+; CHECK:   Showing 157 records
+; CHECK:   0x1008 | LF_STRUCTURE [size = 124] `main::__l2::<unnamed-type-Anonymous>`
+; CHECK:            unique name: `.?AU<unnamed-type-Anonymous>@?1??main@@YAHHPEAPEAD@Z@`aa6523bc`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1007
+; CHECK:            options: has unique name | scoped, sizeof 1
+; CHECK:   0x1009 | LF_STRUCTURE [size = 88] `main::__l2::Scoped`
+; CHECK:            unique name: `.?AUScoped@?1??main@@YAHHPEAPEAD@Z@`aa6523bc`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1007
+; CHECK:            options: has unique name | scoped, sizeof 1
+; CHECK:   0x1054 | LF_STRUCTURE [size = 48] `Nested::F`
+; CHECK:            unique name: `.?AUF@Nested@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (-> 0x1057) | has unique name | is nested, sizeof 0
+; CHECK:   0x1056 | LF_STRUCTURE [size = 44] `Nested`
+; CHECK:            unique name: `.?AUNested@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1055
+; CHECK:            options: contains nested class | has unique name, sizeof 1
+; CHECK:   0x1057 | LF_STRUCTURE [size = 48] `Nested::F`
+; CHECK:            unique name: `.?AUF@Nested@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1007
+; CHECK:            options: has unique name | is nested, sizeof 1
+; CHECK:   0x1058 | LF_STRUCTURE [size = 52] `Constructor`
+; CHECK:            unique name: `.?AUConstructor@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (-> 0x105C) | has unique name, sizeof 0
+; CHECK:   0x105C | LF_STRUCTURE [size = 52] `Constructor`
+; CHECK:            unique name: `.?AUConstructor@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x105B
+; CHECK:            options: has ctor / dtor | has unique name, sizeof 1
+; CHECK:   0x105D | LF_CLASS [size = 40] `Class`
+; CHECK:            unique name: `.?AVClass@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1007
+; CHECK:            options: has unique name, sizeof 1
+; CHECK:   0x105E | LF_UNION [size = 32] `Union`
+; CHECK:            unique name: `.?ATUnion@@`
+; CHECK:            field list: 0x1007
+; CHECK:            options: has unique name | sealed, sizeof 1
+; CHECK:   0x105F | LF_STRUCTURE [size = 48] `Operator`
+; CHECK:            unique name: `.?AUOperator@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (-> 0x1064) | has unique name, sizeof 0
+; CHECK:   0x1064 | LF_STRUCTURE [size = 48] `Operator`
+; CHECK:            unique name: `.?AUOperator@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1063
+; CHECK:            options: has unique name | overloaded operator, sizeof 1
+; CHECK:   0x1066 | LF_ENUM [size = 36] `Enum`
+; CHECK:            unique name: `.?AW4Enum@@`
+; CHECK:            field list: 0x1065, underlying type: 0x0074 (int)
+; CHECK:            options: has unique name
+; CHECK:   0x1067 | LF_STRUCTURE [size = 40] `Cast`
+; CHECK:            unique name: `.?AUCast@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (-> 0x106B) | has unique name, sizeof 0
+; CHECK:   0x106B | LF_STRUCTURE [size = 40] `Cast`
+; CHECK:            unique name: `.?AUCast@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x106A
+; CHECK:            options: conversion operator | has unique name | overloaded operator, sizeof 1
+; CHECK:   0x106C | LF_STRUCTURE [size = 44] `Nothing`
+; CHECK:            unique name: `.?AUNothing@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1007
+; CHECK:            options: has unique name, sizeof 1
+; CHECK:   0x106D | LF_STRUCTURE [size = 52] `Assignment`
+; CHECK:            unique name: `.?AUAssignment@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (-> 0x1073) | has unique name, sizeof 0
+; CHECK:   0x1073 | LF_STRUCTURE [size = 52] `Assignment`
+; CHECK:            unique name: `.?AUAssignment@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: 0x1072
+; CHECK:            options: has unique name | overloaded operator | overloaded operator=, sizeof 1
+; CHECK:   0x1074 | LF_STRUCTURE [size = 44] `Nothing`
+; CHECK:            unique name: `.?AUNothing@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (<- 0x106C) | has unique name, sizeof 0
+; CHECK:   0x1081 | LF_UNION [size = 32] `Union`
+; CHECK:            unique name: `.?ATUnion@@`
+; CHECK:            field list: <no type>
+; CHECK:            options: forward ref (<- 0x105E) | has unique name, sizeof 0
+; CHECK:   0x1084 | LF_STRUCTURE [size = 124] `main::__l2::<unnamed-type-Anonymous>`
+; CHECK:            unique name: `.?AU<unnamed-type-Anonymous>@?1??main@@YAHHPEAPEAD@Z@`aa6523bc`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (<- 0x1008) | has unique name | scoped, sizeof 0
+; CHECK:   0x108E | LF_STRUCTURE [size = 44] `Nested`
+; CHECK:            unique name: `.?AUNested@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (<- 0x1056) | has unique name, sizeof 0
+; CHECK:   0x1095 | LF_STRUCTURE [size = 88] `main::__l2::Scoped`
+; CHECK:            unique name: `.?AUScoped@?1??main@@YAHHPEAPEAD@Z@`aa6523bc`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (<- 0x1009) | has unique name | scoped, sizeof 0
+; CHECK:   0x1098 | LF_CLASS [size = 40] `Class`
+; CHECK:            unique name: `.?AVClass@@`
+; CHECK:            vtable: <no type>, base list: <no type>, field list: <no type>
+; CHECK:            options: forward ref (<- 0x105D) | has unique name, sizeof 0

llvm/test/DebugInfo/PDB/pdbdump-headers.test

-; RUN: llvm-pdbutil dump -all %p/Inputs/empty.pdb | FileCheck -check-prefix=ALL %s
+; RUN: llvm-pdbutil dump -all -dont-resolve-forward-refs %p/Inputs/empty.pdb \
+; RUN:   | FileCheck -check-prefix=ALL %s
 ; RUN: llvm-pdbutil dump -summary -modules -files \
 ; RUN:              %p/Inputs/big-read.pdb | FileCheck -check-prefix=BIG %s
-; RUN: not llvm-pdbutil dump -summary %p/Inputs/bad-block-size.pdb 2>&1 | FileCheck -check-prefix=BAD-BLOCK-SIZE %s
+; RUN: not llvm-pdbutil dump -summary %p/Inputs/bad-block-size.pdb 2>&1 \
+; RUN:   | FileCheck -check-prefix=BAD-BLOCK-SIZE %s
 
 ALL:                                Summary
 ALL-NEXT: ============================================================
 ALL-NEXT:   Block Size: 4096
 ALL-NEXT:   Number of blocks: 25
 ALL-NEXT:   Number of streams: 17
 ALL-NEXT:   Signature: 1424295906
 ALL-NEXT:   Age: 1

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

for (const auto &I : Indices) {
     buildDepSet(Types, DepList, DepSet);
   }
 }
 
 static void
 dumpFullTypeStream(LinePrinter &Printer, LazyRandomTypeCollection &Types,
                    uint32_t NumTypeRecords, uint32_t NumHashBuckets,
                    FixedStreamArray<support::ulittle32_t> HashValues,
-                   bool Bytes, bool Extras) {
+                   TpiStream *Stream, bool Bytes, bool Extras) {
 
   Printer.formatLine("Showing {0:N} records", NumTypeRecords);
   uint32_t Width = NumDigits(TypeIndex::FirstNonSimpleIndex + NumTypeRecords);
 
   MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types,
-                           NumHashBuckets, HashValues);
+                           NumHashBuckets, HashValues, Stream);
 
   if (auto EC = codeview::visitTypeStream(Types, V)) {
     Printer.formatLine("An error occurred dumping type records: {0}",
                        toString(std::move(EC)));
   }
 }
 
 static void dumpPartialTypeStream(LinePrinter &Printer,
                                   LazyRandomTypeCollection &Types,
                                   TpiStream &Stream, ArrayRef<TypeIndex> TiList,
                                   bool Bytes, bool Extras, bool Deps) {
   uint32_t Width =
       NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
 
   MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types,
-                           Stream.getNumHashBuckets(), Stream.getHashValues());
+                           Stream.getNumHashBuckets(), Stream.getHashValues(),
+                           &Stream);
 
   if (opts::dump::DumpTypeDependents) {
     // If we need to dump all dependents, then iterate each index and find
     // all dependents, adding them to a map ordered by TypeIndex.
     std::map<TypeIndex, CVType> DepSet;
     buildDepSet(Types, TiList, DepSet);
 
     Printer.formatLine(
if (auto EC = Reader.readInteger(Magic))
       return EC;
     if (Magic != COFF::DEBUG_SECTION_MAGIC)
       return make_error<StringError>("Invalid CodeView debug section.",
                                      inconvertibleErrorCode());
 
     Types.reset(Reader, 100);
 
     if (opts::dump::DumpTypes) {
-      dumpFullTypeStream(P, Types, 0, 0, {}, opts::dump::DumpTypeData, false);
+      dumpFullTypeStream(P, Types, 0, 0, {}, nullptr, opts::dump::DumpTypeData,
+                         false);
     } else if (opts::dump::DumpTypeExtras) {
       auto LocalHashes = LocallyHashedType::hashTypeCollection(Types);
       auto GlobalHashes = GloballyHashedType::hashTypeCollection(Types);
       assert(LocalHashes.size() == GlobalHashes.size());
 
       P.formatLine("Local / Global hashes:");
       TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
       for (const auto &H : zip(LocalHashes, GlobalHashes)) {
Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
   AutoIndent Indent(P);
   ExitOnError Err("Unexpected error processing types: ");
 
   auto &Stream = Err((StreamIdx == StreamTPI) ? getPdb().getPDBTpiStream()
                                               : getPdb().getPDBIpiStream());
 
   auto &Types = (StreamIdx == StreamTPI) ? File.types() : File.ids();
 
+  // Enable resolving forward decls.
+  Stream.buildHashMap();
+
   if (DumpTypes || !Indices.empty()) {
     if (Indices.empty())
       dumpFullTypeStream(P, Types, Stream.getNumTypeRecords(),
                          Stream.getNumHashBuckets(), Stream.getHashValues(),
-                         DumpBytes, DumpExtras);
+                         &Stream, DumpBytes, DumpExtras);
     else {
       std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
       dumpPartialTypeStream(P, Types, Stream, TiList, DumpBytes, DumpExtras,
                             opts::dump::DumpTypeDependents);
     }
   }
 
   if (DumpExtras) {

llvm/tools/llvm-pdbutil/MinimalTypeDumper.h

 
 namespace llvm {
 namespace codeview {
 class LazyRandomTypeCollection;
 }
 
 namespace pdb {
 class LinePrinter;
+class TpiStream;
 
 class MinimalTypeDumpVisitor : public codeview::TypeVisitorCallbacks {
 public:
   MinimalTypeDumpVisitor(LinePrinter &P, uint32_t Width, bool RecordBytes,
                          bool Hashes, codeview::LazyRandomTypeCollection &Types,
                          uint32_t NumHashBuckets,
-                         FixedStreamArray<support::ulittle32_t> HashValues)
+                         FixedStreamArray<support::ulittle32_t> HashValues,
+                         pdb::TpiStream *Stream)
       : P(P), Width(Width), RecordBytes(RecordBytes), Hashes(Hashes),
-        Types(Types), NumHashBuckets(NumHashBuckets), HashValues(HashValues) {}
+        Types(Types), NumHashBuckets(NumHashBuckets), HashValues(HashValues),
+        Stream(Stream) {}
 
   Error visitTypeBegin(codeview::CVType &Record,
                        codeview::TypeIndex Index) override;
   Error visitTypeEnd(codeview::CVType &Record) override;
   Error visitMemberBegin(codeview::CVMemberRecord &Record) override;
   Error visitMemberEnd(codeview::CVMemberRecord &Record) override;
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
private:
   StringRef getTypeName(codeview::TypeIndex TI) const;
 
   LinePrinter &P;
   uint32_t Width;
   bool RecordBytes = false;
   bool Hashes = false;
   codeview::LazyRandomTypeCollection &Types;
   uint32_t NumHashBuckets;
+  codeview::TypeIndex CurrentTypeIndex;
   FixedStreamArray<support::ulittle32_t> HashValues;
+  pdb::TpiStream *Stream = nullptr;
 };
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/tools/llvm-pdbutil/MinimalTypeDumper.cpp

 //===- MinimalTypeDumper.cpp ---------------------------------- *- C++ --*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MinimalTypeDumper.h"
 
 #include "FormatUtil.h"
 #include "LinePrinter.h"
 
+#include "llvm-pdbutil.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Formatters.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
+#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 static std::string formatClassOptions(uint32_t IndentLevel,
-                                      ClassOptions Options) {
+                                      ClassOptions Options, TpiStream *Stream,
+                                      TypeIndex CurrentTypeIndex) {
   std::vector<std::string> Opts;
+
+  if (Stream && Stream->supportsTypeLookup() &&
+      !opts::dump::DontResolveForwardRefs &&
+      ((Options & ClassOptions::ForwardReference) != ClassOptions::None)) {
+    // If we're able to resolve forward references, do that.
+    Expected<TypeIndex> ETI =
+        Stream->findFullDeclForForwardRef(CurrentTypeIndex);
+    if (!ETI) {
+      consumeError(ETI.takeError());
+      PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref (???)");
+    } else {
+      const char *Direction = (*ETI == CurrentTypeIndex)
+                                  ? "="
+                                  : ((*ETI < CurrentTypeIndex) ? "<-" : "->");
+      std::string Formatted =
+          formatv("forward ref ({0} {1})", Direction, *ETI).str();
+      PUSH_FLAG(ClassOptions, ForwardReference, Options, std::move(Formatted));
+    }
+  } else {
+    PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref");
+  }
+
   PUSH_FLAG(ClassOptions, HasConstructorOrDestructor, Options,
             "has ctor / dtor");
   PUSH_FLAG(ClassOptions, ContainsNestedClass, Options,
             "contains nested class");
   PUSH_FLAG(ClassOptions, HasConversionOperator, Options,
             "conversion operator");
-  PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref");
   PUSH_FLAG(ClassOptions, HasUniqueName, Options, "has unique name");
   PUSH_FLAG(ClassOptions, Intrinsic, Options, "intrin");
   PUSH_FLAG(ClassOptions, Nested, Options, "is nested");
   PUSH_FLAG(ClassOptions, HasOverloadedOperator, Options,
             "overloaded operator");
   PUSH_FLAG(ClassOptions, HasOverloadedAssignmentOperator, Options,
             "overloaded operator=");
   PUSH_FLAG(ClassOptions, Packed, Options, "packed");
PUSH_FLAG(FunctionOptions, ConstructorWithVirtualBases, Options,
             "constructor with virtual bases");
   PUSH_FLAG(FunctionOptions, Constructor, Options, "constructor");
   if (Opts.empty())
     return "None";
   return join(Opts, " | ");
 }
 
 Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
+  CurrentTypeIndex = Index;
   // formatLine puts the newline at the beginning, so we use formatLine here
   // to start a new line, and then individual visit methods use format to
   // append to the existing line.
   if (!Hashes) {
     P.formatLine("{0} | {1} [size = {2}]",
                  fmt_align(Index, AlignStyle::Right, Width),
                  formatTypeLeafKind(Record.Type), Record.length());
   } else {

 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
                                                ClassRecord &Class) {
   P.format(" `{0}`", Class.Name);
   if (Class.hasUniqueName())
     P.formatLine("unique name: `{0}`", Class.UniqueName);
   P.formatLine("vtable: {0}, base list: {1}, field list: {2}",
                Class.VTableShape, Class.DerivationList, Class.FieldList);
   P.formatLine("options: {0}, sizeof {1}",
-               formatClassOptions(P.getIndentLevel(), Class.Options),
+               formatClassOptions(P.getIndentLevel(), Class.Options, Stream,
+                                  CurrentTypeIndex),
                Class.Size);
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
                                                UnionRecord &Union) {
   P.format(" `{0}`", Union.Name);
   if (Union.hasUniqueName())
     P.formatLine("unique name: `{0}`", Union.UniqueName);
   P.formatLine("field list: {0}", Union.FieldList);
   P.formatLine("options: {0}, sizeof {1}",
-               formatClassOptions(P.getIndentLevel(), Union.Options),
+               formatClassOptions(P.getIndentLevel(), Union.Options, Stream,
+                                  CurrentTypeIndex),
                Union.Size);
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
   P.format(" `{0}`", Enum.Name);
   if (Enum.hasUniqueName())
     P.formatLine("unique name: `{0}`", Enum.UniqueName);
   P.formatLine("field list: {0}, underlying type: {1}", Enum.FieldList,
                Enum.UnderlyingType);
   P.formatLine("options: {0}",
-               formatClassOptions(P.getIndentLevel(), Enum.Options));
+               formatClassOptions(P.getIndentLevel(), Enum.Options, Stream,
+                                  CurrentTypeIndex));
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
   if (AT.Name.empty()) {
     P.formatLine("size: {0}, index type: {1}, element type: {2}", AT.Size,
                  AT.IndexType, AT.ElementType);
   } else {

llvm/tools/llvm-pdbutil/llvm-pdbutil.h

 extern llvm::cl::opt<bool> DumpSectionHeaders;
 
 extern llvm::cl::opt<bool> DumpIds;
 extern llvm::cl::opt<bool> DumpIdData;
 extern llvm::cl::opt<bool> DumpIdExtras;
 extern llvm::cl::list<uint32_t> DumpIdIndex;
 extern llvm::cl::opt<uint32_t> DumpModi;
 extern llvm::cl::opt<bool> JustMyCode;
+extern llvm::cl::opt<bool> DontResolveForwardRefs;
 extern llvm::cl::opt<bool> DumpSymbols;
 extern llvm::cl::opt<bool> DumpSymRecordBytes;
 extern llvm::cl::opt<bool> DumpGSIRecords;
 extern llvm::cl::opt<bool> DumpGlobals;
 extern llvm::cl::opt<bool> DumpGlobalExtras;
 extern llvm::cl::opt<bool> DumpPublics;
 extern llvm::cl::opt<bool> DumpPublicExtras;
 extern llvm::cl::opt<bool> DumpSectionContribs;

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

Recurse("recurse",
             cl::desc("When dumping a SymIndexId, dump the full details of the "
                      "corresponding record"),
             cl::sub(DiaDumpSubcommand));
 
 static cl::opt<bool> Enums("enums", cl::desc("Dump enum types"),
                            cl::sub(DiaDumpSubcommand));
 static cl::opt<bool> Pointers("pointers", cl::desc("Dump enum types"),
                               cl::sub(DiaDumpSubcommand));
+static cl::opt<bool> UDTs("udts", cl::desc("Dump udt types"),
+                          cl::sub(DiaDumpSubcommand));
 static cl::opt<bool> Compilands("compilands",
                                 cl::desc("Dump compiland information"),
                                 cl::sub(DiaDumpSubcommand));
 } // namespace diadump
 
 namespace pretty {
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input PDB files>"),
cl::opt<bool> DumpTypeData(
     "type-data",
     cl::desc("dump CodeView type record raw bytes from TPI stream"),
     cl::cat(TypeOptions), cl::sub(DumpSubcommand));
 
 cl::opt<bool> DumpTypeExtras("type-extras",
                              cl::desc("dump type hashes and index offsets"),
                              cl::cat(TypeOptions), cl::sub(DumpSubcommand));
 
+cl::opt<bool> DontResolveForwardRefs(
+    "dont-resolve-forward-refs",
+    cl::desc("When dumping type records for classes, unions, enums, and "
+             "structs, don't try to resolve forward references"),
+    cl::cat(TypeOptions), cl::sub(DumpSubcommand));
+
 cl::list<uint32_t> DumpTypeIndex(
     "type-index", cl::ZeroOrMore, cl::CommaSeparated,
     cl::desc("only dump types with the specified hexadecimal type index"),
     cl::cat(TypeOptions), cl::sub(DumpSubcommand));
 
 cl::opt<bool> DumpIds("ids",
                       cl::desc("dump CodeView type records from IPI stream"),
                       cl::cat(TypeOptions), cl::sub(DumpSubcommand));
static void dumpDia(StringRef Path) {
   std::vector<PDB_SymType> SymTypes;
 
   if (opts::diadump::Compilands)
     SymTypes.push_back(PDB_SymType::Compiland);
   if (opts::diadump::Enums)
     SymTypes.push_back(PDB_SymType::Enum);
   if (opts::diadump::Pointers)
     SymTypes.push_back(PDB_SymType::PointerType);
+  if (opts::diadump::UDTs)
+    SymTypes.push_back(PDB_SymType::UDT);
 
   PdbSymbolIdField Ids = opts::diadump::NoSymIndexIds ? PdbSymbolIdField::None
                                                       : PdbSymbolIdField::All;
   PdbSymbolIdField Recurse = PdbSymbolIdField::None;
   if (opts::diadump::Recurse)
     Recurse = PdbSymbolIdField::All;
   if (!opts::diadump::ShowClassHierarchy)
     Ids &= ~(PdbSymbolIdField::ClassParent | PdbSymbolIdField::LexicalParent);
while (auto Child = Children->getNext()) {
           outs() << "  {";
           Enumerator->defaultDump(outs(), 4, Ids, Recurse);
           outs() << "\n  }\n";
         }
       }
       outs() << "\n}\n";
     }
   }
+  auto Child = Session->getSymbolById(3);
+  Child->defaultDump(outs(), 2, PdbSymbolIdField::All, PdbSymbolIdField::None);
 }
 
 static void dumpPretty(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
 
   const auto ReaderType =
       opts::pretty::Native ? PDB_ReaderType::Native : PDB_ReaderType::DIA;
   ExitOnErr(loadDataForPDB(ReaderType, Path, Session));