Dump MSF headers to YAML

[zturner]

Summary

This introduces the YAML output style and implements dumping of the MSF headers to YAML. This is the smallest possible patch to get basic support for YAML output working. After I confirm I'm using the library correctly and that the code I've written is sufficiently "yamlish" (like pythonic), I'll iterate more quickly with post commit reviews.

Output looks like this currently:

D:\src\llvmbuild\ninja>bin\llvm-pdbdump.exe -raw-headers -raw-output-style=YAML d:\FileCheck.pdb
---
MSF:
  BlockSize:       4096
  Unknown0:        1
  NumBlocks:       1767
  NumDirectoryBytes: 6728
  Unknown1:        0
  BlockMapAddr:    1558
  NumDirectoryBlocks: 2
  BlockMapOffset:  6381568
  DirectoryBlocks:
    - 1556
    - 1557
  NumStreams:      131
...

[ruiu]

Can you add a (smallest possible) test as well?

[zturner]

I debated over whether it was worth it. The reason for doing all this is to enable new tests, and in writing those new tests (once this is complete), we should find bugs in the yaml output format as well.

I don't mind adding one tests that just checks these 5 fields, but I don't think it should turn into something comprehensive like pdbdump-headers.text where we test every single possible output path, because it seems like a lot of work for little gain.

[ruiu]

OK, but having absolutely no test makes me nervous. I'd appreciate if you add a test for the five fields.

llvm/trunk/test/DebugInfo/PDB/pdbdump-yaml.test

+; RUN: llvm-pdbdump -raw-headers -raw-output-style=YAML %p/Inputs/empty.pdb \
+; RUN:               | FileCheck -check-prefix=YAML %s
+
+; YAML:      ---
+; YAML-NEXT: MSF:
+; YAML-NEXT:   BlockSize:       4096
+; YAML-NEXT:   Unknown0:        2
+; YAML-NEXT:   NumBlocks:       25
+; YAML-NEXT:   NumDirectoryBytes: 136
+; YAML-NEXT:   Unknown1:        0
+; YAML-NEXT:   BlockMapAddr:    24
+; YAML-NEXT:   NumDirectoryBlocks: 1
+; YAML-NEXT:   BlockMapOffset:  98304
+; YAML-NEXT:   DirectoryBlocks:
+; YAML-NEXT:     - 23
+; YAML-NEXT:   NumStreams:      17
+; YAML-NEXT: ...

llvm/trunk/tools/llvm-pdbdump/CMakeLists.txt

add_llvm_tool(llvm-pdbdump
   BuiltinDumper.cpp
   ClassDefinitionDumper.cpp
   CompilandDumper.cpp
   EnumDumper.cpp
   ExternalSymbolDumper.cpp
   FunctionDumper.cpp
   LinePrinter.cpp
   LLVMOutputStyle.cpp
+  PdbYaml.cpp
   TypeDumper.cpp
   TypedefDumper.cpp
   VariableDumper.cpp
+  YAMLOutputStyle.cpp
   )
 
 if(LLVM_USE_SANITIZE_COVERAGE)
   add_subdirectory(fuzzer)
 endif()

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

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

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

for (const object::FpoData &Fpo : DS.getFpoRecords()) {
     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();
 }
+void LLVMOutputStyle::flush() { P.flush(); }

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

public:
   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;
+
+  virtual void flush() = 0;
 };
 }
 }
 
 #endif

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

+//===- PdbYAML.h ---------------------------------------------- *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVMPDBDUMP_PDBYAML_H
+#define LLVM_TOOLS_LLVMPDBDUMP_PDBYAML_H
+
+#include "OutputStyle.h"
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/YAMLTraits.h"
+
+#include <vector>
+
+namespace llvm {
+namespace pdb {
+class PDBFile;
+
+namespace yaml {
+struct MsfHeaders {
+  uint32_t BlockSize;
+  uint32_t Unknown0;
+  uint32_t BlockCount;
+  uint32_t NumDirectoryBytes;
+  uint32_t Unknown1;
+  uint32_t BlockMapIndex;
+  uint32_t NumDirectoryBlocks;
+  uint32_t BlockMapOffset;
+  std::vector<uint32_t> DirectoryBlocks;
+  uint32_t NumStreams;
+};
+
+struct PdbObject {
+  Optional<MsfHeaders> Headers;
+};
+}
+}
+
+namespace yaml {
+template <> struct MappingTraits<pdb::yaml::MsfHeaders> {
+  static void mapping(IO &IO, pdb::yaml::MsfHeaders &Obj);
+};
+template <> struct MappingTraits<pdb::yaml::PdbObject> {
+  static void mapping(IO &IO, pdb::yaml::PdbObject &Obj);
+};
+}
+}
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(uint32_t)
+
+#endif // LLVM_TOOLS_LLVMPDBDUMP_PDBYAML_H

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

+//===- PdbYAML.cpp -------------------------------------------- *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "PdbYaml.h"
+
+#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+using namespace llvm::pdb::yaml;
+
+void llvm::yaml::MappingTraits<MsfHeaders>::mapping(
+    IO &IO, pdb::yaml::MsfHeaders &Obj) {
+  IO.mapRequired("BlockSize", Obj.BlockSize);
+  IO.mapRequired("Unknown0", Obj.Unknown0);
+  IO.mapRequired("NumBlocks", Obj.BlockCount);
+  IO.mapRequired("NumDirectoryBytes", Obj.NumDirectoryBytes);
+  IO.mapRequired("Unknown1", Obj.Unknown1);
+  IO.mapRequired("BlockMapAddr", Obj.BlockMapIndex);
+  IO.mapRequired("NumDirectoryBlocks", Obj.NumDirectoryBlocks);
+  IO.mapRequired("BlockMapOffset", Obj.BlockMapOffset);
+  IO.mapRequired("DirectoryBlocks", Obj.DirectoryBlocks);
+  IO.mapRequired("NumStreams", Obj.NumStreams);
+}
+
+void llvm::yaml::MappingTraits<pdb::yaml::PdbObject>::mapping(
+    IO &IO, pdb::yaml::PdbObject &Obj) {
+  IO.mapOptional("MSF", Obj.Headers);
+}

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

