Allow llvm-pdbdump pretty mode to only dump certain types of types

[zturner]

Summary

Sometimes you might only be interested in classes, or typedefs, or enums, but not all 3. Adding this method to filter the output means you have to deal with less spam.

[amccarth]

LGTM

llvm/trunk/tools/llvm-pdbdump/PrettyTypeDumper.cpp

 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 TypeDumper::TypeDumper(LinePrinter &P) : PDBSymDumper(true), Printer(P) {}
 
 void TypeDumper::start(const PDBSymbolExe &Exe) {
+  if (opts::pretty::Enums) {
     auto Enums = Exe.findAllChildren<PDBSymbolTypeEnum>();
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::Identifier).get() << "Enums";
     Printer << ": (" << Enums->getChildCount() << " items)";
     Printer.Indent();
     while (auto Enum = Enums->getNext())
       Enum->dump(*this);
     Printer.Unindent();
+  }
 
+  if (opts::pretty::Typedefs) {
     auto Typedefs = Exe.findAllChildren<PDBSymbolTypeTypedef>();
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::Identifier).get() << "Typedefs";
     Printer << ": (" << Typedefs->getChildCount() << " items)";
     Printer.Indent();
     while (auto Typedef = Typedefs->getNext())
       Typedef->dump(*this);
     Printer.Unindent();
+  }
 
+  if (opts::pretty::Classes) {
     auto Classes = Exe.findAllChildren<PDBSymbolTypeUDT>();
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::Identifier).get() << "Classes";
     Printer << ": (" << Classes->getChildCount() << " items)";
     Printer.Indent();
     while (auto Class = Classes->getNext())
       Class->dump(*this);
     Printer.Unindent();
   }
+}
 
 void TypeDumper::dump(const PDBSymbolTypeEnum &Symbol) {
+  assert(opts::pretty::Enums);
+
   if (Symbol.getUnmodifiedTypeId() != 0)
     return;
   if (Printer.IsTypeExcluded(Symbol.getName()))
     return;
   // Dump member enums when dumping their class definition.
   if (nullptr != Symbol.getClassParent())
     return;
 
   Printer.NewLine();
   EnumDumper Dumper(Printer);
   Dumper.start(Symbol);
 }
 
 void TypeDumper::dump(const PDBSymbolTypeTypedef &Symbol) {
+  assert(opts::pretty::Typedefs);
+
   if (Printer.IsTypeExcluded(Symbol.getName()))
     return;
 
   Printer.NewLine();
   TypedefDumper Dumper(Printer);
   Dumper.start(Symbol);
 }
 
 void TypeDumper::dump(const PDBSymbolTypeUDT &Symbol) {
+  assert(opts::pretty::Classes);
+
   if (Symbol.getUnmodifiedTypeId() != 0)
     return;
   if (Printer.IsTypeExcluded(Symbol.getName()))
     return;
 
   Printer.NewLine();
 
   if (opts::pretty::NoClassDefs) {
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "class ";
     WithColor(Printer, PDB_ColorItem::Identifier).get() << Symbol.getName();
   } else {
     ClassDefinitionDumper Dumper(Printer);
     Dumper.start(Symbol);
   }
 }

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h

 #include "llvm/Support/raw_ostream.h"
 
 namespace opts {
 
 namespace pretty {
 extern llvm::cl::opt<bool> Compilands;
 extern llvm::cl::opt<bool> Symbols;
 extern llvm::cl::opt<bool> Globals;
-extern llvm::cl::opt<bool> Types;
+extern llvm::cl::opt<bool> Classes;
+extern llvm::cl::opt<bool> Enums;
+extern llvm::cl::opt<bool> Typedefs;
 extern llvm::cl::opt<bool> All;
 extern llvm::cl::opt<bool> ExcludeCompilerGenerated;
 
 extern llvm::cl::opt<bool> NoClassDefs;
 extern llvm::cl::opt<bool> NoEnumDefs;
 extern llvm::cl::list<std::string> ExcludeTypes;
 extern llvm::cl::list<std::string> ExcludeSymbols;
 extern llvm::cl::list<std::string> ExcludeCompilands;

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp

 cl::opt<bool> Compilands("compilands", cl::desc("Display compilands"),
                          cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 cl::opt<bool> Symbols("symbols", cl::desc("Display symbols for each compiland"),
                       cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 cl::opt<bool> Globals("globals", cl::desc("Dump global symbols"),
                       cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 cl::opt<bool> Externals("externals", cl::desc("Dump external symbols"),
                         cl::cat(TypeCategory), cl::sub(PrettySubcommand));
-cl::opt<bool> Types("types", cl::desc("Display types"), cl::cat(TypeCategory),
-                    cl::sub(PrettySubcommand));
+cl::opt<bool>
+    Types("types",
+          cl::desc("Display all types (implies -classes, -enums, -typedefs)"),
+          cl::cat(TypeCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> Classes("classes", cl::desc("Display class types"),
+                      cl::cat(TypeCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> Enums("enums", cl::desc("Display enum types"),
+                    cl::cat(TypeCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> Typedefs("typedefs", cl::desc("Display typedef types"),
+                       cl::cat(TypeCategory), cl::sub(PrettySubcommand));
+
 cl::opt<bool> Lines("lines", cl::desc("Line tables"), cl::cat(TypeCategory),
                     cl::sub(PrettySubcommand));
 cl::opt<bool>
     All("all", cl::desc("Implies all other options in 'Symbol Types' category"),
         cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 
 cl::opt<uint64_t> LoadAddress(
     "load-address",
if (opts::pretty::Compilands) {
     CompilandDumpFlags options = CompilandDumper::Flags::None;
     if (opts::pretty::Lines)
       options = options | CompilandDumper::Flags::Lines;
     while (auto Compiland = Compilands->getNext())
       Dumper.start(*Compiland, options);
     Printer.Unindent();
   }
 
-  if (opts::pretty::Types) {
+  if (opts::pretty::Classes || opts::pretty::Enums || opts::pretty::Typedefs) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---";
     Printer.Indent();
     TypeDumper Dumper(Printer);
     Dumper.start(*GlobalScope);
     Printer.Unindent();
   }
 
if (opts::pretty::All) {
       opts::pretty::Compilands = true;
       opts::pretty::Symbols = true;
       opts::pretty::Globals = true;
       opts::pretty::Types = true;
       opts::pretty::Externals = true;
       opts::pretty::Lines = true;
     }
 
+    if (opts::pretty::Types) {
+      opts::pretty::Classes = true;
+      opts::pretty::Typedefs = true;
+      opts::pretty::Enums = true;
+    }
+
     // When adding filters for excluded compilands and types, we need to
     // remember that these are regexes.  So special characters such as * and \
     // need to be escaped in the regex.  In the case of a literal \, this means
     // it needs to be escaped again in the C++.  So matching a single \ in the
     // input requires 4 \es in the C++.
     if (opts::pretty::ExcludeCompilerGenerated) {
       opts::pretty::ExcludeTypes.push_back("__vc_attributes");
       opts::pretty::ExcludeCompilands.push_back("\\* Linker \\*");