[llvm-pdbutil] Support PDBs without a DBI stream

[aganea]

Summary

This change ensures llvm-pdb doesn't fail on start, when the DBI stream isn't present in the PDB.

This occurs when compiling a simple .cpp with /Zi (see attached test)

Also, normalized the formatting of the errors printed by llvm-pdbutil in that case.

Tested all commands with the provided PDB, only llvm-pdbutil dump ... and llvm-pdbutil pdb2yaml ... seemed to be previously affected by the issue.

[zturner]

lib/DebugInfo/PDB/Native/PDBFile.cpp

473–474 ↗

(On Diff #159016)

This check looks incorrect to me. A 0-byte stream is still a stream.

test/tools/llvm-pdbdump/Inputs/TypeServerTest.cpp

1 ↗

(On Diff #159016)

Instead of checking in source code and a binary object file, can we just check in a yaml file and run it through yaml2pdb? If you can't get pdb2yaml to produce this file (because it also crashes), then just run pdb2yaml on a good file, and delete the DBI stream. If it's possible to get pdb2yaml to produce a PDB with a 0-byte DBI stream, that should be sufficient to test this.

If all else fails and you really must check in binary files, then I think we only need the PDB and not the obj, and you will probably need to use /nodefaultlib /entry:main to keep the PDB binary small.

tools/llvm-pdbutil/DumpOutputStyle.cpp

71–73 ↗

(On Diff #159016)

This looks odd? We shouldn't be printing anything inside of a predicate function.

79–81 ↗

(On Diff #159016)

Same here.

87–89 ↗

(On Diff #159016)

And here.

[aganea]

lib/DebugInfo/PDB/Native/PDBFile.cpp

473–474 ↗

(On Diff #159016)

Reverted this change - replaced by change in InputFile.cpp instead.

test/tools/llvm-pdbdump/Inputs/TypeServerTest.cpp

1 ↗

(On Diff #159016)

Unfourtunately the pdb is needed, because yaml2pdb generates a default DBI stream if there's none in the yaml. Also, please note this is the pdb generated by cl.exe, not link.exe. The current size is 60kb.

[zturner]

Ok 60kb is probably fine. Lgtm

[aganea]

Thank you for the review Zachary!

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

uint32_t PDBFile::getPointerSize() {
   if (!DbiS)
     return 0;
   PDB_Machine Machine = DbiS->getMachineType();
   if (Machine == PDB_Machine::Amd64)
     return 8;
   return 4;
 }
 
-bool PDBFile::hasPDBDbiStream() const { return StreamDBI < getNumStreams(); }
+bool PDBFile::hasPDBDbiStream() const {
+  return StreamDBI < getNumStreams() && getStreamByteSize(StreamDBI) > 0;
+}
 
 bool PDBFile::hasPDBGlobalsStream() {
   auto DbiS = getPDBDbiStream();
   if (!DbiS) {
     consumeError(DbiS.takeError());
     return false;
   }
 

llvm/trunk/test/tools/llvm-pdbdump/Inputs/TypeServerTest.cpp

+// Compile with "cl /c /Zi TypeServerTest.cpp /FdTypeServerTest.pdb"
+
+int main(void)
+{
+  return 0;
+}

llvm/trunk/test/tools/llvm-pdbdump/type-server-no-dbi.test

+
+RUN: llvm-pdbutil dump -all %p/Inputs/TypeServerTest.pdb | FileCheck %s --check-prefix=NO-DBI
+RUN: llvm-pdbutil pdb2yaml -all %p/Inputs/TypeServerTest.pdb > %t
+RUN: FileCheck --input-file=%t %s --check-prefix=NO-DBI-YAML
+
+NO-DBI-NOT: Native PDB Error: The specified stream could not be loaded.
+
+NO-DBI:                         Module Stats
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+NO-DBI:                      S_UDT Record Stats
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     Globals stream not present
+
+NO-DBI:                           Modules
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+NO-DBI:                            Files
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+NO-DBI:                            Lines
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+NO-DBI:                        Inlinee Lines
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+NO-DBI:                     Cross Module Imports
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+NO-DBI:                     Cross Module Exports
+NO-DBI-NEXT: ============================================================
+NO-DBI-NEXT:     DBI stream not present
+
+
+NO-DBI-YAML-NOT: Native PDB Error: The specified stream could not be loaded.
+
+NO-DBI-YAML: TpiStream:
+NO-DBI-YAML-NEXT:  Version:         VC80
+NO-DBI-YAML-NEXT:  Records:
+NO-DBI-YAML-NEXT:    - Kind:            LF_ARGLIST

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

public:
   DumpOutputStyle(InputFile &File);
 
   Error dump() override;
 
 private:
   PDBFile &getPdb();
   object::COFFObjectFile &getObj();
 
+  void printStreamNotValidForObj();
+  void printStreamNotPresent(StringRef StreamName);
+
   Error dumpFileSummary();
   Error dumpStreamSummary();
   Error dumpSymbolStats();
   Error dumpUdtStats();
   Error dumpNamedStreams();
   Error dumpStringTable();
   Error dumpStringTableFromPdb();
   Error dumpStringTableFromObj();

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

 using namespace llvm::pdb;
 
 DumpOutputStyle::DumpOutputStyle(InputFile &File)
     : File(File), P(2, false, outs()) {}
 
 PDBFile &DumpOutputStyle::getPdb() { return File.pdb(); }
 object::COFFObjectFile &DumpOutputStyle::getObj() { return File.obj(); }
 
+void DumpOutputStyle::printStreamNotValidForObj() {
+  AutoIndent Indent(P, 4);
+  P.formatLine("Dumping this stream is not valid for object files");
+}
+
+void DumpOutputStyle::printStreamNotPresent(StringRef StreamName) {
+  AutoIndent Indent(P, 4);
+  P.formatLine("{0} stream not present", StreamName);
+}
+
 Error DumpOutputStyle::dump() {
   if (opts::dump::DumpSummary) {
     if (auto EC = dumpFileSummary())
       return EC;
     P.NewLine();
   }
 
   if (opts::dump::DumpStreams) {
static void printHeader(LinePrinter &P, const Twine &S) {
   P.NewLine();
   P.formatLine("{0,=60}", S);
   P.formatLine("{0}", fmt_repeat('=', 60));
 }
 
 Error DumpOutputStyle::dumpFileSummary() {
   printHeader(P, "Summary");
 
-  ExitOnError Err("Invalid PDB Format: ");
-
-  AutoIndent Indent(P);
   if (File.isObj()) {
-    P.formatLine("Dumping File summary is not valid for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
+  AutoIndent Indent(P);
+  ExitOnError Err("Invalid PDB Format: ");
+
   P.formatLine("Block Size: {0}", getPdb().getBlockSize());
   P.formatLine("Number of blocks: {0}", getPdb().getBlockCount());
   P.formatLine("Number of streams: {0}", getPdb().getNumStreams());
 
   auto &PS = Err(getPdb().getPDBInfoStream());
   P.formatLine("Signature: {0}", PS.getSignature());
   P.formatLine("Age: {0}", PS.getAge());
   P.formatLine("GUID: {0}", fmt_guid(PS.getGuid().Guid));
static bool shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group) {
 
   // Otherwise, only dump if this is the same module specified.
   return (opts::dump::DumpModi == Idx);
 }
 
 Error DumpOutputStyle::dumpStreamSummary() {
   printHeader(P, "Streams");
 
-  AutoIndent Indent(P);
   if (File.isObj()) {
-    P.formatLine("Dumping streams is not valid for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
+  AutoIndent Indent(P);
+
   if (StreamPurposes.empty())
     discoverStreamPurposes(getPdb(), StreamPurposes);
 
   uint32_t StreamCount = getPdb().getNumStreams();
   uint32_t MaxStreamSize = getPdb().getMaxStreamSize();
 
   for (uint16_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
     P.formatLine(
P.formatLine("SC2[{6}] | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
                fmtle(SC.Base.RelocCrc), fmtle(SC.ISectCoff));
   P.formatLine("      {0}",
                formatSectionCharacteristics(P.getIndentLevel() + 6,
                                             SC.Base.Characteristics, 3, " | "));
 }
 
 Error DumpOutputStyle::dumpModules() {
   printHeader(P, "Modules");
-  AutoIndent Indent(P);
 
   if (File.isObj()) {
-    P.formatLine("Dumping modules is not supported for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
   if (!getPdb().hasPDBDbiStream()) {
-    P.formatLine("DBI Stream not present");
+    printStreamNotPresent("DBI");
     return Error::success();
   }
 
+  AutoIndent Indent(P);
   ExitOnError Err("Unexpected error processing modules: ");
 
   auto &Stream = Err(getPdb().getPDBDbiStream());
 
   const DbiModuleList &Modules = Stream.modules();
   iterateSymbolGroups(
       File, PrintScope{P, 11}, [&](uint32_t Modi, const SymbolGroup &Strings) {
         auto Desc = Modules.getModuleDescriptor(Modi);
iterateSymbolGroups(
       });
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpModuleFiles() {
   printHeader(P, "Files");
 
   if (File.isObj()) {
-    P.formatLine("Dumping files is not valid for object files");
+    printStreamNotValidForObj();
+    return Error::success();
+  }
+
+  if (!getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
     return Error::success();
   }
 
   ExitOnError Err("Unexpected error processing modules: ");
 
   iterateSymbolGroups(File, PrintScope{P, 11},
                       [this, &Err](uint32_t Modi, const SymbolGroup &Strings) {
                         auto &Stream = Err(getPdb().getPDBDbiStream());
 
                         const DbiModuleList &Modules = Stream.modules();
                         for (const auto &F : Modules.source_files(Modi)) {
                           Strings.formatFromFileName(P, F);
                         }
                       });
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpSymbolStats() {
   printHeader(P, "Module Stats");
 
+  if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
+    return Error::success();
+  }
+
   ExitOnError Err("Unexpected error processing modules: ");
 
   StatCollection SymStats;
   StatCollection ChunkStats;
 
   Optional<PrintScope> Scope;
   if (File.isPdb())
     Scope.emplace(P, 2);
if (SG.getFile().isPdb()) {
       P.formatLine("Stream {0}, {1} bytes", StreamIdx,
                    getPdb().getStreamByteSize(StreamIdx));
 
       printModuleDetailStats<SymbolKind>(P, "Symbols", SS);
       printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", CS);
     }
   });
 
+  if (SymStats.Totals.Count > 0) {
     P.printLine("  Summary |");
     AutoIndent Indent(P, 4);
-  if (SymStats.Totals.Count > 0) {
     printModuleDetailStats<SymbolKind>(P, "Symbols", SymStats);
     printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", ChunkStats);
   }
 
   return Error::success();
 }
 
 static bool isValidNamespaceIdentifier(StringRef S) {
for (const auto &Stat : Stats.Individual) {
     L = std::max(L, Label.size());
   }
   return static_cast<uint32_t>(L);
 }
 
 Error DumpOutputStyle::dumpUdtStats() {
   printHeader(P, "S_UDT Record Stats");
 
+  if (File.isPdb() && !getPdb().hasPDBGlobalsStream()) {
+    printStreamNotPresent("Globals");
+    return Error::success();
+  }
+
   StatCollection UdtStats;
   StatCollection UdtTargetStats;
   AutoIndent Indent(P, 4);
 
   auto &TpiTypes = File.types();
 
   StringMap<StatCollection::Stat> NamespacedStats;
 
auto HandleOneSymbol = [&](const CVSymbol &Sym) {
 
     LongestNamespace = std::max(LongestNamespace, Scope.size());
     NamespacedStats[Scope].update(RecordSize);
   };
 
   P.NewLine();
 
   if (File.isPdb()) {
-    if (!getPdb().hasPDBGlobalsStream()) {
-      P.printLine("- Error: globals stream not present");
-      return Error::success();
-    }
-
     auto &SymbolRecords = cantFail(getPdb().getPDBSymbolStream());
     auto ExpGlobals = getPdb().getPDBGlobalsStream();
     if (!ExpGlobals)
       return ExpGlobals.takeError();
 
     for (uint32_t PubSymOff : ExpGlobals->getGlobalsTable()) {
       CVSymbol Sym = SymbolRecords.readRecord(PubSymOff);
       HandleOneSymbol(Sym);
while (ItemsLeft != 0) {
     }
     P.NewLine();
   }
 }
 
 Error DumpOutputStyle::dumpLines() {
   printHeader(P, "Lines");
 
+  if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
+    return Error::success();
+  }
+
   uint32_t LastModi = UINT32_MAX;
   uint32_t LastNameIndex = UINT32_MAX;
   iterateModuleSubsections<DebugLinesSubsectionRef>(
       File, PrintScope{P, 4},
       [this, &LastModi, &LastNameIndex](uint32_t Modi,
                                         const SymbolGroup &Strings,
                                         DebugLinesSubsectionRef &Lines) {
         uint16_t Segment = Lines.header()->RelocSegment;
iterateModuleSubsections<DebugLinesSubsectionRef>(
       });
 
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpInlineeLines() {
   printHeader(P, "Inlinee Lines");
 
+  if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
+    return Error::success();
+  }
+
   iterateModuleSubsections<DebugInlineeLinesSubsectionRef>(
       File, PrintScope{P, 2},
       [this](uint32_t Modi, const SymbolGroup &Strings,
              DebugInlineeLinesSubsectionRef &Lines) {
         P.formatLine("{0,+8} | {1,+5} | {2}", "Inlinee", "Line", "Source File");
         for (const auto &Entry : Lines) {
           P.formatLine("{0,+8} | {1,+5} | ", Entry.Header->Inlinee,
                        fmtle(Entry.Header->SourceLineNum));
           Strings.formatFromChecksumsOffset(P, Entry.Header->FileID, true);
         }
         P.NewLine();
       });
 
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpXmi() {
   printHeader(P, "Cross Module Imports");
+
+  if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
+    return Error::success();
+  }
+
   iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
       File, PrintScope{P, 2},
       [this](uint32_t Modi, const SymbolGroup &Strings,
              DebugCrossModuleImportsSubsectionRef &Imports) {
         P.formatLine("{0,=32} | {1}", "Imported Module", "Type IDs");
 
         for (const auto &Xmi : Imports) {
           auto ExpectedModule =
iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
       });
 
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpXme() {
   printHeader(P, "Cross Module Exports");
 
+  if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
+    return Error::success();
+  }
+
   iterateModuleSubsections<DebugCrossModuleExportsSubsectionRef>(
       File, PrintScope{P, 2},
       [this](uint32_t Modi, const SymbolGroup &Strings,
              DebugCrossModuleExportsSubsectionRef &Exports) {
         P.formatLine("{0,-10} | {1}", "Local ID", "Global ID");
         for (const auto &Export : Exports) {
           P.formatLine("{0,+10:X+} | {1}", TypeIndex(Export.Local),
                        TypeIndex(Export.Global));
iterateModuleSubsections<DebugStringTableSubsectionRef>(
                        Str);
         }
       });
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpNamedStreams() {
   printHeader(P, "Named Streams");
-  AutoIndent Indent(P, 2);
 
   if (File.isObj()) {
-    P.formatLine("Dumping Named Streams is only supported for PDB files.");
+    printStreamNotValidForObj();
     return Error::success();
   }
+
+  AutoIndent Indent(P);
   ExitOnError Err("Invalid PDB File: ");
 
   auto &IS = Err(File.pdb().getPDBInfoStream());
   const NamedStreamMap &NS = IS.getNamedStreams();
   for (const auto &Entry : NS.entries()) {
     P.printLine(Entry.getKey());
     AutoIndent Indent2(P, 2);
     P.formatLine("Index: {0}", Entry.getValue());
Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 
   if (StreamIdx == StreamTPI) {
     printHeader(P, "Types (TPI Stream)");
   } else if (StreamIdx == StreamIPI) {
     printHeader(P, "Types (IPI Stream)");
   }
 
-  AutoIndent Indent(P);
   assert(!File.isObj());
 
   bool Present = false;
   bool DumpTypes = false;
   bool DumpBytes = false;
   bool DumpExtras = false;
   std::vector<uint32_t> Indices;
   if (StreamIdx == StreamTPI) {
     Present = getPdb().hasPDBTpiStream();
     DumpTypes = opts::dump::DumpTypes;
     DumpBytes = opts::dump::DumpTypeData;
     DumpExtras = opts::dump::DumpTypeExtras;
     Indices.assign(opts::dump::DumpTypeIndex.begin(),
                    opts::dump::DumpTypeIndex.end());
   } else if (StreamIdx == StreamIPI) {
     Present = getPdb().hasPDBIpiStream();
     DumpTypes = opts::dump::DumpIds;
     DumpBytes = opts::dump::DumpIdData;
     DumpExtras = opts::dump::DumpIdExtras;
     Indices.assign(opts::dump::DumpIdIndex.begin(),
                    opts::dump::DumpIdIndex.end());
   }
 
   if (!Present) {
-    P.formatLine("Stream not present");
+    printStreamNotPresent(StreamIdx == StreamTPI ? "TPI" : "IPI");
     return Error::success();
   }
 
+  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();
 
   if (DumpTypes || !Indices.empty()) {
if (SymbolError)
     return std::move(*SymbolError);
 
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpModuleSymsForPdb() {
   printHeader(P, "Symbols");
 
-  AutoIndent Indent(P);
-  if (!getPdb().hasPDBDbiStream()) {
-    P.formatLine("DBI Stream not present");
+  if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
     return Error::success();
   }
 
+  AutoIndent Indent(P);
   ExitOnError Err("Unexpected error processing symbols: ");
 
   auto &Ids = File.ids();
   auto &Types = File.types();
 
   iterateSymbolGroups(
       File, PrintScope{P, 2}, [&](uint32_t I, const SymbolGroup &Strings) {
         auto ExpectedModS = getModuleDebugStream(File.pdb(), I);
iterateSymbolGroups(
           return;
         }
       });
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpGSIRecords() {
   printHeader(P, "GSI Records");
-  AutoIndent Indent(P);
 
   if (File.isObj()) {
-    P.formatLine("Dumping Globals is not supported for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
   if (!getPdb().hasPDBSymbolStream()) {
-    P.formatLine("GSI Common Symbol Stream not present");
+    printStreamNotPresent("GSI Common Symbol");
     return Error::success();
   }
 
+  AutoIndent Indent(P);
+
   auto &Records = cantFail(getPdb().getPDBSymbolStream());
   auto &Types = File.types();
   auto &Ids = File.ids();
 
   P.printLine("Records");
   SymbolVisitorCallbackPipeline Pipeline;
   SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
   MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
 
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(Dumper);
   CVSymbolVisitor Visitor(Pipeline);
 
   BinaryStreamRef SymStream = Records.getSymbolArray().getUnderlyingStream();
   if (auto E = Visitor.visitSymbolStream(Records.getSymbolArray(), 0))
     return E;
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpGlobals() {
   printHeader(P, "Global Symbols");
-  AutoIndent Indent(P);
 
   if (File.isObj()) {
-    P.formatLine("Dumping Globals is not supported for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
   if (!getPdb().hasPDBGlobalsStream()) {
-    P.formatLine("Globals stream not present");
+    printStreamNotPresent("Globals");
     return Error::success();
   }
+
+  AutoIndent Indent(P);
   ExitOnError Err("Error dumping globals stream: ");
   auto &Globals = Err(getPdb().getPDBGlobalsStream());
 
   const GSIHashTable &Table = Globals.getGlobalsTable();
   Err(dumpSymbolsFromGSI(Table, opts::dump::DumpGlobalExtras));
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpPublics() {
   printHeader(P, "Public Symbols");
-  AutoIndent Indent(P);
 
   if (File.isObj()) {
-    P.formatLine("Dumping Globals is not supported for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
   if (!getPdb().hasPDBPublicsStream()) {
-    P.formatLine("Publics stream not present");
+    printStreamNotPresent("Publics");
     return Error::success();
   }
+
+  AutoIndent Indent(P);
   ExitOnError Err("Error dumping publics stream: ");
   auto &Publics = Err(getPdb().getPDBPublicsStream());
 
   const GSIHashTable &PublicsTable = Publics.getPublicsTable();
   if (opts::dump::DumpPublicExtras) {
     P.printLine("Publics Header");
     AutoIndent Indent(P);
     P.formatLine("sym hash = {0}, thunk table addr = {1}", Publics.getSymHash(),
Error DumpOutputStyle::dumpSectionHeaders() {
   dumpSectionHeaders("Section Headers", DbgHeaderType::SectionHdr);
   dumpSectionHeaders("Original Section Headers", DbgHeaderType::SectionHdrOrig);
   return Error::success();
 }
 
 void DumpOutputStyle::dumpSectionHeaders(StringRef Label, DbgHeaderType Type) {
   printHeader(P, Label);
 
-  AutoIndent Indent(P);
   if (File.isObj()) {
-    P.formatLine("Dumping Section Headers is not supported for object files");
+    printStreamNotValidForObj();
+    return;
+  }
+
+  if (!getPdb().hasPDBDbiStream()) {
+    printStreamNotPresent("DBI");
     return;
   }
 
+  AutoIndent Indent(P);
   ExitOnError Err("Error dumping section headers: ");
   std::unique_ptr<MappedBlockStream> Stream;
   ArrayRef<object::coff_section> Headers;
   auto ExpectedHeaders = loadSectionHeaders(getPdb(), Type);
   if (!ExpectedHeaders) {
     P.printLine(toString(ExpectedHeaders.takeError()));
     return;
   }
for (const auto &Header : Headers) {
     ++I;
   }
   return;
 }
 
 Error DumpOutputStyle::dumpSectionContribs() {
   printHeader(P, "Section Contributions");
 
-  AutoIndent Indent(P);
   if (File.isObj()) {
-    P.formatLine(
-        "Dumping section contributions is not supported for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
-  ExitOnError Err("Error dumping section contributions: ");
   if (!getPdb().hasPDBDbiStream()) {
-    P.formatLine(
-        "Section contribs require a DBI Stream, which could not be loaded");
+    printStreamNotPresent("DBI");
     return Error::success();
   }
 
+  AutoIndent Indent(P);
+  ExitOnError Err("Error dumping section contributions: ");
+
   auto &Dbi = Err(getPdb().getPDBDbiStream());
 
   class Visitor : public ISectionContribVisitor {
   public:
     Visitor(LinePrinter &P, ArrayRef<std::string> Names) : P(P), Names(Names) {
       auto Max = std::max_element(
           Names.begin(), Names.end(),
           [](StringRef S1, StringRef S2) { return S1.size() < S2.size(); });
Error DumpOutputStyle::dumpSectionContribs() {
   std::vector<std::string> Names = getSectionNames(getPdb());
   Visitor V(P, makeArrayRef(Names));
   Dbi.visitSectionContributions(V);
   return Error::success();
 }
 
 Error DumpOutputStyle::dumpSectionMap() {
   printHeader(P, "Section Map");
-  AutoIndent Indent(P);
 
   if (File.isObj()) {
-    P.formatLine("Dumping section map is not supported for object files");
+    printStreamNotValidForObj();
     return Error::success();
   }
 
-  ExitOnError Err("Error dumping section map: ");
-
   if (!getPdb().hasPDBDbiStream()) {
-    P.formatLine("Dumping the section map requires a DBI Stream, which could "
-                 "not be loaded");
+    printStreamNotPresent("DBI");
     return Error::success();
   }
 
+  AutoIndent Indent(P);
+  ExitOnError Err("Error dumping section map: ");
+
   auto &Dbi = Err(getPdb().getPDBDbiStream());
 
   uint32_t I = 0;
   for (auto &M : Dbi.getSectionMap()) {
     P.formatLine(
         "Section {0:4} | ovl = {1}, group = {2}, frame = {3}, name = {4}", I,
         fmtle(M.Ovl), fmtle(M.Group), fmtle(M.Frame), fmtle(M.SecName));
     P.formatLine("               class = {0}, offset = {1}, size = {2}",

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

 InputFile::~InputFile() {}
 
 static Expected<ModuleDebugStreamRef>
 getModuleDebugStream(PDBFile &File, StringRef &ModuleName, uint32_t Index) {
   ExitOnError Err("Unexpected error: ");
 
   auto &Dbi = Err(File.getPDBDbiStream());
   const auto &Modules = Dbi.modules();
+  if (Index >= Modules.getModuleCount())
+    return make_error<RawError>(raw_error_code::index_out_of_bounds,
+                                "Invalid module index");
+
   auto Modi = Modules.getModuleDescriptor(Index);
 
   ModuleName = Modi.getModuleName();
 
   uint16_t ModiStream = Modi.getModuleStreamIndex();
   if (ModiStream == kInvalidStreamIndex)
     return make_error<RawError>(raw_error_code::no_stream,
                                 "Module stream not present");

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

static opts::ModuleSubsection convertSubsectionKind(DebugSubsectionKind K) {
   }
   llvm_unreachable("Unreachable!");
 }
 
 Error YAMLOutputStyle::dumpDbiStream() {
   if (!opts::pdb2yaml::DbiStream)
     return Error::success();
 
+  if (!File.hasPDBDbiStream())
+    return Error::success();
+
   auto DbiS = File.getPDBDbiStream();
   if (!DbiS)
     return DbiS.takeError();
 
   auto &DS = DbiS.get();
   Obj.DbiStream.emplace();
   Obj.DbiStream->Age = DS.getAge();
   Obj.DbiStream->BuildNumber = DS.getBuildNumber();