Expose PDBFileBuilder::finalizeMsfLayout.

[ruiu]

Summary

In many cases, clients of PDBFileBuilder generally needs to know
the exact file size before calling PDBFileBuilder::commit() so that
they can create output files with the exact sizes (this is needed
if you are using mmap'ed IO.)

This patch exposes finalizeMsfLayout and defines getMsf which
returns a MSFLayout object. Because MSFLayout object contains a
superblock which in turn contains the number of blocks, we can
compute the total file size by calling these functions.

[zturner]

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

53

I'm not sure if making this public is a good idea. This leaves open the possibility that someone could mis-use the class.

I can think of two solutions that would still keep this private:

1. Changing commit so that instead of taking an msf::WritableStream it takes a filename. Then you create the stream in there.

2. Change the implementation of FileBufferByteStream so that instead of taking a FileOutputBuffer to its constructor, it only takes a filename. Add a method to that class called create(uint64_t size). Then the signature of commit is changed to take an msf::FileBufferByteStream and after internally finalizing the layout, it calls stream.create(layout.size).

What do you think?

[ruiu]

• Updated as per discussion with Zach.

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

public:
   InfoStreamBuilder &getInfoBuilder();
   DbiStreamBuilder &getDbiBuilder();
   TpiStreamBuilder &getTpiBuilder();
   TpiStreamBuilder &getIpiBuilder();
 
   Expected<std::unique_ptr<PDBFile>>
   build(std::unique_ptr<msf::WritableStream> PdbFileBuffer);
 
-  Error commit(const msf::WritableStream &Buffer);
+  Error commit(StringRef Filename);
 
 private:
   Expected<msf::MSFLayout> finalizeMsfLayout() const;
-
   BumpPtrAllocator &Allocator;
 
   std::unique_ptr<msf::MSFBuilder> Msf;
   std::unique_ptr<InfoStreamBuilder> Info;
   std::unique_ptr<DbiStreamBuilder> Dbi;
   std::unique_ptr<TpiStreamBuilder> Tpi;
   std::unique_ptr<TpiStreamBuilder> Ipi;
 };
 }
 }
 
 #endif

lib/DebugInfo/PDB/Raw/PDBFileBuilder.cpp

 //===- PDBFileBuilder.cpp - PDB File Creation -------------------*- 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/PDBFileBuilder.h"
 
 #include "llvm/ADT/BitVector.h"
 
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
 #include "llvm/DebugInfo/MSF/StreamInterface.h"
 #include "llvm/DebugInfo/MSF/StreamWriter.h"
+#include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStreamBuilder.h"
 
PDBFileBuilder::build(std::unique_ptr<msf::WritableStream> PdbFileBuffer) {
   if (File->Info && File->Dbi && File->Info->getAge() != File->Dbi->getAge())
     return llvm::make_error<RawError>(
         raw_error_code::corrupt_file,
         "PDB Stream Age doesn't match Dbi Stream Age!");
 
   return std::move(File);
 }
 
-Error PDBFileBuilder::commit(const msf::WritableStream &Buffer) {
-  StreamWriter Writer(Buffer);
+Error PDBFileBuilder::commit(StringRef Filename) {
   auto ExpectedLayout = finalizeMsfLayout();
   if (!ExpectedLayout)
     return ExpectedLayout.takeError();
   auto &Layout = *ExpectedLayout;
 
+  uint64_t Filesize = Layout.SB->BlockSize * Layout.SB->NumBlocks;
+  auto OutFileOrError = FileOutputBuffer::create(Filename, Filesize);
+  if (OutFileOrError.getError())
+    return llvm::make_error<pdb::GenericError>(
+        generic_error_code::invalid_path, Filename);
+  FileBufferByteStream Buffer(std::move(*OutFileOrError));
+
+  StreamWriter Writer(Buffer);
+
   if (auto EC = Writer.writeObject(*Layout.SB))
     return EC;
   uint32_t BlockMapOffset =
       msf::blockToOffset(Layout.SB->BlockMapAddr, Layout.SB->BlockSize);
   Writer.setOffset(BlockMapOffset);
   if (auto EC = Writer.writeArray(Layout.DirectoryBlocks))
     return EC;
 
Error PDBFileBuilder::commit(StringRef Filename) {
   }
 
   if (Ipi) {
     if (auto EC = Ipi->commit(Layout, Buffer))
       return EC;
   }
 
   return Buffer.commit();
-}
+}
 

tools/llvm-pdbdump/llvm-pdbdump.cpp

static void yamlToPdb(StringRef Path) {
 
   llvm::yaml::Input In(Buffer->getBuffer());
   pdb::yaml::PdbObject YamlObj(Allocator);
   In >> YamlObj;
   if (!YamlObj.Headers.hasValue())
     ExitOnErr(make_error<GenericError>(generic_error_code::unspecified,
                                        "Yaml does not contain MSF headers"));
 
-  auto OutFileOrError = FileOutputBuffer::create(
-      opts::yaml2pdb::YamlPdbOutputFile, YamlObj.Headers->FileSize);
-  if (OutFileOrError.getError())
-    ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path,
-                                       opts::yaml2pdb::YamlPdbOutputFile));
-
-  auto FileByteStream =
-      llvm::make_unique<FileBufferByteStream>(std::move(*OutFileOrError));
   PDBFileBuilder Builder(Allocator);
 
   ExitOnErr(Builder.initialize(YamlObj.Headers->SuperBlock));
   // Add each of the reserved streams.  We ignore stream metadata in the
   // yaml, because we will reconstruct our own view of the streams.  For
   // example, the YAML may say that there were 20 streams in the original
   // PDB, but maybe we only dump a subset of those 20 streams, so we will
   // have fewer, and the ones we do have may end up with different indices
static void yamlToPdb(StringRef Path) {
 
   if (YamlObj.IpiStream.hasValue()) {
     auto &IpiBuilder = Builder.getIpiBuilder();
     IpiBuilder.setVersionHeader(YamlObj.IpiStream->Version);
     for (const auto &R : YamlObj.IpiStream->Records)
       IpiBuilder.addTypeRecord(R.Record);
   }
 
-  ExitOnErr(Builder.commit(*FileByteStream));
+  ExitOnErr(Builder.commit(opts::yaml2pdb::YamlPdbOutputFile));
 }
 
 static void pdb2Yaml(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
   ExitOnErr(loadDataForPDB(PDB_ReaderType::Raw, Path, Session));
 
   RawSession *RS = static_cast<RawSession *>(Session.get());
   PDBFile &File = RS->getPDBFile();