+//===- YAMLOutputStyle.h -------------------------------------- *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVMPDBDUMP_YAMLOUTPUTSTYLE_H
+#define LLVM_TOOLS_LLVMPDBDUMP_YAMLOUTPUTSTYLE_H
+
+#include "OutputStyle.h"
+#include "PdbYaml.h"
+
+#include "llvm/DebugInfo/CodeView/TypeDumper.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/YAMLTraits.h"
+
+namespace llvm {
+namespace pdb {
+class YAMLOutputStyle : public OutputStyle {
+public:
+  YAMLOutputStyle(PDBFile &File);
+
+  Error dumpFileHeaders() override;
+  Error dumpStreamSummary() override;
+  Error dumpStreamBlocks() override;
+  Error dumpStreamData() override;
+  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;
+
+  void flush() override;
+
+private:
+  PDBFile &File;
+  llvm::yaml::Output Out;
+
+  yaml::PdbObject Obj;
+};
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_TOOLS_LLVMPDBDUMP_YAMLOUTPUTSTYLE_H

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

+//===- YAMLOutputStyle.cpp ------------------------------------ *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "YAMLOutputStyle.h"
+
+#include "PdbYaml.h"
+#include "llvm-pdbdump.h"
+
+#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+
+YAMLOutputStyle::YAMLOutputStyle(PDBFile &File) : File(File), Out(outs()) {}
+
+Error YAMLOutputStyle::dumpFileHeaders() {
+  if (!opts::DumpHeaders)
+    return Error::success();
+
+  yaml::MsfHeaders Headers;
+  Headers.BlockCount = File.getBlockCount();
+  Headers.BlockMapIndex = File.getBlockMapIndex();
+  Headers.BlockMapOffset = File.getBlockMapOffset();
+  Headers.BlockSize = File.getBlockSize();
+  auto Blocks = File.getDirectoryBlockArray();
+  Headers.DirectoryBlocks.assign(Blocks.begin(), Blocks.end());
+  Headers.NumDirectoryBlocks = File.getNumDirectoryBlocks();
+  Headers.NumDirectoryBytes = File.getNumDirectoryBytes();
+  Headers.NumStreams = File.getNumStreams();
+  Headers.Unknown0 = File.getUnknown0();
+  Headers.Unknown1 = File.getUnknown1();
+
+  Obj.Headers.emplace(Headers);
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpStreamSummary() {
+  if (!opts::DumpStreamSummary)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpStreamBlocks() {
+  if (!opts::DumpStreamBlocks)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpStreamData() {
+  uint32_t StreamCount = File.getNumStreams();
+  StringRef DumpStreamStr = opts::DumpStreamDataIdx;
+  uint32_t DumpStreamNum;
+  if (DumpStreamStr.getAsInteger(/*Radix=*/0U, DumpStreamNum) ||
+      DumpStreamNum >= StreamCount)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpInfoStream() {
+  if (!opts::DumpHeaders)
+    return Error::success();
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpNamedStream() {
+  if (opts::DumpStreamDataName.empty())
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpDbiStream() { return Error::success(); }
+
+Error YAMLOutputStyle::dumpSectionContribs() {
+  if (!opts::DumpSectionContribs)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpSectionMap() {
+  if (!opts::DumpSectionMap)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpPublicsStream() {
+  if (!opts::DumpPublics)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpSectionHeaders() {
+  if (!opts::DumpSectionHeaders)
+    return Error::success();
+
+  return Error::success();
+}
+
+Error YAMLOutputStyle::dumpFpoStream() {
+  if (!opts::DumpFpo)
+    return Error::success();
+
+  return Error::success();
+}
+
+void YAMLOutputStyle::flush() {
+  Out << Obj;
+  outs().flush();
+}

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

 #include "CompilandDumper.h"
 #include "ExternalSymbolDumper.h"
 #include "FunctionDumper.h"
 #include "LLVMOutputStyle.h"
 #include "LinePrinter.h"
 #include "OutputStyle.h"
 #include "TypeDumper.h"
 #include "VariableDumper.h"
+#include "YAMLOutputStyle.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"

 
 static ExitOnError ExitOnErr;
 
 static Error dumpStructure(RawSession &RS) {
   PDBFile &File = RS.getPDBFile();
   std::unique_ptr<OutputStyle> O;
   if (opts::RawOutputStyle == opts::OutputStyleTy::LLVM)
     O = llvm::make_unique<LLVMOutputStyle>(File);
+  else if (opts::RawOutputStyle == opts::OutputStyleTy::YAML)
+    O = llvm::make_unique<YAMLOutputStyle>(File);
   else
     return make_error<RawError>(raw_error_code::feature_unsupported,
                                 "Requested output style unsupported");
 
   if (auto EC = O->dumpFileHeaders())
     return EC;
 
   if (auto EC = O->dumpStreamSummary())
static Error dumpStructure(RawSession &RS) {
   if (auto EC = O->dumpPublicsStream())
     return EC;
 
   if (auto EC = O->dumpSectionHeaders())
     return EC;
 
   if (auto EC = O->dumpFpoStream())
     return EC;
+  O->flush();
   return Error::success();
 }
 
 bool isRawDumpEnabled() {
   if (opts::DumpHeaders)
     return true;
   if (opts::DumpModules)
     return true;