[llvm-pdbutil] Add the ability to dump a single type's entire dependency chain

[zturner]

Summary

Previously we had the -type-index option which would dump the record of a single, but we had no way to follow the dependency graph backwards and also dump all dependent types.

Having this option makes test-writing better, because we can limit the test to only those records that are of importance for the thing we're trying to test, which allows us to use things like CHECK-NEXT to reduce fragility.

[rnk]

lgtm, nice

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

struct TiReference {
   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);
 
 /// Discover type indices in symbol records. Returns false if this is an unknown
 /// record.
 bool discoverTypeIndices(const CVSymbol &Symbol,
                          SmallVectorImpl<TiReference> &Refs);
 }
 }
 
 #endif

llvm/trunk/lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp

static bool discoverTypeIndices(ArrayRef<uint8_t> Content, SymbolKind Kind,
   return true;
 }
 
 void llvm::codeview::discoverTypeIndices(const CVType &Type,
                                          SmallVectorImpl<TiReference> &Refs) {
   ::discoverTypeIndices(Type.content(), Type.kind(), Refs);
 }
 
+void llvm::codeview::discoverTypeIndices(const CVType &Type,
+                                         SmallVectorImpl<TypeIndex> &Indices) {
+
+  Indices.clear();
+
+  SmallVector<TiReference, 4> Refs;
+  discoverTypeIndices(Type, Refs);
+  if (Refs.empty())
+    return;
+
+  BinaryStreamReader Reader(Type.content(), support::little);
+  for (const auto &Ref : Refs) {
+    Reader.setOffset(Ref.Offset);
+    FixedStreamArray<TypeIndex> Run;
+    cantFail(Reader.readArray(Run, Ref.Count));
+    Indices.append(Run.begin(), Run.end());
+  }
+}
+
 void llvm::codeview::discoverTypeIndices(ArrayRef<uint8_t> RecordData,
                                          SmallVectorImpl<TiReference> &Refs) {
   const RecordPrefix *P =
       reinterpret_cast<const RecordPrefix *>(RecordData.data());
   TypeLeafKind K = static_cast<TypeLeafKind>(uint16_t(P->RecordKind));
   ::discoverTypeIndices(RecordData.drop_front(sizeof(RecordPrefix)), K, Refs);
 }
 
 bool llvm::codeview::discoverTypeIndices(const CVSymbol &Sym,
                                          SmallVectorImpl<TiReference> &Refs) {
   SymbolKind K = Sym.kind();
   return ::discoverTypeIndices(Sym.content(), K, Refs);
 }

llvm/trunk/test/tools/llvm-pdbdump/partial-type-stream.test

+; RUN: llvm-pdbutil dump -type-index=0x1019 %p/Inputs/ClassLayoutTest.pdb \
+; RUN: | FileCheck --check-prefix=NODEPS %s
+; RUN: llvm-pdbutil dump -type-index=0x1019 -dependents %p/Inputs/ClassLayoutTest.pdb \
+; RUN: | FileCheck --check-prefix=DEPS %s
+
+
+NODEPS:                          Types (TPI Stream)
+NODEPS-NEXT: ============================================================
+NODEPS-NEXT:   Showing 1 records.
+NODEPS-NEXT:   0x1019 | LF_MFUNCTION [size = 28]
+NODEPS-NEXT:            return type = 0x0003 (void), # args = 0, param list = 0x100E
+NODEPS-NEXT:            class type = 0x1017, this type = 0x1018, this adjust = 0
+NODEPS-NEXT:            calling conv = thiscall, options = None
+
+
+DEPS:                           Types (TPI Stream)
+DEPS-NEXT: ============================================================
+DEPS-NEXT:   Showing 1 records and their dependents (4 records total)
+DEPS-NEXT:   0x100E | LF_ARGLIST [size = 8]
+DEPS-NEXT:   0x1017 | LF_CLASS [size = 60]
+DEPS-NEXT:            class name: `MembersTest::A`
+DEPS-NEXT:            unique name: `.?AVA@MembersTest@@`
+DEPS-NEXT:            vtable: <no type>, base list: <no type>, field list: <no type>
+DEPS-NEXT:            options: forward ref | has unique name
+DEPS-NEXT:   0x1018 | LF_POINTER [size = 12]
+DEPS-NEXT:            referent = 0x1017, mode = pointer, opts = const, kind = ptr32
+DEPS-NEXT:   0x1019 | LF_MFUNCTION [size = 28]
+DEPS-NEXT:            return type = 0x0003 (void), # args = 0, param list = 0x100E
+DEPS-NEXT:            class type = 0x1017, this type = 0x1018, this adjust = 0
+DEPS-NEXT:            calling conv = thiscall, options = None

