pdbdump: print out COFF section headers.

[ruiu]

Summary

Unlike other sections that can grow to any size, the COFF section header
stream has maximum length because each record is fixed size and the COFF
file format limits the maximum number of sections. So I decided to not
create a specific stream class for it. Instead, I added a member function
to PDBFile class which returns a vector of COFF headers.

I think it is enough, but I'm open to other options, so let me know if
you think the other way.

[majnemer]

tools/llvm-pdbdump/llvm-pdbdump.cpp

638

Might be nice to dump the flags.

[zturner]

Admittedly these section headers aren't too big, but if we want to standardize on the new stream interface stuff, maybe you can wait until my memory patch goes in, and then use FixedStreamArray<object::coff_section>.

Eventually I'd like to even delete the methods of StreamReader that allocate memory

[zturner]

It's in now as of r270951, btw, so sync up and see if it works.

[ruiu]

• Updated to use FixedArrayStream.

[zturner]

Sorry again for the delay, kept forgetting about this.

include/llvm/DebugInfo/PDB/Raw/PDBFile.h

79–80

I don't think this should go in PDBFile. Seems to me like it should be accessible from DBIStream.

lib/DebugInfo/PDB/Raw/PDBFile.cpp

341

It's going to do this each time someone calls the function. Now that everything is using StreamRef and zero-copy, there is no overhead to creating the FixedStreamArray up front, because it's not actually parsing anything until you iterate the collection.

So I would move this all to DBIStream (as mentioned earlier) and parse this at the time you call reload. Since that doesn't actually parse anything, you can do it once and just store the FixedStreamArray inside of DBIStream class and return it through a trivial accessor.

[ruiu]

include/llvm/DebugInfo/PDB/Raw/PDBFile.h

79–80

So is publics stream?

lib/DebugInfo/PDB/Raw/PDBFile.cpp

341

Ah, that sounds like a good idea. Will do.

[zturner]

include/llvm/DebugInfo/PDB/Raw/PDBFile.h

79–80

I think publics stream is fine at the top level. After all, it is a top-level stream, you just have to look in the DBI stream to figure out its index. The coff section headers though is just an array that is embedded entirely inside the DBI Stream.

It's kind of a judgement call though, I wouldn't object to publics stream being accessible from DBI stream, but I think "streams" are the only thing that should be accessible from the file.

[ruiu]

• Move getSectionHeaders function from PDBFile to DbiStream.

include/llvm/DebugInfo/PDB/Raw/PDBFile.h

 #include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 
 #include <memory>
 
 namespace llvm {
 class MemoryBuffer;
 
+namespace codeview {
+template <typename T> class FixedStreamArray;
+}
+
+namespace object {
+struct coff_section;
+}
+
 namespace pdb {
 struct PDBFileContext;
 class DbiStream;
 class InfoStream;
+class MappedBlockStream;
 class PublicsStream;
 class SymbolStream;
 class TpiStream;
 
 class PDBFile {
 public:
   explicit PDBFile(std::unique_ptr<MemoryBuffer> MemBuffer);
   ~PDBFile();
public:
   }
 
   Expected<InfoStream &> getPDBInfoStream();
   Expected<DbiStream &> getPDBDbiStream();
   Expected<TpiStream &> getPDBTpiStream();
   Expected<TpiStream &> getPDBIpiStream();
   Expected<PublicsStream &> getPDBPublicsStream();
   Expected<SymbolStream &> getPDBSymbolStream();
+  Expected<codeview::FixedStreamArray<object::coff_section>>
+      getPDBSectionHeaders();
 
 private:
   std::unique_ptr<PDBFileContext> Context;
   std::unique_ptr<InfoStream> Info;
   std::unique_ptr<DbiStream> Dbi;
   std::unique_ptr<TpiStream> Tpi;
   std::unique_ptr<TpiStream> Ipi;
   std::unique_ptr<PublicsStream> Publics;
   std::unique_ptr<SymbolStream> Symbols;
+  std::unique_ptr<MappedBlockStream> SectionHeaders;
 };
 }
 }
 
 #endif

lib/DebugInfo/PDB/Raw/PDBFile.cpp

 //===- PDBFile.cpp - Low level interface to a PDB file ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/DebugInfo/CodeView/StreamArray.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/SymbolStream.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 namespace {
 static const char Magic[] = {'M',  'i',  'c',    'r', 'o', 's',  'o',  'f',
if (!Symbols) {
     uint32_t SymbolStreamNum = DbiS->getSymRecordStreamIndex();
 
     Symbols.reset(new SymbolStream(*this, SymbolStreamNum));
     if (auto EC = Symbols->reload())
       return std::move(EC);
   }
   return *Symbols;
 }
