[pdb] Actually write a PDB to the disk

[zturner]

Summary

Finally! We can write a real PDB file to the disk. There's still quite a bit of work to be done on this codepath, but in its current limited form, it can dump MSF headers and stream directory information to YAML, then read it back in and produce a PDB from that information, then dump the resulting PDB back to YAML and the dumped YAML is identical.

[zturner]

bump

[ruiu]

include/llvm/DebugInfo/CodeView/StreamRef.h

96 ↗

(On Diff #60316)

Is this different from the default copy assignment operator?

include/llvm/DebugInfo/CodeView/StreamWriter.h

44 ↗

(On Diff #60316)

Can you use static_assert instead of enable_if_t?

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

122 ↗

(On Diff #60316)

ArrayRef<ArrayRef<support::ulittle32_t>> is probably better for consistency.

lib/DebugInfo/PDB/Raw/PDBFile.cpp

287 ↗

(On Diff #60316)

We shouldn't meet the error conditions that we are checking in this function unless there's a bug in PDB producer code or YAML reader code (YAML reader should do reasonable semantic checking), so they should be asserts.

[zturner]

include/llvm/DebugInfo/CodeView/StreamRef.h

96 ↗

(On Diff #60316)

I don't think so, this might have slipped in accidentally.

include/llvm/DebugInfo/CodeView/StreamWriter.h

44 ↗

(On Diff #60316)

Probably so, I will try it.

lib/DebugInfo/PDB/Raw/PDBFile.cpp

287 ↗

(On Diff #60316)

Technically a PDB file is a program input, we could generate one through fuzzing for example. Also we can't assume we are the only producer of PDB files. And since this will be in library code, I don't know if I feel comfortable asserting on conditions of the program input.

[ruiu]

LGTM

llvm/trunk/include/llvm/DebugInfo/CodeView/StreamRef.h

if (Stream != Other.Stream)
       return false;
     if (ViewOffset != Other.ViewOffset)
       return false;
     if (Length != Other.Length)
       return false;
     return true;
   }
 
-  bool operator!=(const StreamRef &Other) const { return !(*this == Other); }
-
 private:
   const StreamInterface *Stream;
   uint32_t ViewOffset;
   uint32_t Length;
 };
 }
 }
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_STREAMREF_H

llvm/trunk/include/llvm/DebugInfo/CodeView/StreamWriter.h

public:
   Error writeStreamRef(StreamRef Ref, uint32_t Size);
 
   template <typename T> Error writeEnum(T Num) {
     return writeInteger(
         static_cast<typename std::underlying_type<T>::type>(Num));
   }
 
   template <typename T> Error writeObject(const T &Obj) {
+    static_assert(!std::is_pointer<T>::value,
+                  "writeObject should not be used with pointers, to write "
+                  "the pointed-to value dereference the pointer before calling "
+                  "writeObject");
     return writeBytes(
         ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&Obj), sizeof(T)));
   }
 
   template <typename T> Error writeArray(ArrayRef<T> Array) {
     if (Array.size() == 0)
       return Error::success();
 

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

public:
   uint32_t getBlockMapIndex() const;
   uint32_t getNumDirectoryBlocks() const;
   uint64_t getBlockMapOffset() const;
 
   uint32_t getNumStreams() const override;
   uint32_t getStreamByteSize(uint32_t StreamIndex) const override;
   ArrayRef<support::ulittle32_t>
   getStreamBlockList(uint32_t StreamIndex) const override;
+  size_t getFileSize() const;
 
   ArrayRef<uint8_t> getBlockData(uint32_t BlockIndex,
                                  uint32_t NumBytes) const override;
   Error setBlockData(uint32_t BlockIndex, uint32_t Offset,
                      ArrayRef<uint8_t> Data) const override;
 
+  ArrayRef<support::ulittle32_t> getStreamSizes() const { return StreamSizes; }
+  ArrayRef<ArrayRef<support::ulittle32_t>> getStreamMap() const {
+    return StreamMap;
+  }
+
   ArrayRef<support::ulittle32_t> getDirectoryBlockArray() const;
 
   Error parseFileHeaders();
   Error parseStreamData();
 
   static uint64_t bytesToBlocks(uint64_t NumBytes, uint64_t BlockSize) {
     return alignTo(NumBytes, BlockSize) / BlockSize;
   }
 
   static uint64_t blockToOffset(uint64_t BlockNumber, uint64_t BlockSize) {
     return BlockNumber * BlockSize;
   }
 
   Expected<InfoStream &> getPDBInfoStream();
   Expected<DbiStream &> getPDBDbiStream();
   Expected<TpiStream &> getPDBTpiStream();
   Expected<TpiStream &> getPDBIpiStream();
   Expected<PublicsStream &> getPDBPublicsStream();
   Expected<SymbolStream &> getPDBSymbolStream();
   Expected<NameHashTable &> getStringTable();
 
+  void setSuperBlock(const SuperBlock *Block);
+  void setStreamSizes(ArrayRef<support::ulittle32_t> Sizes);
+  void setStreamMap(ArrayRef<ArrayRef<support::ulittle32_t>> Blocks);
+  void commit();
+
 private:
   std::unique_ptr<codeview::StreamInterface> Buffer;
   const PDBFile::SuperBlock *SB;
   ArrayRef<support::ulittle32_t> StreamSizes;
   std::vector<ArrayRef<support::ulittle32_t>> StreamMap;
 
   std::unique_ptr<InfoStream> Info;
   std::unique_ptr<DbiStream> Dbi;

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

 #include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.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/Support/Endian.h"
+#include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 namespace {
 typedef FixedStreamArray<support::ulittle32_t> ulittle_array;
uint32_t PDBFile::getStreamByteSize(uint32_t StreamIndex) const {
   return StreamSizes[StreamIndex];
 }
 
 ArrayRef<support::ulittle32_t>
 PDBFile::getStreamBlockList(uint32_t StreamIndex) const {
   return StreamMap[StreamIndex];
 }
 
+size_t PDBFile::getFileSize() const { return Buffer->getLength(); }
+
 ArrayRef<uint8_t> PDBFile::getBlockData(uint32_t BlockIndex,
                                         uint32_t NumBytes) const {
   uint64_t StreamBlockOffset = blockToOffset(BlockIndex, getBlockSize());
 
   ArrayRef<uint8_t> Result;
   if (auto EC = Buffer->readBytes(StreamBlockOffset, NumBytes, Result))
     consumeError(std::move(EC));
   return Result;
if (!StringTable || !StringTableStream) {
     auto N = llvm::make_unique<NameHashTable>();
     if (auto EC = N->load(Reader))
       return std::move(EC);
     StringTable = std::move(N);
     StringTableStream = std::move(*NS);
   }
   return *StringTable;
 }
+
+void PDBFile::setSuperBlock(const SuperBlock *Block) { SB = Block; }
+
+void PDBFile::setStreamSizes(ArrayRef<support::ulittle32_t> Sizes) {
+  StreamSizes = Sizes;
+}
+
+void PDBFile::setStreamMap(ArrayRef<ArrayRef<support::ulittle32_t>> Blocks) {
+  StreamMap = Blocks;
+}
+
+void PDBFile::commit() {}
 No newline at end of file

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: MSF:
+; YAML-NEXT:   SuperBlock:
+; 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:   NumStreams:      17
+; YAML-NEXT:   FileSize:        102400
 ; YAML-NEXT: ...

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/DebugInfo/PDB/Raw/PDBFile.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;
+  PDBFile::SuperBlock SuperBlock;
   uint32_t NumDirectoryBlocks;
   uint32_t BlockMapOffset;
-  std::vector<uint32_t> DirectoryBlocks;
+  std::vector<support::ulittle32_t> DirectoryBlocks;
   uint32_t NumStreams;
+  uint32_t FileSize;
 };
 
-struct StreamSizeEntry {
-  uint32_t Size;
-};
-
-struct StreamMapEntry {
-  std::vector<uint32_t> Blocks;
+struct StreamBlockList {
+  std::vector<support::ulittle32_t> Blocks;
 };
 
 struct PdbObject {
-  Optional<MsfHeaders> Headers;
-  Optional<std::vector<StreamSizeEntry>> StreamSizes;
-  Optional<std::vector<StreamMapEntry>> StreamMap;
+  MsfHeaders Headers;
+  Optional<std::vector<support::ulittle32_t>> StreamSizes;
+  Optional<std::vector<StreamBlockList>> StreamMap;
 };
 }
 }
 }
 
 namespace llvm {
 namespace yaml {
-template <> struct MappingTraits<pdb::yaml::StreamSizeEntry> {
-  static void mapping(IO &IO, pdb::yaml::StreamSizeEntry &Obj);
+
+template <> struct MappingTraits<pdb::PDBFile::SuperBlock> {
+  static void mapping(IO &IO, pdb::PDBFile::SuperBlock &SB);
 };
 
-template <> struct MappingTraits<pdb::yaml::StreamMapEntry> {
-  static void mapping(IO &IO, pdb::yaml::StreamMapEntry &Obj);
+template <> struct MappingTraits<pdb::yaml::StreamBlockList> {
+  static void mapping(IO &IO, pdb::yaml::StreamBlockList &SB);
 };
 
 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)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamSizeEntry)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamMapEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(support::ulittle32_t)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamBlockList)
 
 #endif // LLVM_TOOLS_LLVMPDBDUMP_PDBYAML_H

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

 
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 
 using namespace llvm;
 using namespace llvm::yaml;
 using namespace llvm::pdb;
 using namespace llvm::pdb::yaml;
 
+void MappingTraits<PDBFile::SuperBlock>::mapping(IO &IO,
+                                                 PDBFile::SuperBlock &SB) {
+  if (!IO.outputting()) {
+    ::memcpy(SB.MagicBytes, MsfMagic, sizeof(MsfMagic));
+  }
+
+  IO.mapRequired("BlockSize", SB.BlockSize);
+  IO.mapRequired("Unknown0", SB.Unknown0);
+  IO.mapRequired("NumBlocks", SB.NumBlocks);
+  IO.mapRequired("NumDirectoryBytes", SB.NumDirectoryBytes);
+  IO.mapRequired("Unknown1", SB.Unknown1);
+  IO.mapRequired("BlockMapAddr", SB.BlockMapAddr);
+}
+
+void MappingTraits<StreamBlockList>::mapping(IO &IO, StreamBlockList &SB) {
+  IO.mapRequired("Stream", SB.Blocks);
+}
+
 void MappingTraits<MsfHeaders>::mapping(IO &IO, 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("SuperBlock", Obj.SuperBlock);
   IO.mapRequired("NumDirectoryBlocks", Obj.NumDirectoryBlocks);
   IO.mapRequired("BlockMapOffset", Obj.BlockMapOffset);
   IO.mapRequired("DirectoryBlocks", Obj.DirectoryBlocks);
   IO.mapRequired("NumStreams", Obj.NumStreams);
+  IO.mapRequired("FileSize", Obj.FileSize);
 }
 
 void MappingTraits<PdbObject>::mapping(IO &IO, PdbObject &Obj) {
   IO.mapOptional("MSF", Obj.Headers);
   IO.mapOptional("StreamSizes", Obj.StreamSizes);
   IO.mapOptional("StreamMap", Obj.StreamMap);
 }
-
-void MappingTraits<StreamSizeEntry>::mapping(IO &IO, StreamSizeEntry &Obj) {
-  IO.mapRequired("Size", Obj.Size);
-}
-
-void MappingTraits<StreamMapEntry>::mapping(IO &IO, StreamMapEntry &Obj) {
-  IO.mapRequired("Blocks", Obj.Blocks);
-}

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

 
 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();
+  Obj.Headers.SuperBlock.NumBlocks = File.getBlockCount();
+  Obj.Headers.SuperBlock.BlockMapAddr = File.getBlockMapIndex();
+  Obj.Headers.BlockMapOffset = File.getBlockMapOffset();
+  Obj.Headers.SuperBlock.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);
+  Obj.Headers.DirectoryBlocks.assign(Blocks.begin(), Blocks.end());
+  Obj.Headers.NumDirectoryBlocks = File.getNumDirectoryBlocks();
+  Obj.Headers.SuperBlock.NumDirectoryBytes = File.getNumDirectoryBytes();
+  Obj.Headers.NumStreams = File.getNumStreams();
+  Obj.Headers.SuperBlock.Unknown0 = File.getUnknown0();
+  Obj.Headers.SuperBlock.Unknown1 = File.getUnknown1();
+  Obj.Headers.FileSize = File.getFileSize();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpStreamSummary() {
   if (!opts::DumpStreamSummary)
     return Error::success();
 
-  std::vector<yaml::StreamSizeEntry> Sizes;
-  for (uint32_t I = 0; I < File.getNumStreams(); ++I) {
-    yaml::StreamSizeEntry Entry;
-    Entry.Size = File.getStreamByteSize(I);
-    Sizes.push_back(Entry);
-  }
-  Obj.StreamSizes.emplace(Sizes);
+  Obj.StreamSizes = File.getStreamSizes();
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpStreamBlocks() {
   if (!opts::DumpStreamBlocks)
     return Error::success();
 
-  std::vector<yaml::StreamMapEntry> Blocks;
-  for (uint32_t I = 0; I < File.getNumStreams(); ++I) {
-    yaml::StreamMapEntry Entry;
-    auto BlockList = File.getStreamBlockList(I);
-    Entry.Blocks.assign(BlockList.begin(), BlockList.end());
-    Blocks.push_back(Entry);
+  auto StreamMap = File.getStreamMap();
+  Obj.StreamMap.emplace();
+  for (auto &Stream : StreamMap) {
+    pdb::yaml::StreamBlockList BlockList;
+    BlockList.Blocks = Stream;
+    Obj.StreamMap->push_back(BlockList);
   }
-  Obj.StreamMap.emplace(Blocks);
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpStreamData() {
   uint32_t StreamCount = File.getNumStreams();
   StringRef DumpStreamStr = opts::DumpStreamDataIdx;
   uint32_t DumpStreamNum;

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

 #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/CodeView/ByteStream.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolThunk.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/RawSession.h"
 #include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/FileOutputBuffer.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"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
+namespace {
+// A simple adapter that acts like a ByteStream but holds ownership over
+// and underlying FileOutputBuffer.
+class FileBufferByteStream : public ByteStream<true> {
+public:
+  FileBufferByteStream(std::unique_ptr<FileOutputBuffer> Buffer)
+      : ByteStream(MutableArrayRef<uint8_t>(Buffer->getBufferStart(),
+                                            Buffer->getBufferEnd())),
+        FileBuffer(std::move(Buffer)) {}
+
+private:
+  std::unique_ptr<FileOutputBuffer> FileBuffer;
+};
+}
+
 namespace opts {
 
 enum class PDB_DumpType { ByType, ByObjFile, Both };
 
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input PDB files>"),
                                      cl::OneOrMore);
 

 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::opt<bool>
+    YamlToPdb("yaml-to-pdb",
+              cl::desc("The input file is yaml, and the tool outputs a pdb"),
+              cl::cat(NativeOptions));
+cl::opt<std::string> YamlPdbOutputFile(
+    "pdb-output", cl::desc("When yaml-to-pdb is specified, the output file"),
+    cl::cat(NativeOptions));
+
 cl::list<std::string>
     ExcludeTypes("exclude-types",
                  cl::desc("Exclude types by regular expression"),
                  cl::ZeroOrMore, cl::cat(FilterCategory));
 cl::list<std::string>
     ExcludeSymbols("exclude-symbols",
                    cl::desc("Exclude symbols by regular expression"),
                    cl::ZeroOrMore, cl::cat(FilterCategory));
if (opts::DumpSectionMap)
     return true;
   if (opts::DumpLineInfo)
     return true;
   if (opts::DumpFpo)
     return true;
   return false;
 }
 
+static void yamlToPdb(StringRef Path) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
+      MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
+                                   /*RequiresNullTerminator=*/false);
+
+  if (ErrorOrBuffer.getError()) {
+    ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path, Path));
+  }
+
+  std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
+
+  llvm::yaml::Input In(Buffer->getBuffer());
+  pdb::yaml::PdbObject YamlObj;
+  In >> YamlObj;
+
+  auto OutFileOrError = FileOutputBuffer::create(opts::YamlPdbOutputFile,
+                                                 YamlObj.Headers.FileSize);
+  if (OutFileOrError.getError())
+    ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path,
+                                       opts::YamlPdbOutputFile));
+
+  auto FileByteStream =
+      llvm::make_unique<FileBufferByteStream>(std::move(*OutFileOrError));
+  PDBFile Pdb(std::move(FileByteStream));
+  Pdb.setSuperBlock(&YamlObj.Headers.SuperBlock);
+  if (YamlObj.StreamMap.hasValue()) {
+    std::vector<ArrayRef<support::ulittle32_t>> StreamMap;
+    for (auto &E : YamlObj.StreamMap.getValue()) {
+      StreamMap.push_back(E.Blocks);
+    }
+    Pdb.setStreamMap(StreamMap);
+  }
+  if (YamlObj.StreamSizes.hasValue()) {
+    Pdb.setStreamSizes(YamlObj.StreamSizes.getValue());
+  }
+
+  Pdb.commit();
+}
+
 static void dumpInput(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
   if (isRawDumpEnabled()) {
     ExitOnErr(loadDataForPDB(PDB_ReaderType::Raw, Path, Session));
 
     RawSession *RS = static_cast<RawSession *>(Session.get());
     ExitOnErr(dumpStructure(*RS));
     return;
if (opts::ExcludeSystemLibraries) {
     opts::ExcludeCompilands.push_back(
         "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
     opts::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
     opts::ExcludeCompilands.push_back("d:\\\\th.obj.x86fre\\\\minkernel");
   }
 
   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 
+  if (opts::YamlToPdb) {
+    std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
+                  yamlToPdb);
+  } else {
     std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
                   dumpInput);
+  }
 
   outs().flush();
   return 0;
 }