llvm/trunk/tools/llvm-pdbutil/DumpOutputStyle.h

public:
 
   Error dump() override;
 
 private:
   Expected<codeview::LazyRandomTypeCollection &> initializeTypes(uint32_t SN);
 
   Error dumpFileSummary();
   Error dumpStreamSummary();
-  Error dumpBlockRanges();
-  Error dumpStreamBytes();
   Error dumpStringTable();
   Error dumpLines();
   Error dumpInlineeLines();
   Error dumpXmi();
   Error dumpXme();
   Error dumpTpiStream(uint32_t StreamIdx);
   Error dumpModules();
   Error dumpModuleFiles();

llvm/trunk/tools/llvm-pdbutil/DumpOutputStyle.cpp

 #include "llvm/DebugInfo/CodeView/Formatters.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
+#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/EnumTables.h"
 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
 #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
if (auto EC = dumpXmi())
       return EC;
   }
 
   if (opts::dump::DumpXme) {
     if (auto EC = dumpXme())
       return EC;
   }
 
-  if (opts::dump::DumpTypes || opts::dump::DumpTypeExtras) {
+  if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
+      opts::dump::DumpTypeExtras) {
     if (auto EC = dumpTpiStream(StreamTPI))
       return EC;
   }
 
-  if (opts::dump::DumpIds || opts::dump::DumpIdExtras) {
+  if (opts::dump::DumpIds || !opts::dump::DumpIdIndex.empty() ||
+      opts::dump::DumpIdExtras) {
     if (auto EC = dumpTpiStream(StreamIPI))
       return EC;
   }
 
   if (opts::dump::DumpPublics) {
     if (auto EC = dumpPublics())
       return EC;
   }
for (uint32_t I : SortedIDs) {
     }
 
     if (!Str.empty())
       P.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Digits), Str);
   }
   return Error::success();
 }
 
+static void buildDepSet(LazyRandomTypeCollection &Types,
+                        ArrayRef<TypeIndex> Indices,
+                        std::map<TypeIndex, CVType> &DepSet) {
+  SmallVector<TypeIndex, 4> DepList;
+  for (const auto &I : Indices) {
+    TypeIndex TI(I);
+    if (DepSet.find(TI) != DepSet.end() || TI.isSimple() || TI.isNoneType())
+      continue;
+
+    CVType Type = Types.getType(TI);
+    DepSet[TI] = Type;
+    codeview::discoverTypeIndices(Type, DepList);
+    buildDepSet(Types, DepList, DepSet);
+  }
+}
+
+static void dumpFullTypeStream(LinePrinter &Printer,
+                               LazyRandomTypeCollection &Types,
+                               TpiStream &Stream, bool Bytes, bool Extras) {
+  Printer.formatLine("Showing {0:N} records", Stream.getNumTypeRecords());
+  uint32_t Width =
+      NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
+
+  MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types,
+                           Stream.getHashValues());
+
+  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.getHashValues());
+
+  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(
+        "Showing {0:N} records and their dependents ({1:N} records total)",
+        TiList.size(), DepSet.size());
+
+    for (auto &Dep : DepSet) {
+      if (auto EC = codeview::visitTypeRecord(Dep.second, Dep.first, V))
+        Printer.formatLine("An error occurred dumping type record {0}: {1}",
+                           Dep.first, toString(std::move(EC)));
+    }
+  } else {
+    Printer.formatLine("Showing {0:N} records.", TiList.size());
+
+    for (const auto &I : TiList) {
+      TypeIndex TI(I);
+      CVType Type = Types.getType(TI);
+      if (auto EC = codeview::visitTypeRecord(Type, TI, V))
+        Printer.formatLine("An error occurred dumping type record {0}: {1}", TI,
+                           toString(std::move(EC)));
+    }
+  }
+}
+
 Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 
   bool Present = false;
   bool DumpTypes = false;
   bool DumpBytes = false;
   bool DumpExtras = false;
   std::vector<uint32_t> Indices;
Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
 
   ExitOnError Err("Unexpected error processing types");
 
   auto &Stream = Err((StreamIdx == StreamTPI) ? File.getPDBTpiStream()
                                               : File.getPDBIpiStream());
 
   auto &Types = Err(initializeTypes(StreamIdx));
 