+
+Expected<codeview::FixedStreamArray<object::coff_section>>
+PDBFile::getPDBSectionHeaders() {
+  if (!SectionHeaders) {
+    auto DbiS = getPDBDbiStream();
+    if (auto EC = DbiS.takeError())
+      return std::move(EC);
+    uint32_t StreamNum = DbiS->getDebugStreamIndex(DbgHeaderType::SectionHdr);
+    SectionHeaders.reset(new MappedBlockStream(StreamNum, *this));
+  }
+
+  size_t StreamLen = SectionHeaders->getLength();
+  if (StreamLen % sizeof(object::coff_section))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Corrupted section header stream.");
+
+  size_t NumSections = StreamLen / sizeof(object::coff_section);
+  codeview::StreamReader Reader(*SectionHeaders);
+  codeview::FixedStreamArray<object::coff_section> Sections;
+  if (auto EC = Reader.readArray(Sections, NumSections))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Could not read a bitmap.");
+  return Sections;
+}

test/DebugInfo/PDB/pdbdump-headers.test

 ; RUN: llvm-pdbdump -raw-headers -raw-tpi-records -raw-tpi-record-bytes -raw-module-syms \
 ; RUN:              -raw-sym-record-bytes -raw-publics -raw-module-files -raw-stream-name=/names \
 ; RUN:              -raw-stream-summary -raw-stream-blocks -raw-ipi-records -raw-ipi-record-bytes \
-; RUN:              %p/Inputs/empty.pdb \
+; RUN:              -raw-section-headers %p/Inputs/empty.pdb \
 ; RUN:              | FileCheck -check-prefix=EMPTY %s
 ; RUN: llvm-pdbdump -raw-all %p/Inputs/empty.pdb | FileCheck -check-prefix=ALL %s
 ; RUN: llvm-pdbdump -raw-headers -raw-stream-name=/names -raw-modules -raw-module-files \
 ; RUN:              %p/Inputs/big-read.pdb | FileCheck -check-prefix=BIG %s
 ; RUN: llvm-pdbdump -raw-headers %p/Inputs/bad-block-size.pdb | FileCheck -check-prefix=BAD-BLOCK-SIZE %s
 
 ; EMPTY:      FileHeaders {
 ; EMPTY-NEXT:   BlockSize: 4096

 ; EMPTY-NEXT:       }
 ; EMPTY-NEXT:       Bytes (
 ; EMPTY-NEXT:         0000: 03040000 00000000 03005F5F 70757265  |..........__pure|
 ; EMPTY-NEXT:         0010: 63616C6C 00000000                    |call....|
 ; EMPTY-NEXT:       )
 ; EMPTY-NEXT:     }
 ; EMPTY-NEXT:   ]
 ; EMPTY-NEXT: }
