Remove PDBFileBuilder::build() and related functions.

[ruiu]

Summary

PDBFileBuilder supports two different ways to create files.
One is PDBFileBuilder::commit. That function takes a filename
and write a result to the file. The other is PDBFileBuilder::build.
That returns a new PDBFile object.

This patch removes the latter because no one is using it and
in a real life situation we are very unlikely to need it.
Even if you need it, it'd be easy to write a new PDB to a memory
buffer and read it back.

Removing PDBFileBuilder::build enables us to remove other classes
build transitively.

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

public:
 
   uint32_t calculateSerializedLength() const;
 
   Error addModuleInfo(StringRef ObjFile, StringRef Module);
   Error addModuleSourceFile(StringRef Module, StringRef File);
 
   Error finalizeMsfLayout();
 
-  Expected<std::unique_ptr<DbiStream>> build(PDBFile &File);
   Error commit(const msf::MSFLayout &Layout,
                const msf::WritableStream &Buffer);
 
   // A helper function to create Section Contributions from COFF input
   // section headers.
   static std::vector<SectionContrib>
   createSectionContribs(ArrayRef<llvm::object::coff_section> SecHdrs);
 

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

public:
   void setGuid(PDB_UniqueId G);
 
   NameMapBuilder &getNamedStreamsBuilder();
 
   uint32_t calculateSerializedLength() const;
 
   Error finalizeMsfLayout();
 
-  Expected<std::unique_ptr<InfoStream>> build(PDBFile &File);
-
   Error commit(const msf::MSFLayout &Layout,
                const msf::WritableStream &Buffer) const;
 
 private:
   msf::MSFBuilder &Msf;
 
   PdbRaw_ImplVer Ver;
   uint32_t Sig;

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

public:
   Error initialize(uint32_t BlockSize);
 
   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(StringRef Filename);
 
 private:
   Expected<msf::MSFLayout> finalizeMsfLayout() const;
 
   BumpPtrAllocator &Allocator;
 
   std::unique_ptr<msf::MSFBuilder> Msf;

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

public:
   TpiStreamBuilder(const TpiStreamBuilder &) = delete;
   TpiStreamBuilder &operator=(const TpiStreamBuilder &) = delete;
 
   void setVersionHeader(PdbRaw_TpiVer Version);
   void addTypeRecord(const codeview::CVType &Record);
 
   Error finalizeMsfLayout();
 
-  Expected<std::unique_ptr<TpiStream>> build(PDBFile &File);
-
   Error commit(const msf::MSFLayout &Layout, const msf::WritableStream &Buffer);
 
   uint32_t calculateSerializedLength() const;
 
 private:
   uint32_t calculateHashBufferSize() const;
   Error finalize();
 

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

std::vector<SecMapEntry> DbiStreamBuilder::createSectionMap(
   auto &Entry = Add();
   Entry.Flags = static_cast<uint16_t>(OMFSegDescFlags::AddressIs32Bit) |
                 static_cast<uint16_t>(OMFSegDescFlags::IsAbsoluteAddress);
   Entry.SecByteLength = UINT32_MAX;
 
   return Ret;
 }
 
-Expected<std::unique_ptr<DbiStream>>
-DbiStreamBuilder::build(PDBFile &File) {
-  if (!VerHeader.hasValue())
-    return make_error<RawError>(raw_error_code::unspecified,
-                                "Missing DBI Stream Version");
-  if (auto EC = finalize())
-    return std::move(EC);
-
-  auto StreamData = MappedBlockStream::createIndexedStream(
-      File.getMsfLayout(), File.getMsfBuffer(), StreamDBI);
-  auto Dbi = llvm::make_unique<DbiStream>(File, std::move(StreamData));
-  Dbi->Header = Header;
-  Dbi->FileInfoSubstream = ReadableStreamRef(FileInfoBuffer);
-  Dbi->ModInfoSubstream = ReadableStreamRef(ModInfoBuffer);
-  if (auto EC = Dbi->initializeModInfoArray())
-    return std::move(EC);
-  if (auto EC = Dbi->initializeFileInfo())
-    return std::move(EC);
-  return std::move(Dbi);
-}
-
 Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout,
                                const msf::WritableStream &Buffer) {
   if (auto EC = finalize())
     return EC;
 
   auto InfoS =
       WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamDBI);
 

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

 
 Error InfoStreamBuilder::finalizeMsfLayout() {
   uint32_t Length = calculateSerializedLength();
   if (auto EC = Msf.setStreamSize(StreamPDB, Length))
     return EC;
   return Error::success();
 }
 