-  if (DumpTypes) {
-    P.formatLine("Showing {0:N} records", Stream.getNumTypeRecords());
-    uint32_t Width =
-        NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
-
-    MinimalTypeDumpVisitor V(P, Width + 2, DumpBytes, DumpExtras, Types,
-                             Stream.getHashValues());
-
-    if (Indices.empty()) {
-      if (auto EC = codeview::visitTypeStream(Types, V)) {
-        P.formatLine("An error occurred dumping type records: {0}",
-                     toString(std::move(EC)));
-      }
-    } else {
-      for (const auto &I : Indices) {
-        TypeIndex TI(I);
-        CVType Type = Types.getType(TI);
-        if (auto EC = codeview::visitTypeRecord(Type, TI, V))
-          P.formatLine("An error occurred dumping type record {0}: {1}", TI,
-                       toString(std::move(EC)));
-      }
+  if (DumpTypes || !Indices.empty()) {
+    if (Indices.empty())
+      dumpFullTypeStream(P, Types, Stream, DumpBytes, DumpExtras);
+    else {
+      std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
+      dumpPartialTypeStream(P, Types, Stream, TiList, DumpBytes, DumpExtras,
+                            opts::dump::DumpTypeDependents);
     }
   }
 
   if (DumpExtras) {
     P.NewLine();
     auto IndexOffsets = Stream.getTypeIndexOffsets();
     P.formatLine("Type Index Offsets:");
     for (const auto &IO : IndexOffsets) {

llvm/trunk/tools/llvm-pdbutil/MinimalTypeDumper.cpp

P.formatLine("calling conv = {0}, options = {1}",
                formatCallingConvention(Proc.CallConv),
                formatFunctionOptions(Proc.Options));
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
                                                MemberFunctionRecord &MF) {
   P.formatLine("return type = {0}, # args = {1}, param list = {2}",
-               MF.ParameterCount, MF.ArgumentList, MF.ReturnType);
+               MF.ReturnType, MF.ParameterCount, MF.ArgumentList);
   P.formatLine("class type = {0}, this type = {1}, this adjust = {2}",
                MF.ClassType, MF.ThisType, MF.ThisPointerAdjustment);
   P.formatLine("calling conv = {0}, options = {1}",
                formatCallingConvention(MF.CallConv),
                formatFunctionOptions(MF.Options));
   return Error::success();
 }
 

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

 extern llvm::cl::opt<bool> DumpInlineeLines;
 extern llvm::cl::opt<bool> DumpXmi;
 extern llvm::cl::opt<bool> DumpXme;
 extern llvm::cl::opt<bool> DumpStringTable;
 extern llvm::cl::opt<bool> DumpTypes;
 extern llvm::cl::opt<bool> DumpTypeData;
 extern llvm::cl::opt<bool> DumpTypeExtras;
 extern llvm::cl::list<uint32_t> DumpTypeIndex;
+extern llvm::cl::opt<bool> DumpTypeDependents;
 
 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<bool> DumpSymbols;
 extern llvm::cl::opt<bool> DumpSymRecordBytes;
 extern llvm::cl::opt<bool> DumpPublics;

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

 cl::opt<bool> DumpIdExtras("id-extras",
                            cl::desc("dump id hashes and index offsets"),
                            cl::cat(TypeOptions), cl::sub(DumpSubcommand));
 cl::list<uint32_t> DumpIdIndex(
     "id-index", cl::ZeroOrMore,
     cl::desc("only dump ids with the specified hexadecimal type index"),
     cl::cat(TypeOptions), cl::sub(DumpSubcommand));
 
+cl::opt<bool> DumpTypeDependents(
+    "dependents",
+    cl::desc("In conjunection with -type-index and -id-index, dumps the entire "
+             "dependency graph for the specified index instead of "
+             "just the single record with the specified index"),
+    cl::cat(TypeOptions), cl::sub(DumpSubcommand));
+
 // SYMBOL OPTIONS
 cl::opt<bool> DumpPublics("publics", cl::desc("dump Publics stream data"),
                           cl::cat(SymbolOptions), cl::sub(DumpSubcommand));
 cl::opt<bool> DumpSymbols("symbols", cl::desc("dump module symbols"),
                           cl::cat(SymbolOptions), cl::sub(DumpSubcommand));
 
 cl::opt<bool>
     DumpSymRecordBytes("sym-data",