+; EMPTY-NEXT: Section Headers [
+; EMPTY-NEXT:   {
+; EMPTY-NEXT:     Name: .text
+; EMPTY-NEXT:     Virtual Size: 4122
+; EMPTY-NEXT:     Virtual Address: 4096
+; EMPTY-NEXT:     Size of Raw Data: 4608
+; EMPTY-NEXT:     File Pointer to Raw Data: 1024
+; EMPTY-NEXT:     File Pointer to Relocations: 0
+; EMPTY-NEXT:     File Pointer to Linenumbers: 0
+; EMPTY-NEXT:     Number of Relocations: 0
+; EMPTY-NEXT:     Number of Linenumbers: 0
+; EMPTY-NEXT:     Characteristics: 1610612768
+; EMPTY-NEXT:   }
+; EMPTY-NEXT:   {
+; EMPTY-NEXT:     Name: .rdata
+; EMPTY-NEXT:     Virtual Size: 690
+; EMPTY-NEXT:     Virtual Address: 12288
+; EMPTY-NEXT:     Size of Raw Data: 1024
+; EMPTY-NEXT:     File Pointer to Raw Data: 5632
+; EMPTY-NEXT:     File Pointer to Relocations: 0
+; EMPTY-NEXT:     File Pointer to Linenumbers: 0
+; EMPTY-NEXT:     Number of Relocations: 0
+; EMPTY-NEXT:     Number of Linenumbers: 0
+; EMPTY-NEXT:     Characteristics: 1073741888
+; EMPTY-NEXT:   }
+; EMPTY-NEXT:   {
+; EMPTY-NEXT:     Name: .data
+; EMPTY-NEXT:     Virtual Size: 4
+; EMPTY-NEXT:     Virtual Address: 16384
+; EMPTY-NEXT:     Size of Raw Data: 0
+; EMPTY-NEXT:     File Pointer to Raw Data: 0
+; EMPTY-NEXT:     File Pointer to Relocations: 0
+; EMPTY-NEXT:     File Pointer to Linenumbers: 0
+; EMPTY-NEXT:     Number of Relocations: 0
+; EMPTY-NEXT:     Number of Linenumbers: 0
+; EMPTY-NEXT:     Characteristics: 3221225536
+; EMPTY-NEXT:   }
+; EMPTY-NEXT:   {
+; EMPTY-NEXT:     Name: .reloc
+; EMPTY-NEXT:     Virtual Size: 8
+; EMPTY-NEXT:     Virtual Address: 20480
+; EMPTY-NEXT:     Size of Raw Data: 512
+; EMPTY-NEXT:     File Pointer to Raw Data: 6656
+; EMPTY-NEXT:     File Pointer to Relocations: 0
+; EMPTY-NEXT:     File Pointer to Linenumbers: 0
+; EMPTY-NEXT:     Number of Relocations: 0
+; EMPTY-NEXT:     Number of Linenumbers: 0
+; EMPTY-NEXT:     Characteristics: 1107296320
+; EMPTY-NEXT:   }
+; EMPTY-NEXT: ]
 
 ; ALL: FileHeaders {
 ; ALL:   BlockSize: 4096
 ; ALL:   Unknown0: 2
 ; ALL:   NumBlocks: 25
 ; ALL:   NumDirectoryBytes: 136
 ; ALL:   Unknown1: 0
 ; ALL:   BlockMapAddr: 24

 ; ALL:             BuildId: 4110
 ; ALL:           }
 ; ALL:         }
 ; ALL:       ]
 ; ALL:     }
 ; ALL:     {
 ; ALL:       Name: * Linker *
 ; ALL:       Debug Stream Index: 14
-; ALL:       Object File Name: 
+; ALL:       Object File Name:
 ; ALL:       Num Files: 0
 ; ALL:       Source File Name Idx: 0
 ; ALL:       Pdb File Name Idx: 1
 ; ALL:       Line Info Byte Size: 0
 ; ALL:       C13 Line Info Byte Size: 0
 ; ALL:       Symbol Byte Size: 516
 ; ALL:       Type Server Index: 0
 ; ALL:       Has EC Info: No

 ; ALL:     {
 ; ALL:       DataSym {
 ; ALL:         Type: void* (0x403)
 ; ALL:         DisplayName: __purecall
 ; ALL:       }
 ; ALL:     }
 ; ALL:   ]
 ; ALL: }
