[llvm-pdbdump] Add guard for null pointers and remove unused code

[asmith]

Summary

This avoids crashing when a user tries to dump a pdb with the -native option.

[zturner]

I don't have any problems with this, so feel free to commit. But I'm curious how you ran into this. Did you find a PDB with no compilands, functions, or data? If so, I'm curious how it was generated.

[asmith]

Yes, at least some of these changes are necessary to stop llvm-pdbdump from crashing today.

Here is a reproducer (atleast for us):

llvm-pdbdump.exe pretty -all -native foo.pdb

tools/llvm-pdbutil/PrettyCompilandDumper.cpp

void CompilandDumper::start(const PDBSymbolCompiland &Symbol,
   if (Printer.IsCompilandExcluded(FullName))
     return;
 
   Printer.NewLine();
   WithColor(Printer, PDB_ColorItem::Path).get() << FullName;
 
   if (opts & Flags::Lines) {
     const IPDBSession &Session = Symbol.getSession();
-    auto Files = Session.getSourceFilesForCompiland(Symbol);
+    if (auto Files = Session.getSourceFilesForCompiland(Symbol)) {
       Printer.Indent();
       while (auto File = Files->getNext()) {
         Printer.NewLine();
         WithColor(Printer, PDB_ColorItem::Path).get() << File->getFileName();
 
         auto Lines = Session.findLineNumbers(Symbol, *File);
+        if (!Lines)
+          continue;
+
         Printer.Indent();
         while (auto Line = Lines->getNext()) {
           Printer.NewLine();
           uint32_t LineStart = Line->getLineNumber();
           uint32_t LineEnd = Line->getLineNumberEnd();
 
           Printer << "Line ";
           PDB_ColorItem StatementColor = Line->isStatement()
-                                           ? PDB_ColorItem::Keyword
-                                           : PDB_ColorItem::LiteralValue;
           WithColor(Printer, StatementColor).get() << LineStart;
           if (LineStart != LineEnd)
             WithColor(Printer, StatementColor).get() << " - " << LineEnd;
 
           uint32_t ColumnStart = Line->getColumnNumber();
           uint32_t ColumnEnd = Line->getColumnNumberEnd();
           if (ColumnStart != 0 || ColumnEnd != 0) {
             Printer << ", Column: ";
             WithColor(Printer, StatementColor).get() << ColumnStart;
             if (ColumnEnd != ColumnStart)
               WithColor(Printer, StatementColor).get() << " - " << ColumnEnd;
           }
 
           Printer << ", Address: ";
           if (Line->getLength() > 0) {
             uint64_t AddrStart = Line->getVirtualAddress();
             uint64_t AddrEnd = AddrStart + Line->getLength() - 1;
             WithColor(Printer, PDB_ColorItem::Address).get()
               << "[" << format_hex(AddrStart, 10) << " - "
               << format_hex(AddrEnd, 10) << "]";
             Printer << " (" << Line->getLength() << " bytes)";
           } else {
             uint64_t AddrStart = Line->getVirtualAddress();
             WithColor(Printer, PDB_ColorItem::Address).get()
               << "[" << format_hex(AddrStart, 10) << "] ";
             Printer << "(0 bytes)";
           }
         }
         Printer.Unindent();
       }
       Printer.Unindent();
     }
+  }
 
   if (opts & Flags::Children) {
-    auto ChildrenEnum = Symbol.findAllChildren();
+    if (auto ChildrenEnum = Symbol.findAllChildren()) {
       Printer.Indent();
       while (auto Child = ChildrenEnum->getNext())
         Child->dump(*this);
       Printer.Unindent();
     }
   }
+}
 
 void CompilandDumper::dump(const PDBSymbolData &Symbol) {
   if (!shouldDumpSymLevel(opts::pretty::SymLevel::Data))
     return;
   if (Printer.IsSymbolExcluded(Symbol.getName()))
     return;
 
   Printer.NewLine();

tools/llvm-pdbutil/PrettyExternalSymbolDumper.cpp

 
 using namespace llvm;
 using namespace llvm::pdb;
 
 ExternalSymbolDumper::ExternalSymbolDumper(LinePrinter &P)
     : PDBSymDumper(true), Printer(P) {}
 
 void ExternalSymbolDumper::start(const PDBSymbolExe &Symbol) {
-  auto Vars = Symbol.findAllChildren<PDBSymbolPublicSymbol>();
+  if (auto Vars = Symbol.findAllChildren<PDBSymbolPublicSymbol>()) {
     while (auto Var = Vars->getNext())
       Var->dump(*this);
   }
+}
 
 void ExternalSymbolDumper::dump(const PDBSymbolPublicSymbol &Symbol) {
   std::string LinkageName = Symbol.getName();
   if (Printer.IsSymbolExcluded(LinkageName))
     return;
 
   Printer.NewLine();
   uint64_t Addr = Symbol.getVirtualAddress();
 
   Printer << "[";
   WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(Addr, 10);
   Printer << "] ";
   WithColor(Printer, PDB_ColorItem::Identifier).get() << LinkageName;
 }

tools/llvm-pdbutil/PrettyTypeDumper.cpp

filterAndSortClassDefs(LinePrinter &Printer, Enumerator &E,
   if (Comp)
     std::sort(Filtered.begin(), Filtered.end(), Comp);
   return Filtered;
 }
 
 TypeDumper::TypeDumper(LinePrinter &P) : PDBSymDumper(true), Printer(P) {}
 
 void TypeDumper::start(const PDBSymbolExe &Exe) {
-  auto Children = Exe.findAllChildren();
   if (opts::pretty::Enums) {
     if (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);

tools/llvm-pdbutil/llvm-pdbutil.cpp

static void dumpPretty(StringRef Path) {
 
   auto &Stream = outs();
   const bool UseColor = opts::pretty::ColorOutput == cl::BOU_UNSET
                             ? Stream.has_colors()
                             : opts::pretty::ColorOutput == cl::BOU_TRUE;
   LinePrinter Printer(2, UseColor, Stream);
 
   auto GlobalScope(Session->getGlobalScope());
+  if (!GlobalScope)
+    return;
   std::string FileName(GlobalScope->getSymbolsFileName());
 
   WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
   WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
   Printer.Indent();
   uint64_t FileSize = 0;
 
   Printer.NewLine();
static void dumpPretty(StringRef Path) {
   if (GlobalScope->hasPrivateSymbols())
     outs() << "HasPrivateSymbols ";
   Printer.Unindent();
 
   if (opts::pretty::Compilands) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get()
         << "---COMPILANDS---";
+    if (auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>()) {
       Printer.Indent();
-    auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
       CompilandDumper Dumper(Printer);
       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::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::Symbols) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---";
+    if (auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>()) {
       Printer.Indent();
-    auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
       CompilandDumper Dumper(Printer);
       while (auto Compiland = Compilands->getNext())
         Dumper.start(*Compiland, true);
       Printer.Unindent();
     }
+  }
 
   if (opts::pretty::Globals) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---";
     Printer.Indent();
     if (shouldDumpSymLevel(opts::pretty::SymLevel::Functions)) {
+      if (auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>()) {
         FunctionDumper Dumper(Printer);
-      auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>();
         if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
           while (auto Function = Functions->getNext()) {
             Printer.NewLine();
             Dumper.start(*Function, FunctionDumper::PointerType::None);
           }
         } else {
           std::vector<std::unique_ptr<PDBSymbolFunc>> Funcs;
           while (auto Func = Functions->getNext())
             Funcs.push_back(std::move(Func));
           std::sort(Funcs.begin(), Funcs.end(),
                     opts::pretty::compareFunctionSymbols);
           for (const auto &Func : Funcs) {
             Printer.NewLine();
             Dumper.start(*Func, FunctionDumper::PointerType::None);
           }
         }
       }
+    }
     if (shouldDumpSymLevel(opts::pretty::SymLevel::Data)) {
-      auto Vars = GlobalScope->findAllChildren<PDBSymbolData>();
+      if (auto Vars = GlobalScope->findAllChildren<PDBSymbolData>()) {
         VariableDumper Dumper(Printer);
         if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
           while (auto Var = Vars->getNext())
             Dumper.start(*Var);
         } else {
           std::vector<std::unique_ptr<PDBSymbolData>> Datas;
           while (auto Var = Vars->getNext())
             Datas.push_back(std::move(Var));
-        std::sort(Datas.begin(), Datas.end(), opts::pretty::compareDataSymbols);
+          std::sort(Datas.begin(), Datas.end(),
+                    opts::pretty::compareDataSymbols);
           for (const auto &Var : Datas)
             Dumper.start(*Var);
         }
       }
+    }
     if (shouldDumpSymLevel(opts::pretty::SymLevel::Thunks)) {
-      auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>();
+      if (auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>()) {
         CompilandDumper Dumper(Printer);
         while (auto Thunk = Thunks->getNext())
           Dumper.dump(*Thunk);
       }
+    }
     Printer.Unindent();
   }
   if (opts::pretty::Externals) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---EXTERNALS---";
     Printer.Indent();
     ExternalSymbolDumper Dumper(Printer);
     Dumper.start(*GlobalScope);