[llvm-pdbutil] Dump image section headers

[zturner]

Summary

By dumping the image section headers that get written to the PDB, I'm also now able to write a test that LLD writes these image section headers to the PDB.

Unfortunately, I don't know of a good way to write a test that the values that get written correspond to the correct values in the actual executable.

[rnk]

lgtm

Thanks, I was looking for this yesterday. :)

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

1073

Should be "dumping section headers stream"

lld/test/COFF/pdb.test

 # RUN: yaml2obj < %p/Inputs/pdb1.yaml > %t1.obj
 # RUN: yaml2obj < %p/Inputs/pdb2.yaml > %t2.obj
 # RUN: lld-link /debug /pdb:%t.pdb /dll /out:%t.dll /entry:main /nodefaultlib \
 # RUN:   %t1.obj %t2.obj
 
 # RUN: llvm-pdbutil pdb2yaml -stream-metadata -stream-directory -pdb-stream \
 # RUN:   -dbi-stream -ipi-stream -tpi-stream %t.pdb | FileCheck %s
 
-# RUN: llvm-pdbutil dump -modules -section-map -section-contribs \
+# RUN: llvm-pdbutil dump -modules -section-map -section-contribs -section-headers \
 # RUN:   -publics -public-extras -types -ids -type-extras -id-extras %t.pdb \
 # RUN:   | FileCheck -check-prefix RAW %s
 
 # CHECK:      MSF:
 # CHECK-NEXT:   SuperBlock:
 # CHECK-NEXT:     BlockSize:       4096
 # CHECK-NEXT:     FreeBlockMap:    1
 # CHECK-NEXT:     NumBlocks:

 RAW-NEXT:    off = 21, refcnt = 1
 RAW-NEXT:    off = 1, refcnt = 1
 RAW-NEXT:  Hash Buckets
 RAW-NEXT:    0x00000000
 RAW-NEXT:    0x0000000c
 RAW-NEXT:  Address Map
 RAW-NEXT:    off = 20
 RAW-NEXT:    off = 0
+RAW:                            Section Headers
+RAW-NEXT: ============================================================
+RAW:        SECTION HEADER #1
+RAW-NEXT:     .pdata name
+RAW-NEXT:          C virtual size
+RAW-NEXT:       1000 virtual address
+RAW-NEXT:        200 size of raw data
+RAW-NEXT:        400 file pointer to raw data
+RAW-NEXT:          0 file pointer to relocation table
+RAW-NEXT:          0 file pointer to line numbers
+RAW-NEXT:          0 number of relocations
+RAW-NEXT:          0 number of line numbers
+RAW-NEXT:   40000040 flags
+RAW-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+RAW-NEXT:            IMAGE_SCN_MEM_READ
+RAW:        SECTION HEADER #2
+RAW-NEXT:      .text name
+RAW-NEXT:         16 virtual size
+RAW-NEXT:       2000 virtual address
+RAW-NEXT:        200 size of raw data
+RAW-NEXT:        600 file pointer to raw data
+RAW-NEXT:          0 file pointer to relocation table
+RAW-NEXT:          0 file pointer to line numbers
+RAW-NEXT:          0 number of relocations
+RAW-NEXT:          0 number of line numbers
+RAW-NEXT:   60000020 flags
+RAW-NEXT:            IMAGE_SCN_CNT_CODE
+RAW-NEXT:            IMAGE_SCN_MEM_EXECUTE
+RAW-NEXT:            IMAGE_SCN_MEM_READ
+RAW:        SECTION HEADER #3
+RAW-NEXT:     .xdata name
+RAW-NEXT:          8 virtual size
+RAW-NEXT:       3000 virtual address
+RAW-NEXT:        200 size of raw data
+RAW-NEXT:        800 file pointer to raw data
+RAW-NEXT:          0 file pointer to relocation table
+RAW-NEXT:          0 file pointer to line numbers
+RAW-NEXT:          0 number of relocations
+RAW-NEXT:          0 number of line numbers
+RAW-NEXT:   40000040 flags
+RAW-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+RAW-NEXT:            IMAGE_SCN_MEM_READ
+RAW:        SECTION HEADER #4
+RAW-NEXT:     .rdata name
+RAW-NEXT:         77 virtual size
+RAW-NEXT:       4000 virtual address
+RAW-NEXT:        200 size of raw data
+RAW-NEXT:        A00 file pointer to raw data
+RAW-NEXT:          0 file pointer to relocation table
+RAW-NEXT:          0 file pointer to line numbers
+RAW-NEXT:          0 number of relocations
+RAW-NEXT:          0 number of line numbers
+RAW-NEXT:   40000040 flags
+RAW-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+RAW-NEXT:            IMAGE_SCN_MEM_READ
+RAW:                        Original Section Headers
+RAW-NEXT: ============================================================
+RAW-NEXT:   PDB does not contain the requested image section header type
 RAW:                        Section Contributions
 RAW-NEXT: ============================================================
 RAW-NEXT:   SC  | mod = 0, 0001:0000, size = 12, data crc = 0, reloc crc = 0
 RAW-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ
 RAW-NEXT:   SC  | mod = 0, 0002:0000, size = 14, data crc = 0, reloc crc = 0
 RAW-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_EXECUTE |
 RAW-NEXT:         IMAGE_SCN_MEM_READ
 RAW-NEXT:   SC  | mod = 1, 0002:0016, size = 6, data crc = 0, reloc crc = 0
 RAW-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_EXECUTE |
 RAW-NEXT:         IMAGE_SCN_MEM_READ
 RAW-NEXT:   SC  | mod = 0, 0003:0000, size = 8, data crc = 0, reloc crc = 0
 RAW-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ
 RAW:                             Section Map
 RAW-NEXT: ============================================================
