[pdbdump] Print out New FPO stream contents.

[ruiu]

Summary

The data strucutre in the new FPO stream is described in the
PE/COFF spec. There is one record per function if frame pointer
is omitted.

[majnemer]

lib/DebugInfo/PDB/Raw/DbiStream.cpp

313–314 ↗

(On Diff #59652)

Should we check that StreamLen is a multiple of sizeof(FpoData)?

tools/llvm-pdbdump/LLVMOutputStyle.cpp

691–692 ↗

(On Diff #59652)

Shouldn't these be printed as booleans?

[zturner]

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

83 ↗

(On Diff #59652)

Do you think this should go in llvm/Support/COFF.h (or is it perhaps there already?)

tools/llvm-pdbdump/LLVMOutputStyle.h

36 ↗

(On Diff #59652)

You will probably need to update YamlOutputStyle.h as well, you can just have the method do nothing.

tools/llvm-pdbdump/llvm-pdbdump.cpp

157 ↗

(On Diff #59652)

I'm starting to wonder if all of this should be broken out into a separate tool. The whole yaml thing is to support pdb <-> yaml, so maybe it makes sense for llvm-pdbdump to continue as the "semantic" pretty dumper, and llvm-readpdb as the raw dumper. This way we could have a more consistent and easy to understand command line option set and not have to worry about option conflicts, and reading/writing pdbs would be the same tool, so be able to share a lot of the same code.

Anyway, I'm just thinking out loud, obvious that is outside the scope of this patch.

[ruiu]

• Moved FpoData struct to COFF.h.
• Use printBoolean to print out boolean values.

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

83 ↗

(On Diff #59652)

Done.

lib/DebugInfo/PDB/Raw/DbiStream.cpp

313–314 ↗

(On Diff #59652)

I think readArray takes care of it.

tools/llvm-pdbdump/LLVMOutputStyle.cpp

691–692 ↗

(On Diff #59652)

Done.

tools/llvm-pdbdump/LLVMOutputStyle.h

36 ↗

(On Diff #59652)

Did you submit YamlOutputStyle.h already?

[zturner]

I thought so, but if not ignore that comment

[majnemer]

lib/DebugInfo/PDB/Raw/DbiStream.cpp

313–314 ↗

(On Diff #59672)

I don't see such a check.

[zturner]

It checks that there is enough space for the requested number of elements
in the underlying stream, but it doesn't check that the stream length is
exactly the right length because it doesn't know if there is more data
after the array

[ruiu]

• Added a check for stream size.

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/DbiStream.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 FpoData;
 struct coff_section;
 }
 
 namespace pdb {
 class PDBFile;
 class ISectionContribVisitor;
 
 class DbiStream {
public:
   uint32_t getDebugStreamIndex(DbgHeaderType Type) const;
 
   ArrayRef<ModuleInfoEx> modules() const;
 
   Expected<StringRef> getFileNameForIndex(uint32_t Index) const;
 
   codeview::FixedStreamArray<object::coff_section> getSectionHeaders();
 
+  codeview::FixedStreamArray<object::FpoData> getFpoRecords();
+
   codeview::FixedStreamArray<SecMapEntry> getSectionMap() const;
   void visitSectionContributions(ISectionContribVisitor &Visitor) const;
 
 private:
   Error initializeSectionContributionData();
   Error initializeSectionHeadersData();
   Error initializeSectionMapData();
   Error initializeFileInfo();
+  Error initializeFpoRecords();
 
   PDBFile &Pdb;
   MappedBlockStream Stream;
 
   std::vector<ModuleInfoEx> ModuleInfos;
   NameHashTable ECNames;
 
   codeview::StreamRef ModInfoSubstream;
private:
   codeview::FixedStreamArray<SectionContrib> SectionContribs;
   codeview::FixedStreamArray<SectionContrib2> SectionContribs2;
   codeview::FixedStreamArray<SecMapEntry> SectionMap;
   codeview::FixedStreamArray<support::little32_t> FileNameOffsets;
 
   std::unique_ptr<MappedBlockStream> SectionHeaderStream;
   codeview::FixedStreamArray<object::coff_section> SectionHeaders;
 
+  std::unique_ptr<MappedBlockStream> FpoStream;
+  codeview::FixedStreamArray<object::FpoData> FpoRecords;
+
   const HeaderInfo *Header;
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/Object/COFF.h

public:
   std::error_code getRVA(uint32_t &Result) const;
 
 private:
   const coff_base_reloc_block_header *Header;
   uint32_t Index;
   const COFFObjectFile *OwningObject;
 };
 
+// Corresponds to `_FPO_DATA` structure in the PE/COFF spec.
+struct FpoData {
+  support::ulittle32_t Offset; // ulOffStart: Offset 1st byte of function code
+  support::ulittle32_t Size;   // cbProcSize: # bytes in function
+  support::ulittle32_t NumLocals; // cdwLocals: # bytes in locals/4
+  support::ulittle16_t NumParams; // cdwParams: # bytes in params/4
+  support::ulittle16_t Attributes;
+
+  // cbProlog: # bytes in prolog
+  int getPrologSize() const { return Attributes & 0xF; }
+
+  // cbRegs: # regs saved
+  int getNumSavedRegs() const { return (Attributes >> 8) & 0x7; }
+
+  // fHasSEH: true if seh is func
+  bool hasSEH() const { return (Attributes >> 9) & 1; }
+
+  // fUseBP: true if EBP has been allocated
+  bool useBP() const { return (Attributes >> 10) & 1; }
+
+  // cbFrame: frame pointer
+  int getFP() const { return Attributes >> 14; }
+};
+
 } // end namespace object
 } // end namespace llvm
 
 #endif

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

if (auto EC = Reader.readArray(DbgStreams, Header->OptionalDbgHdrSize /
     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 (auto EC = initializeFpoRecords())
+    return EC;
 
   if (Reader.bytesRemaining() > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Found unexpected bytes in DBI Stream.");
 
   StreamReader ECReader(ECSubstream);
   if (auto EC = ECNames.load(ECReader))
     return EC;
PDB_Machine DbiStream::getMachineType() const {
   return static_cast<PDB_Machine>(Machine);
 }
 
 codeview::FixedStreamArray<object::coff_section>
 DbiStream::getSectionHeaders() {
   return SectionHeaders;
 }
 
+codeview::FixedStreamArray<object::FpoData> DbiStream::getFpoRecords() {
+  return FpoRecords;
+}
+
 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) {
Error DbiStream::initializeSectionHeadersData() {
   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();
 }
 
+// Initializes this->Fpos.
+Error DbiStream::initializeFpoRecords() {
+  uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::NewFPO);
+  FpoStream.reset(new MappedBlockStream(StreamNum, Pdb));
+
+  size_t StreamLen = FpoStream->getLength();
+  if (StreamLen % sizeof(object::FpoData))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Corrupted New FPO stream.");
+
+  size_t NumRecords = StreamLen / sizeof(object::FpoData);
+  codeview::StreamReader Reader(*FpoStream);
+  if (auto EC = Reader.readArray(FpoRecords, NumRecords))
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Corrupted New FPO stream.");
+  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 -raw-section-headers -raw-line-info \
-; RUN:              -raw-tpi-hash %p/Inputs/empty.pdb | FileCheck -check-prefix=EMPTY %s
+; RUN:              -raw-tpi-hash -raw-fpo %p/Inputs/empty.pdb | 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:   Unknown0: 2

 ; 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: ]
+; EMPTY:      New FPO [
+; EMPTY-NEXT:   {
+; EMPTY-NEXT:     Offset: 4112
+; EMPTY-NEXT:     Size: 10
+; EMPTY-NEXT:     Number of locals: 0
+; EMPTY-NEXT:     Number of params: 0
+; EMPTY-NEXT:     Size of Prolog: 0
+; EMPTY-NEXT:     Number of Saved Registers: 0
+; EMPTY-NEXT:     Has SEH: No
+; EMPTY-NEXT:     Use BP: No
+; EMPTY-NEXT:     Frame Pointer: 0
+; EMPTY-NEXT:   }
+; EMPTY-NEXT:   {
+; EMPTY-NEXT:     Offset: 0
+; EMPTY-NEXT:     Size: 134
+; EMPTY-NEXT:     Number of locals: 3
+; EMPTY-NEXT:     Number of params: 4
+; EMPTY-NEXT:     Size of Prolog: 0
+; EMPTY-NEXT:     Number of Saved Registers: 0
+; EMPTY-NEXT:     Has SEH: No
+; EMPTY-NEXT:     Use BP: No
+; EMPTY-NEXT:     Frame Pointer: 0
+; EMPTY-NEXT:   }
+; EMPTY-NEXT: ]
 
 ; ALL: FileHeaders {
 ; ALL:   BlockSize: 4096
 ; ALL:   Unknown0: 2
 ; ALL:   NumBlocks: 25
 ; ALL:   NumDirectoryBytes: 136
 ; ALL:   Unknown1: 0
 ; ALL:   BlockMapAddr: 24

llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.h

public:
   Error dumpInfoStream() override;
   Error dumpNamedStream() override;
   Error dumpTpiStream(uint32_t StreamIdx) override;
   Error dumpDbiStream() override;
   Error dumpSectionContribs() override;
   Error dumpSectionMap() override;
   Error dumpPublicsStream() override;
   Error dumpSectionHeaders() override;
+  Error dumpFpoStream() override;
 
 private:
   PDBFile &File;
   ScopedPrinter P;
   codeview::CVTypeDumper TD;
 };
 }
 }
 
 #endif

llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp

for (const object::coff_section &Section : DS.getSectionHeaders()) {
     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();
 }
+
+Error LLVMOutputStyle::dumpFpoStream() {
+  if (!opts::DumpFpo)
+    return Error::success();
+
+  auto DbiS = File.getPDBDbiStream();
+  if (auto EC = DbiS.takeError())
+    return EC;
+  DbiStream &DS = DbiS.get();
+
+  ListScope D(P, "New FPO");
+  for (const object::FpoData &Fpo : DS.getFpoRecords()) {
+    DictScope DD(P, "");
+    P.printNumber("Offset", Fpo.Offset);
+    P.printNumber("Size", Fpo.Size);
+    P.printNumber("Number of locals", Fpo.NumLocals);
+    P.printNumber("Number of params", Fpo.NumParams);
+    P.printNumber("Size of Prolog", Fpo.getPrologSize());
+    P.printNumber("Number of Saved Registers", Fpo.getNumSavedRegs());
+    P.printBoolean("Has SEH", Fpo.hasSEH());
+    P.printBoolean("Use BP", Fpo.useBP());
+    P.printNumber("Frame Pointer", Fpo.getFP());
+  }
+  return Error::success();
+}

llvm/trunk/tools/llvm-pdbdump/OutputStyle.h

public:
   virtual Error dumpInfoStream() = 0;
   virtual Error dumpNamedStream() = 0;
   virtual Error dumpTpiStream(uint32_t StreamIdx) = 0;
   virtual Error dumpDbiStream() = 0;
   virtual Error dumpSectionContribs() = 0;
   virtual Error dumpSectionMap() = 0;
   virtual Error dumpPublicsStream() = 0;
   virtual Error dumpSectionHeaders() = 0;
+  virtual Error dumpFpoStream() = 0;
 };
 }
 }
 
 #endif

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.h

 extern llvm::cl::opt<bool> DumpModuleFiles;
 extern llvm::cl::opt<bool> DumpModuleSyms;
 extern llvm::cl::opt<bool> DumpPublics;
 extern llvm::cl::opt<bool> DumpSectionContribs;
 extern llvm::cl::opt<bool> DumpLineInfo;
 extern llvm::cl::opt<bool> DumpSectionMap;
 extern llvm::cl::opt<bool> DumpSymRecordBytes;
 extern llvm::cl::opt<bool> DumpSectionHeaders;
+extern llvm::cl::opt<bool> DumpFpo;
 
 extern llvm::cl::opt<bool> ExcludeCompilerGenerated;
 
 extern llvm::cl::opt<bool> NoClassDefs;
 extern llvm::cl::opt<bool> NoEnumDefs;
 extern llvm::cl::list<std::string> ExcludeTypes;
 extern llvm::cl::list<std::string> ExcludeSymbols;
 extern llvm::cl::list<std::string> ExcludeCompilands;
 extern llvm::cl::list<std::string> IncludeTypes;
 extern llvm::cl::list<std::string> IncludeSymbols;
 extern llvm::cl::list<std::string> IncludeCompilands;
 }
 
 #endif

llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp

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> DumpFpo("raw-fpo", cl::desc("dump FPO records"),
+                      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",
static Error dumpStructure(RawSession &RS) {
   if (auto EC = O->dumpSectionMap())
     return EC;
 
   if (auto EC = O->dumpPublicsStream())
     return EC;
 
   if (auto EC = O->dumpSectionHeaders())
     return EC;
+
+  if (auto EC = O->dumpFpoStream())
+    return EC;
   return Error::success();
 }
 
 bool isRawDumpEnabled() {
   if (opts::DumpHeaders)
     return true;
   if (opts::DumpModules)
     return true;
bool isRawDumpEnabled() {
   if (opts::DumpIpiRecordBytes)
     return true;
   if (opts::DumpSectionContribs)
     return true;
   if (opts::DumpSectionMap)
     return true;
   if (opts::DumpLineInfo)
     return true;
+  if (opts::DumpFpo)
+    return true;
   return false;
 }
 
 static void dumpInput(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
   if (isRawDumpEnabled()) {
     ExitOnErr(loadDataForPDB(PDB_ReaderType::Raw, Path, Session));
 
if (opts::RawAll) {
     opts::DumpStreamSummary = true;
     opts::DumpStreamBlocks = true;
     opts::DumpTpiRecords = true;
     opts::DumpTpiHash = true;
     opts::DumpIpiRecords = true;
     opts::DumpSectionMap = true;
     opts::DumpSectionContribs = true;
     opts::DumpLineInfo = true;
+    opts::DumpFpo = 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
   // escaped in the regex.  In the case of a literal \, this means it needs to
   // be escaped again in the C++.  So matching a single \ in the input requires
   // 4 \es in the C++.
   if (opts::ExcludeCompilerGenerated) {