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/MSF/MSFCommon.h

struct SuperBlock {
   support::ulittle32_t NumDirectoryBytes;
   // This field's purpose is not yet known.
   support::ulittle32_t Unknown1;
   // This contains the block # of the block map.
   support::ulittle32_t BlockMapAddr;
 };
 
 struct MSFLayout {
-  MSFLayout() : SB(nullptr) {}
-  const SuperBlock *SB;
+  const SuperBlock *SB = nullptr;
   BitVector FreePageMap;
   ArrayRef<support::ulittle32_t> DirectoryBlocks;
   ArrayRef<support::ulittle32_t> StreamSizes;
   std::vector<ArrayRef<support::ulittle32_t>> StreamMap;
 };
 
 inline bool isValidBlockSize(uint32_t Size) {
   switch (Size) {

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

 class PDBFileBuilder {
 public:
   explicit PDBFileBuilder(BumpPtrAllocator &Allocator);
   PDBFileBuilder(const PDBFileBuilder &) = delete;
   PDBFileBuilder &operator=(const PDBFileBuilder &) = delete;
 
   Error initialize(const msf::SuperBlock &Super);
 
+  msf::MSFLayout &getMsf();
   msf::MSFBuilder &getMsfBuilder();
   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);
 
-private:
-  Expected<msf::MSFLayout> finalizeMsfLayout() const;
+  Error finalizeMsfLayout();
 
+private:
   BumpPtrAllocator &Allocator;
 
-  std::unique_ptr<msf::MSFBuilder> Msf;
+  std::unique_ptr<msf::MSFLayout> Msf;
+  std::unique_ptr<msf::MSFBuilder> MsfBuilder;
   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

 using namespace llvm::msf;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
 PDBFileBuilder::PDBFileBuilder(BumpPtrAllocator &Allocator)
     : Allocator(Allocator) {}
 
 Error PDBFileBuilder::initialize(const msf::SuperBlock &Super) {
+  auto ExpectedMsfBuilder =
+      MSFBuilder::create(Allocator, Super.BlockSize);
+  if (!ExpectedMsfBuilder)
+    return ExpectedMsfBuilder.takeError();
+
   auto ExpectedMsf =
       MSFBuilder::create(Allocator, Super.BlockSize, Super.NumBlocks);
   if (!ExpectedMsf)
     return ExpectedMsf.takeError();
 
   auto &MsfResult = *ExpectedMsf;
   if (auto EC = MsfResult.setBlockMapAddr(Super.BlockMapAddr))
     return EC;
   Msf = llvm::make_unique<MSFBuilder>(std::move(MsfResult));
   Msf->setFreePageMap(Super.FreeBlockMapBlock);
   Msf->setUnknown1(Super.Unknown1);
-  return Error::success();
 }
 
-MSFBuilder &PDBFileBuilder::getMsfBuilder() { return *Msf; }
+MSFLayout &PDBFileBuilder::getMsf() { return *Msf; }
+
+MSFBuilder &PDBFileBuilder::getMsfBuilder() { return *MsfBuilder; }
 
 InfoStreamBuilder &PDBFileBuilder::getInfoBuilder() {
   if (!Info)
-    Info = llvm::make_unique<InfoStreamBuilder>(*Msf);
+    Info = llvm::make_unique<InfoStreamBuilder>(*MsfBuilder);
   return *Info;
 }
 
 DbiStreamBuilder &PDBFileBuilder::getDbiBuilder() {
   if (!Dbi)
-    Dbi = llvm::make_unique<DbiStreamBuilder>(*Msf);
+    Dbi = llvm::make_unique<DbiStreamBuilder>(*MsfBuilder);
   return *Dbi;
 }
 
 TpiStreamBuilder &PDBFileBuilder::getTpiBuilder() {
   if (!Tpi)
-    Tpi = llvm::make_unique<TpiStreamBuilder>(*Msf, StreamTPI);
+    Tpi = llvm::make_unique<TpiStreamBuilder>(*MsfBuilder, StreamTPI);
   return *Tpi;
 }
 
 TpiStreamBuilder &PDBFileBuilder::getIpiBuilder() {
   if (!Ipi)
-    Ipi = llvm::make_unique<TpiStreamBuilder>(*Msf, StreamIPI);
+    Ipi = llvm::make_unique<TpiStreamBuilder>(*MsfBuilder, StreamIPI);
   return *Ipi;
 }
 
-Expected<msf::MSFLayout> PDBFileBuilder::finalizeMsfLayout() const {
+Error PDBFileBuilder::finalizeMsfLayout() {
+  if (Msf)
+    return Error::success();
   if (Info) {
     if (auto EC = Info->finalizeMsfLayout())
-      return std::move(EC);
+      return EC;
   }
   if (Dbi) {
     if (auto EC = Dbi->finalizeMsfLayout())
-      return std::move(EC);
+      return EC;
   }
   if (Tpi) {
     if (auto EC = Tpi->finalizeMsfLayout())
-      return std::move(EC);
+      return EC;
   }
   if (Ipi) {
     if (auto EC = Ipi->finalizeMsfLayout())
-      return std::move(EC);
+      return EC;
   }
 
-  return Msf->build();
+  Expected<msf::MSFLayout> ExpectedMsf = MsfBuilder->build();
+  if (!ExpectedMsf)
+    return ExpectedMsf.takeError();
+  Msf.reset(new MSFLayout(*ExpectedMsf));
+  return Error::success();
 }
 
 Expected<std::unique_ptr<PDBFile>>
 PDBFileBuilder::build(std::unique_ptr<msf::WritableStream> PdbFileBuffer) {
-  auto ExpectedLayout = finalizeMsfLayout();
-  if (!ExpectedLayout)
-    return ExpectedLayout.takeError();
+  if (Error E = finalizeMsfLayout())
+    return std::move(E);
 
   auto File = llvm::make_unique<PDBFile>(std::move(PdbFileBuffer), Allocator);
-  File->ContainerLayout = *ExpectedLayout;
+  File->ContainerLayout = *Msf;
 
   if (Info) {
     auto ExpectedInfo = Info->build(*File, *PdbFileBuffer);
     if (!ExpectedInfo)
       return ExpectedInfo.takeError();
     File->Info = std::move(*ExpectedInfo);
   }
 
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);
-  auto ExpectedLayout = finalizeMsfLayout();
-  if (!ExpectedLayout)
-    return ExpectedLayout.takeError();
-  auto &Layout = *ExpectedLayout;
+  if (Error E = finalizeMsfLayout())
+    return E;
+  msf::MSFLayout &Layout = *Msf;
 
   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(const msf::WritableStream &Buffer) {
   }
 
   if (Ipi) {
     if (auto EC = Ipi->commit(Layout, Buffer))
       return EC;
   }
 
   return Buffer.commit();
-}
+}