-RAW-NEXT:   Section 0000 | ovl = 0, group = 0, frame = 0, name = 1
+RAW-NEXT:   Section 0000 | ovl = 0, group = 0, frame = 1, name = 65535
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = read | 32 bit addr | selector
-RAW-NEXT:   Section 0001 | ovl = 1, group = 0, frame = 0, name = 2
+RAW-NEXT:   Section 0001 | ovl = 0, group = 0, frame = 2, name = 65535
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = read | execute | 32 bit addr | selector
-RAW-NEXT:   Section 0002 | ovl = 2, group = 0, frame = 0, name = 3
+RAW-NEXT:   Section 0002 | ovl = 0, group = 0, frame = 3, name = 65535
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = read | 32 bit addr | selector
-RAW-NEXT:   Section 0003 | ovl = 3, group = 0, frame = 0, name = 4
+RAW-NEXT:   Section 0003 | ovl = 0, group = 0, frame = 4, name = 65535
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = read | 32 bit addr | selector
-RAW-NEXT:   Section 0004 | ovl = 4, group = 0, frame = 0, name = 5
+RAW-NEXT:   Section 0004 | ovl = 0, group = 0, frame = 5, name = 65535
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = 32 bit addr | absolute addr

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

+RUN: llvm-pdbutil dump -section-headers %p/Inputs/empty.pdb | FileCheck %s
+
+CHECK:                       Section Headers
+CHECK-NEXT: ============================================================
+CHECK-LABEL:  SECTION HEADER #1
+CHECK-NEXT:      .text name
+CHECK-NEXT:       101A virtual size
+CHECK-NEXT:       1000 virtual address
+CHECK-NEXT:       1200 size of raw data
+CHECK-NEXT:        400 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   60000020 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_CODE
+CHECK-NEXT:            IMAGE_SCN_MEM_EXECUTE
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
+
+CHECK-LABEL:  SECTION HEADER #2
+CHECK-NEXT:     .rdata name
+CHECK-NEXT:        2B2 virtual size
+CHECK-NEXT:       3000 virtual address
+CHECK-NEXT:        400 size of raw data
+CHECK-NEXT:       1600 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   40000040 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
+
+CHECK-LABEL:  SECTION HEADER #3
+CHECK-NEXT:      .data name
+CHECK-NEXT:          4 virtual size
+CHECK-NEXT:       4000 virtual address
+CHECK-NEXT:          0 size of raw data
+CHECK-NEXT:          0 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   C0000040 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
+CHECK-NEXT:            IMAGE_SCN_MEM_WRITE
+
+CHECK-LABEL:  SECTION HEADER #4
+CHECK-NEXT:     .reloc name
+CHECK-NEXT:          8 virtual size
+CHECK-NEXT:       5000 virtual address
+CHECK-NEXT:        200 size of raw data
+CHECK-NEXT:       1A00 file pointer to raw data
+CHECK-NEXT:          0 file pointer to relocation table
+CHECK-NEXT:          0 file pointer to line numbers
+CHECK-NEXT:          0 number of relocations
+CHECK-NEXT:          0 number of line numbers
+CHECK-NEXT:   42000040 flags
+CHECK-NEXT:            IMAGE_SCN_CNT_INITIALIZED_DATA
+CHECK-NEXT:            IMAGE_SCN_MEM_DISCARDABLE
+CHECK-NEXT:            IMAGE_SCN_MEM_READ
+
+CHECK:                        Original Section Headers
+CHECK-NEXT: ============================================================
+CHECK-NEXT:   PDB does not contain the requested image section header type