+; ALL: Section Headers [
+; ALL:   {
+; ALL:     Name: .text
+; ALL:     Virtual Size: 4122
+; ALL:     Virtual Address: 4096
+; ALL:     Size of Raw Data: 4608
+; ALL:     File Pointer to Raw Data: 1024
+; ALL:     File Pointer to Relocations: 0
+; ALL:     File Pointer to Linenumbers: 0
+; ALL:     Number of Relocations: 0
+; ALL:     Number of Linenumbers: 0
+; ALL:     Characteristics: 1610612768
+; ALL:   }
+; ALL:   {
+; ALL:     Name: .rdata
+; ALL:     Virtual Size: 690
+; ALL:     Virtual Address: 12288
+; ALL:     Size of Raw Data: 1024
+; ALL:     File Pointer to Raw Data: 5632
+; ALL:     File Pointer to Relocations: 0
+; ALL:     File Pointer to Linenumbers: 0
+; ALL:     Number of Relocations: 0
+; ALL:     Number of Linenumbers: 0
+; ALL:     Characteristics: 1073741888
+; ALL:   }
+; ALL:   {
+; ALL:     Name: .data
+; ALL:     Virtual Size: 4
+; ALL:     Virtual Address: 16384
+; ALL:     Size of Raw Data: 0
+; ALL:     File Pointer to Raw Data: 0
+; ALL:     File Pointer to Relocations: 0
+; ALL:     File Pointer to Linenumbers: 0
+; ALL:     Number of Relocations: 0
+; ALL:     Number of Linenumbers: 0
+; ALL:     Characteristics: 3221225536
+; ALL:   }
+; ALL:   {
+; ALL:     Name: .reloc
+; ALL:     Virtual Size: 8
+; ALL:     Virtual Address: 20480
+; ALL:     Size of Raw Data: 512
+; ALL:     File Pointer to Raw Data: 6656
+; ALL:     File Pointer to Relocations: 0
+; ALL:     File Pointer to Linenumbers: 0
+; ALL:     Number of Relocations: 0
+; ALL:     Number of Linenumbers: 0
+; ALL:     Characteristics: 1107296320
+; ALL:   }
+; ALL: ]
 
 ; BIG:      FileHeaders {
 ; BIG-NEXT:   BlockSize: 4096
 ; BIG-NEXT:   Unknown0: 2
 ; BIG-NEXT:   NumBlocks: 99
 ; BIG-NEXT:   NumDirectoryBytes: 616
 ; BIG-NEXT:   Unknown1: 0
 ; BIG-NEXT:   BlockMapAddr: 97

tools/llvm-pdbdump/llvm-pdbdump.cpp

 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/ModStream.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/RawSession.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <string.h>
+
 #if defined(HAVE_DIA_SDK)
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #include <Windows.h>
 #endif
 
 using namespace llvm;

 cl::opt<bool> DumpModuleSyms("raw-module-syms", cl::desc("dump module symbols"),
                              cl::cat(NativeOptions));
 cl::opt<bool> DumpPublics("raw-publics", cl::desc("dump Publics stream data"),
                           cl::cat(NativeOptions));
 cl::opt<bool>
     DumpSymRecordBytes("raw-sym-record-bytes",
                        cl::desc("dump CodeView symbol record raw bytes"),
                        cl::cat(NativeOptions));
+cl::opt<bool> DumpSectionHeaders("raw-section-headers",
+                                 cl::desc("dump section headers"),
+                                 cl::cat(NativeOptions));
+
 cl::opt<bool>
     RawAll("raw-all",
            cl::desc("Implies most other options in 'Native Options' category"),
            cl::cat(NativeOptions));
 
 cl::list<std::string>
     ExcludeTypes("exclude-types",
                  cl::desc("Exclude types by regular expression"),
for (auto S : Publics.getSymbols()) {
 
     SD.dump(S);
     if (opts::DumpSymRecordBytes)
       P.printBinaryBlock("Bytes", S.Data);
   }
   return Error::success();
 }
 
+static Error dumpSectionHeaders(ScopedPrinter &P, PDBFile &File,
+                                codeview::CVTypeDumper &TD) {
+  if (!opts::DumpSectionHeaders)
+    return Error::success();
+
+  ListScope D(P, "Section Headers");
+  auto SectionsS = File.getPDBSectionHeaders();
+  if (auto EC = SectionsS.takeError())
+    return EC;
+  for (const object::coff_section &Section : SectionsS.get()) {
+    DictScope DD(P, "");
+
+    // If a name is 8 characters long, there is no NUL character at end.
+    StringRef Name(Section.Name, strnlen(Section.Name, sizeof(Section.Name)));
+    P.printString("Name", Name);
+    P.printNumber("Virtual Size", Section.VirtualSize);
+    P.printNumber("Virtual Address", Section.VirtualAddress);
+    P.printNumber("Size of Raw Data", Section.SizeOfRawData);
+    P.printNumber("File Pointer to Raw Data", Section.PointerToRawData);
+    P.printNumber("File Pointer to Relocations", Section.PointerToRelocations);
+    P.printNumber("File Pointer to Linenumbers", Section.PointerToLinenumbers);
+    P.printNumber("Number of Relocations", Section.NumberOfRelocations);
+    P.printNumber("Number of Linenumbers", Section.NumberOfLinenumbers);
+    P.printNumber("Characteristics", Section.Characteristics);
+  }
+  return Error::success();
+}
+
 static Error dumpStructure(RawSession &RS) {
   PDBFile &File = RS.getPDBFile();
   ScopedPrinter P(outs());
 
   if (auto EC = dumpFileHeaders(P, File))
     return EC;
 
   if (auto EC = dumpStreamSummary(P, File))
if (auto EC = dumpInfoStream(P, File))
     return EC;
 
   if (auto EC = dumpNamedStream(P, File))
     return EC;
 
   codeview::CVTypeDumper TD(P, false);
   if (auto EC = dumpTpiStream(P, File, TD, StreamTPI))
     return EC;
+
   if (auto EC = dumpTpiStream(P, File, TD, StreamIPI))
     return EC;
 
   if (auto EC = dumpDbiStream(P, File, TD))
     return EC;
 
   if (auto EC = dumpPublicsStream(P, File, TD))
     return EC;
+
+  if (auto EC = dumpSectionHeaders(P, File, TD))
+    return EC;
   return Error::success();
 }
 
 bool isRawDumpEnabled() {
   if (opts::DumpHeaders)
     return true;
   if (opts::DumpModules)
     return true;
int main(int argc_, const char *argv_[]) {
   }
 
   if (opts::RawAll) {
     opts::DumpHeaders = true;
     opts::DumpModules = true;
     opts::DumpModuleFiles = true;
     opts::DumpModuleSyms = true;
     opts::DumpPublics = true;
+    opts::DumpSectionHeaders = true;
     opts::DumpStreamSummary = true;
     opts::DumpStreamBlocks = true;
     opts::DumpTpiRecords = true;
     opts::DumpIpiRecords = 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