-Expected<std::unique_ptr<InfoStream>>
-InfoStreamBuilder::build(PDBFile &File) {
-  auto StreamData = MappedBlockStream::createIndexedStream(
-      File.getMsfLayout(), File.getMsfBuffer(), StreamPDB);
-  auto Info = llvm::make_unique<InfoStream>(std::move(StreamData));
-  Info->Version = Ver;
-  Info->Signature = Sig;
-  Info->Age = Age;
-  Info->Guid = Guid;
-  auto NS = NamedStreams.build();
-  if (!NS)
-    return NS.takeError();
-  Info->NamedStreams = **NS;
-  return std::move(Info);
-}
-
 Error InfoStreamBuilder::commit(const msf::MSFLayout &Layout,
                                 const msf::WritableStream &Buffer) const {
   auto InfoS =
       WritableMappedBlockStream::createIndexedStream(Layout, Buffer, StreamPDB);
   StreamWriter Writer(*InfoS);
 
   InfoStreamHeader H;
   H.Age = Age;
   H.Signature = Sig;
   H.Version = Ver;
   H.Guid = Guid;
   if (auto EC = Writer.writeObject(H))
     return EC;
 
   return NamedStreams.commit(Writer);
 }

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

Expected<msf::MSFLayout> PDBFileBuilder::finalizeMsfLayout() const {
   if (Ipi) {
     if (auto EC = Ipi->finalizeMsfLayout())
       return std::move(EC);
   }
 
   return Msf->build();
 }
 
-Expected<std::unique_ptr<PDBFile>>
-PDBFileBuilder::build(std::unique_ptr<msf::WritableStream> PdbFileBuffer) {
-  auto ExpectedLayout = finalizeMsfLayout();
-  if (!ExpectedLayout)
-    return ExpectedLayout.takeError();
-
-  auto File = llvm::make_unique<PDBFile>(std::move(PdbFileBuffer), Allocator);
-  File->ContainerLayout = *ExpectedLayout;
-
-  if (Info) {
-    auto ExpectedInfo = Info->build(*File);
-    if (!ExpectedInfo)
-      return ExpectedInfo.takeError();
-    File->Info = std::move(*ExpectedInfo);
-  }
-
-  if (Dbi) {
-    auto ExpectedDbi = Dbi->build(*File);
-    if (!ExpectedDbi)
-      return ExpectedDbi.takeError();
-    File->Dbi = std::move(*ExpectedDbi);
-  }
-
-  if (Tpi) {
-    auto ExpectedTpi = Tpi->build(*File);
-    if (!ExpectedTpi)
-      return ExpectedTpi.takeError();
-    File->Tpi = std::move(*ExpectedTpi);
-  }
-
-  if (Ipi) {
-    auto ExpectedIpi = Ipi->build(*File);
-    if (!ExpectedIpi)
-      return ExpectedIpi.takeError();
-    File->Ipi = std::move(*ExpectedIpi);
-  }
-
-  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(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);

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

for (uint32_t I = 0; I < TypeRecords.size(); ++I) {
     HashBuffer[I] = *TypeRecords[I].Hash % MinTpiHashBuckets;
   }
   ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(HashBuffer.data()),
                           HashBufferSize);
   HashValueStream = llvm::make_unique<ByteStream>(Bytes);
   return Error::success();
 }
 
-Expected<std::unique_ptr<TpiStream>> TpiStreamBuilder::build(PDBFile &File) {
-  if (!VerHeader.hasValue())
-    return make_error<RawError>(raw_error_code::unspecified,
-                                "Missing TPI Stream Version");
-  if (auto EC = finalize())
-    return std::move(EC);
-
-  auto StreamData = MappedBlockStream::createIndexedStream(
-      File.getMsfLayout(), File.getMsfBuffer(), Idx);
-  auto Tpi = llvm::make_unique<TpiStream>(File, std::move(StreamData));
-  Tpi->Header = Header;
-  Tpi->TypeRecords = VarStreamArray<codeview::CVType>(TypeRecordStream);
-  if (HashValueStream) {
-    Tpi->HashStream = std::move(HashValueStream);
-    StreamReader HSR(*Tpi->HashStream);
-    if (auto EC = HSR.readArray(Tpi->HashValues, TypeRecords.size()))
-      return std::move(EC);
-  }
-  return std::move(Tpi);
-}
-
 Error TpiStreamBuilder::commit(const msf::MSFLayout &Layout,
                                const msf::WritableStream &Buffer) {
   if (auto EC = finalize())
     return EC;
 
   auto InfoS =
       WritableMappedBlockStream::createIndexedStream(Layout, Buffer, Idx);