llvm/tools/llvm-pdbutil/DumpOutputStyle.h

 #ifndef LLVM_TOOLS_LLVMPDBDUMP_DUMPOUTPUTSTYLE_H
 #define LLVM_TOOLS_LLVMPDBDUMP_DUMPOUTPUTSTYLE_H
 
 #include "LinePrinter.h"
 #include "OutputStyle.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 
 #include <string>
 
 namespace llvm {
 class BitVector;
 
 namespace codeview {
 class LazyRandomTypeCollection;
private:
   Error dumpXme();
   Error dumpTpiStream(uint32_t StreamIdx);
   Error dumpModules();
   Error dumpModuleFiles();
   Error dumpModuleSyms();
   Error dumpGlobals();
   Error dumpPublics();
   Error dumpSymbolsFromGSI(const GSIHashTable &Table, bool HashExtras);
+  Error dumpSectionHeaders();
   Error dumpSectionContribs();
   Error dumpSectionMap();
 
+  void dumpSectionHeaders(StringRef Label, DbgHeaderType Type);
+
   PDBFile &File;
   LinePrinter P;
   std::unique_ptr<codeview::LazyRandomTypeCollection> TpiTypes;
   std::unique_ptr<codeview::LazyRandomTypeCollection> IpiTypes;
   SmallVector<std::string, 32> StreamPurposes;
 };
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

if (auto EC = dumpPublics())
       return EC;
   }
 
   if (opts::dump::DumpSymbols) {
     if (auto EC = dumpModuleSyms())
       return EC;
   }
 
+  if (opts::dump::DumpSectionHeaders) {
+    if (auto EC = dumpSectionHeaders())
+      return EC;
+  }
+
   if (opts::dump::DumpSectionContribs) {
     if (auto EC = dumpSectionContribs())
       return EC;
   }
 
   if (opts::dump::DumpSectionMap) {
     if (auto EC = dumpSectionMap())
       return EC;
P.formatLine("Hash Buckets");
     for (uint32_t Hash : Table.HashBuckets)
       P.formatLine("{0:x8}", Hash);
   }
 
   return Error::success();
 }
 
 static std::string formatSectionCharacteristics(uint32_t IndentLevel,
-                                                uint32_t C) {
+                                                uint32_t C,
+                                                uint32_t FlagsPerLine,
+                                                StringRef Separator) {
   using SC = COFF::SectionCharacteristics;
   std::vector<std::string> Opts;
   if (C == COFF::SC_Invalid)
     return "invalid";
   if (C == 0)
     return "none";
 
   PUSH_FLAG(SC, IMAGE_SCN_TYPE_NOLOAD, C, "IMAGE_SCN_TYPE_NOLOAD");
static std::string formatSectionCharacteristics(uint32_t IndentLevel,
   PUSH_FLAG(SC, IMAGE_SCN_LNK_NRELOC_OVFL, C, "IMAGE_SCN_LNK_NRELOC_OVFL");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_DISCARDABLE, C, "IMAGE_SCN_MEM_DISCARDABLE");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_NOT_CACHED, C, "IMAGE_SCN_MEM_NOT_CACHED");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_NOT_PAGED, C, "IMAGE_SCN_MEM_NOT_PAGED");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_SHARED, C, "IMAGE_SCN_MEM_SHARED");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_EXECUTE, C, "IMAGE_SCN_MEM_EXECUTE");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_READ, C, "IMAGE_SCN_MEM_READ");
   PUSH_FLAG(SC, IMAGE_SCN_MEM_WRITE, C, "IMAGE_SCN_MEM_WRITE");
