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

632 ↗

(On Diff #58741)

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 ↗

(On Diff #58790)

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 ↗

(On Diff #58790)

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 ↗

(On Diff #58790)

So is publics stream?

lib/DebugInfo/PDB/Raw/PDBFile.cpp

341 ↗

(On Diff #58790)

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

[zturner]

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

79–80 ↗

(On Diff #58790)

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.

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/DbiStream.h

 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
+namespace object {
+struct coff_section;
+}
+
 namespace pdb {
 class PDBFile;
 class ISectionContribVisitor;
 
 class DbiStream {
   struct HeaderInfo;
 
 public:
public:
   uint32_t getSymRecordStreamIndex() const;
 
   PDB_Machine getMachineType() const;
 
   uint32_t getDebugStreamIndex(DbgHeaderType Type) const;
 
   ArrayRef<ModuleInfoEx> modules() const;
 
+  codeview::FixedStreamArray<object::coff_section> getSectionHeaders();
+
   codeview::FixedStreamArray<SecMapEntry> getSectionMap() const;
   void visitSectionContributions(ISectionContribVisitor &Visitor) const;
 
 private:
   Error initializeSectionContributionData();
+  Error initializeSectionHeadersData();
   Error initializeSectionMapData();
   Error initializeFileInfo();
 
   PDBFile &Pdb;
   MappedBlockStream Stream;
 
   std::vector<ModuleInfoEx> ModuleInfos;
   NameHashTable ECNames;
 
   codeview::StreamRef ModInfoSubstream;
   codeview::StreamRef SecContrSubstream;
   codeview::StreamRef SecMapSubstream;
   codeview::StreamRef FileInfoSubstream;
   codeview::StreamRef TypeServerMapSubstream;
   codeview::StreamRef ECSubstream;
 
   codeview::FixedStreamArray<support::ulittle16_t> DbgStreams;
 
   PdbRaw_DbiSecContribVer SectionContribVersion;
   codeview::FixedStreamArray<SectionContrib> SectionContribs;
   codeview::FixedStreamArray<SectionContrib2> SectionContribs2;
   codeview::FixedStreamArray<SecMapEntry> SectionMap;
 
+  std::unique_ptr<MappedBlockStream> SectionHeaderStream;
+  codeview::FixedStreamArray<object::coff_section> SectionHeaders;
+
   const HeaderInfo *Header;
 };
 }
 }
 
 #endif

llvm/trunk/lib/DebugInfo/PDB/Raw/DbiStream.cpp

 //===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
 //
 //                     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/DbiStream.h"
 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
+#include "llvm/Object/COFF.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
 namespace {
 // Some of the values are stored in bitfields.  Since this needs to be portable
Error DbiStream::reload() {
   if (auto EC = Reader.readStreamRef(ECSubstream, Header->ECSubstreamSize))
     return EC;
   if (auto EC = Reader.readArray(DbgStreams, Header->OptionalDbgHdrSize /
                                                  sizeof(ulittle16_t)))
     return EC;
 
   if (auto EC = initializeSectionContributionData())
     return EC;
-
+  if (auto EC = initializeSectionHeadersData())
+    return EC;
   if (auto EC = initializeSectionMapData())
     return EC;
 
   if (auto EC = initializeFileInfo())
     return EC;
 
   if (Reader.bytesRemaining() > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
uint32_t DbiStream::getSymRecordStreamIndex() const {
   return Header->SymRecordStreamIndex;
 }
 
 PDB_Machine DbiStream::getMachineType() const {
   uint16_t Machine = Header->MachineType;
   return static_cast<PDB_Machine>(Machine);
 }
 
+codeview::FixedStreamArray<object::coff_section>
+DbiStream::getSectionHeaders() {
+  return SectionHeaders;
+}
+
 ArrayRef<ModuleInfoEx> DbiStream::modules() const { return ModuleInfos; }
 codeview::FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const {
   return SectionMap;
 }
 
 void llvm::pdb::DbiStream::visitSectionContributions(
     ISectionContribVisitor &Visitor) const {
   if (SectionContribVersion == DbiSecContribVer60) {
if (SectionContribVersion == DbiSecContribVer60)
     return loadSectionContribs<SectionContrib>(SectionContribs, SCReader);
   if (SectionContribVersion == DbiSecContribV2)
     return loadSectionContribs<SectionContrib2>(SectionContribs2, SCReader);
 
   return make_error<RawError>(raw_error_code::feature_unsupported,
                               "Unsupported DBI Section Contribution version");
 }
 
+// Initializes this->SectionHeaders.
+Error DbiStream::initializeSectionHeadersData() {
+  uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::SectionHdr);
+  SectionHeaderStream.reset(new MappedBlockStream(StreamNum, Pdb));
+
+  size_t StreamLen = SectionHeaderStream->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(*SectionHeaderStream);
+  if (auto EC = Reader.readArray(SectionHeaders, NumSections))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Could not read a bitmap.");
+  return Error::success();
+}
+
 Error DbiStream::initializeSectionMapData() {
   StreamReader SMReader(SecMapSubstream);
   const SecMapHeader *Header;
   if (auto EC = SMReader.readObject(Header))
     return EC;
   if (auto EC = SMReader.readArray(SectionMap, Header->SecCount))
     return EC;
   return Error::success();

llvm/trunk/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:              -raw-section-contribs -raw-section-map %p/Inputs/empty.pdb \
+; RUN:              -raw-section-contribs -raw-section-map -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: not llvm-pdbdump -raw-headers %p/Inputs/bad-block-size.pdb 2>&1 | 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

llvm/trunk/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/COM.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"
cl::opt<bool> DumpSectionContribs("raw-section-contribs",
                                   cl::desc("dump section contributions"),
                                   cl::cat(NativeOptions));
 cl::opt<bool> DumpSectionMap("raw-section-map", cl::desc("dump section map"),
                              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"),
static Error dumpPublicsStream(ScopedPrinter &P, PDBFile &File,
   if (HadError)
     return make_error<RawError>(
         raw_error_code::corrupt_file,
         "Public symbol stream contained corrupt record");
 
   return Error::success();
 }
 
+static Error dumpSectionHeaders(ScopedPrinter &P, PDBFile &File,
+                                codeview::CVTypeDumper &TD) {
+  if (!opts::DumpSectionHeaders)
+    return Error::success();
+
+  auto DbiS = File.getPDBDbiStream();
+  if (auto EC = DbiS.takeError())
+    return EC;
+  DbiStream &DS = DbiS.get();
+
+  ListScope D(P, "Section Headers");
+  for (const object::coff_section &Section : DS.getSectionHeaders()) {
+    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 = dumpSectionContribs(P, File))
     return EC;
 
   if (auto EC = dumpSectionMap(P, File))
     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;
     opts::DumpSectionMap = true;
     opts::DumpSectionContribs = true;
   }