-  return typesetItemList(Opts, IndentLevel, 3, " | ");
+  return typesetItemList(Opts, IndentLevel, FlagsPerLine, Separator);
 }
 
 static std::string formatSegMapDescriptorFlag(uint32_t IndentLevel,
                                               OMFSegDescFlags Flags) {
   std::vector<std::string> Opts;
   if (Flags == OMFSegDescFlags::None)
     return "none";
 
   PUSH_FLAG(OMFSegDescFlags, Read, Flags, "read");
   PUSH_FLAG(OMFSegDescFlags, Write, Flags, "write");
   PUSH_FLAG(OMFSegDescFlags, Execute, Flags, "execute");
   PUSH_FLAG(OMFSegDescFlags, AddressIs32Bit, Flags, "32 bit addr");
   PUSH_FLAG(OMFSegDescFlags, IsSelector, Flags, "selector");
   PUSH_FLAG(OMFSegDescFlags, IsAbsoluteAddress, Flags, "absolute addr");
   PUSH_FLAG(OMFSegDescFlags, IsGroup, Flags, "group");
   return typesetItemList(Opts, IndentLevel, 4, " | ");
 }
 
+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);
+  ExitOnError Err("Error dumping publics stream: ");
+
+  AutoIndent Indent(P);
+  if (!File.hasPDBDbiStream()) {
+    P.formatLine(
+        "Section headers require a DBI Stream, which could not be loaded");
+    return;
+  }
+
+  auto &Dbi = Err(File.getPDBDbiStream());
+  uint32_t SI = Dbi.getDebugStreamIndex(Type);
+
+  if (SI == kInvalidStreamIndex) {
+    P.formatLine(
+        "PDB does not contain the requested image section header type");
+    return;
+  }
+
+  auto Stream = MappedBlockStream::createIndexedStream(
+      File.getMsfLayout(), File.getMsfBuffer(), SI, File.getAllocator());
+  if (!Stream) {
+    P.formatLine("Could not load the required stream data");
+    return;
+  }
+  ArrayRef<object::coff_section> Headers;
+  if (Stream->getLength() % sizeof(object::coff_section) != 0) {
+    P.formatLine(
+        "Section header array size is not a multiple of section header size");
+    return;
+  }
+  uint32_t NumHeaders = Stream->getLength() / sizeof(object::coff_section);
+  BinaryStreamReader Reader(*Stream);
+  cantFail(Reader.readArray(Headers, NumHeaders));
+  if (Headers.empty()) {
+    P.formatLine("No section headers");
+    return;
+  }
+
+  uint32_t I = 1;
+  for (const auto &Header : Headers) {
+    P.NewLine();
+    P.formatLine("SECTION HEADER #{0}", I);
+    P.formatLine("{0,8} name", Header.Name);
+    P.formatLine("{0,8:X-} virtual size", uint32_t(Header.VirtualSize));
+    P.formatLine("{0,8:X-} virtual address", uint32_t(Header.VirtualAddress));
+    P.formatLine("{0,8:X-} size of raw data", uint32_t(Header.SizeOfRawData));
+    P.formatLine("{0,8:X-} file pointer to raw data",
+                 uint32_t(Header.PointerToRawData));
+    P.formatLine("{0,8:X-} file pointer to relocation table",
+                 uint32_t(Header.PointerToRelocations));
+    P.formatLine("{0,8:X-} file pointer to line numbers",
+                 uint32_t(Header.PointerToLinenumbers));
+    P.formatLine("{0,8:X-} number of relocations",
+                 uint32_t(Header.NumberOfRelocations));
+    P.formatLine("{0,8:X-} number of line numbers",
+                 uint32_t(Header.NumberOfLinenumbers));
+    P.formatLine("{0,8:X-} flags", uint32_t(Header.Characteristics));
+    AutoIndent IndentMore(P, 9);
+    P.formatLine("{0}", formatSectionCharacteristics(
+                            P.getIndentLevel(), Header.Characteristics, 1, ""));
+    ++I;
+  }
+  return;
+}
+
 Error DumpOutputStyle::dumpSectionContribs() {
   printHeader(P, "Section Contributions");
   ExitOnError Err("Error dumping publics stream: ");
 
   AutoIndent Indent(P);
   if (!File.hasPDBDbiStream()) {
     P.formatLine(
         "Section contribs require a DBI Stream, which could not be loaded");
     return Error::success();
   }
 
   auto &Dbi = Err(File.getPDBDbiStream());
 
   class Visitor : public ISectionContribVisitor {
   public:
     Visitor(LinePrinter &P) : P(P) {}
     void visit(const SectionContrib &SC) override {
       P.formatLine(
           "SC  | mod = {2}, {0}, size = {1}, data crc = {3}, reloc crc = {4}",
           formatSegmentOffset(SC.ISect, SC.Off), fmtle(SC.Size), fmtle(SC.Imod),
           fmtle(SC.DataCrc), fmtle(SC.RelocCrc));
       P.formatLine("      {0}",
                    formatSectionCharacteristics(P.getIndentLevel() + 6,
-                                                SC.Characteristics));
+                                                SC.Characteristics, 3, " | "));
     }
     void visit(const SectionContrib2 &SC) override {
       P.formatLine("SC2 | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
                    "crc = {4}, coff section = {5}",
                    formatSegmentOffset(SC.Base.ISect, SC.Base.Off),
                    fmtle(SC.Base.Size), fmtle(SC.Base.Imod),
                    fmtle(SC.Base.DataCrc), fmtle(SC.Base.RelocCrc),
                    fmtle(SC.ISectCoff));
-      P.formatLine("      {0}",
-                   formatSectionCharacteristics(P.getIndentLevel() + 6,
-                                                SC.Base.Characteristics));
+      P.formatLine("      {0}", formatSectionCharacteristics(
+                                    P.getIndentLevel() + 6,
+                                    SC.Base.Characteristics, 3, " | "));
     }
 
   private:
     LinePrinter &P;
   };
 
   Visitor V(P);
   Dbi.visitSectionContributions(V);
if (!File.hasPDBDbiStream()) {
     return Error::success();
   }
 
   auto &Dbi = Err(File.getPDBDbiStream());
 
   uint32_t I = 0;
   for (auto &M : Dbi.getSectionMap()) {
     P.formatLine(
-        "Section {0:4} | ovl = {0}, group = {1}, frame = {2}, name = {3}", I,
+        "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}",
                  fmtle(M.ClassName), fmtle(M.Offset), fmtle(M.SecByteLength));
     P.formatLine("               flags = {0}",
                  formatSegMapDescriptorFlag(
                      P.getIndentLevel() + 13,
                      static_cast<OMFSegDescFlags>(uint16_t(M.Flags))));
     ++I;
   }
   return Error::success();
 }

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

 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> 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> DumpSymbols;
 extern llvm::cl::opt<bool> DumpSymRecordBytes;

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

cl::opt<bool> DumpStringTable("string-table", cl::desc("dump PDB String Table"),
                               cl::cat(MiscOptions), cl::sub(DumpSubcommand));
 
 cl::opt<bool> DumpSectionContribs("section-contribs",
                                   cl::desc("dump section contributions"),
                                   cl::cat(MiscOptions),
                                   cl::sub(DumpSubcommand));
 cl::opt<bool> DumpSectionMap("section-map", cl::desc("dump section map"),
                              cl::cat(MiscOptions), cl::sub(DumpSubcommand));
+cl::opt<bool> DumpSectionHeaders("section-headers",
+                                 cl::desc("Dump image section headers"),
+                                 cl::cat(MiscOptions), cl::sub(DumpSubcommand));
 
 cl::opt<bool> RawAll("all", cl::desc("Implies most other options."),
                      cl::cat(MiscOptions), cl::sub(DumpSubcommand));
 
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input PDB files>"),
                                      cl::OneOrMore, cl::sub(DumpSubcommand));
 }
if (opts::dump::RawAll) {
       opts::dump::DumpIds = true;
       opts::dump::DumpGlobals = true;
       opts::dump::DumpPublics = true;
       opts::dump::DumpSectionContribs = true;
       opts::dump::DumpSectionMap = true;
       opts::dump::DumpStreams = true;
       opts::dump::DumpStreamBlocks = true;
       opts::dump::DumpStringTable = true;
+      opts::dump::DumpSectionHeaders = true;
       opts::dump::DumpSummary = true;
       opts::dump::DumpSymbols = true;
       opts::dump::DumpIds = true;
       opts::dump::DumpIdExtras = true;
       opts::dump::DumpTypes = true;
       opts::dump::DumpTypeExtras = true;
       opts::dump::DumpModules = true;
       opts::dump::DumpModuleFiles = true;