Use MappedBlockStream for parsing the directory

[zturner]

Summary

In order to efficiently write PDBs, we need to be able to make a StreamWriter class similar to a StreamReader, which can transparently deal with writing to discontiguous streams, and we need to use this for all writing, similar to how we use StreamReader for all reading.

Most discontiguous streams are the typical numbered streams that appear in a PDB file and are described by the directory, but the exception to this, that until now has been parsed by hand, is the directory itself. MappedBlockStream works by querying the directory to find out which blocks a stream occupies and various other things, so naturally the same logic could not possibly work to describe the blocks that the directory itself resided on.

To solve this, I've introduced an abstraction IPDBStreamData, which allows the client to query for the list of blocks occupied by the stream, as well as the stream length. I provide two implementations of this: one which queries the directory (for indexed streams), and one which queries the super block (for the directory stream).

This has the side benefit of vastly simplifying the code to parse the directory. Whereas before a mini state machine was rolled by hand, now we simply use FixedStreamArray to read out the stream sizes, then build a vector of FixedStreamArrays for the stream map, all in just a few lines of code.

[ruiu]

LGTM

Introducing a new abstraction make the code slightly more hard to understand, but since this reduces the amount of code by removing multiple pieces of code that do the same thing, I think it is overall win.

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

1–2 ↗

(On Diff #59809)

Format.

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

19–28 ↗

(On Diff #59809)

Remove duplicate comment.

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

public:
 
   FixedStreamArrayIterator<T> begin() const {
     return FixedStreamArrayIterator<T>(*this, 0);
   }
   FixedStreamArrayIterator<T> end() const {
     return FixedStreamArrayIterator<T>(*this, size());
   }
 
+  StreamRef getUnderlyingStream() const { return Stream; }
+
 private:
   StreamRef Stream;
 };
 
 template <typename T> class FixedStreamArrayIterator {
 public:
   FixedStreamArrayIterator(const FixedStreamArray<T> &Array, uint32_t Index)
       : Array(Array), Index(Index) {}

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

public:
   template <typename T> Error readObject(const T *&Dest) {
     ArrayRef<uint8_t> Buffer;
     if (auto EC = readBytes(Buffer, sizeof(T)))
       return EC;
     Dest = reinterpret_cast<const T *>(Buffer.data());
     return Error::success();
   }
 
+  template <typename T>
+  Error readArray(ArrayRef<T> &Array, uint32_t NumElements) {
+    ArrayRef<uint8_t> Bytes;
+    if (NumElements == 0) {
+      Array = ArrayRef<T>();
+      return Error::success();
+    }
+
+    if (auto EC = readBytes(Bytes, NumElements * sizeof(T)))
+      return EC;
+    Array = ArrayRef<T>(reinterpret_cast<const T *>(Bytes.data()), NumElements);
+    return Error::success();
+  }
+
   template <typename T, typename U>
   Error readArray(VarStreamArray<T, U> &Array, uint32_t Size) {
     StreamRef S;
     if (auto EC = readStreamRef(S, Size))
       return EC;
     Array = VarStreamArray<T, U>(S, Array.getExtractor());
     return Error::success();
   }

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

 //===- IPDBFile.h - Abstract base class for a PDB file ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_IPDBFILE_H
 #define LLVM_DEBUGINFO_PDB_RAW_IPDBFILE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/Support/Endian.h"
 
 #include <stdint.h>
 
 namespace llvm {
 namespace pdb {
 
 class IPDBFile {
 public:
   virtual ~IPDBFile() {}
 
   virtual uint32_t getBlockSize() const = 0;
   virtual uint32_t getBlockCount() const = 0;
 
   virtual uint32_t getNumStreams() const = 0;
   virtual uint32_t getStreamByteSize(uint32_t StreamIndex) const = 0;
-  virtual ArrayRef<uint32_t> getStreamBlockList(uint32_t StreamIndex) const = 0;
+  virtual ArrayRef<support::ulittle32_t>
+  getStreamBlockList(uint32_t StreamIndex) const = 0;
 
   virtual StringRef getBlockData(uint32_t BlockIndex,
                                  uint32_t NumBytes) const = 0;
 };
 }
 }
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_IPDBFILE_H

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

+//===- IPDBStreamData.h - Base interface for PDB Stream Data ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_IPDBSTREAMDATA_H
+#define LLVM_DEBUGINFO_PDB_RAW_IPDBSTREAMDATA_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Endian.h"
+
+namespace llvm {
+namespace pdb {
+/// IPDBStream abstracts the notion of PDB stream data.  Although we already
+/// have another stream abstraction (namely in the form of StreamInterface
+/// and MappedBlockStream), they assume that the stream data is referenced
+/// the same way.  Namely, by looking in the directory to get the list of
+/// stream blocks, and by looking in the array of stream lengths to get the
+/// length.  This breaks down for the directory itself, however, since its
+/// length and list of blocks are stored elsewhere.  By abstracting the
+/// notion of stream data further, we can use a MappedBlockStream to read
+/// from the directory itself, or from an indexed stream which references
+/// the directory.
+class IPDBStreamData {
+public:
+  virtual ~IPDBStreamData() {}
+
+  virtual uint32_t getLength() = 0;
+  virtual ArrayRef<support::ulittle32_t> getStreamBlocks() = 0;
+};
+}
+}
+
+#endif

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

+//===- IndexedStreamData.h - Standard PDB Stream Data -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_INDEXEDSTREAMDATA_H
+#define LLVM_DEBUGINFO_PDB_RAW_INDEXEDSTREAMDATA_H
+
+#include "llvm/DebugInfo/PDB/Raw/IPDBStreamData.h"
+
+namespace llvm {
+namespace pdb {
+class IPDBFile;
+
+class IndexedStreamData : public IPDBStreamData {
+public:
+  IndexedStreamData(uint32_t StreamIdx, const IPDBFile &File);
+  virtual ~IndexedStreamData() {}
+
+  uint32_t getLength() override;
+  ArrayRef<support::ulittle32_t> getStreamBlocks() override;
+
+private:
+  uint32_t StreamIdx;
+  const IPDBFile &File;
+};
+}
+}
+
+#endif

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

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class PDBFile;
 class InfoStream {
 public:
-  InfoStream(PDBFile &File);
+  InfoStream(const PDBFile &File);
 
   Error reload();
 
   PdbRaw_ImplVer getVersion() const;
   uint32_t getSignature() const;
   uint32_t getAge() const;
   PDB_UniqueId getGuid() const;
 
   uint32_t getNamedStreamIndex(llvm::StringRef Name) const;
   iterator_range<StringMapConstIterator<uint32_t>> named_streams() const;
 
-  PDBFile &getFile() { return Pdb; }
-
 private:
-  PDBFile &Pdb;
   MappedBlockStream Stream;
 
   // PDB file format version.  We only support VC70.  See the enumeration
   // `PdbRaw_ImplVer` for the other possible values.
   uint32_t Version;
 
   // A 32-bit signature unique across all PDBs.  This is generated with
   // a call to time() when the PDB is written, but obviously this is not

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

 //===- MappedBlockStream.h - Reads stream data from a PDBFile ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/CodeView/StreamInterface.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace pdb {
 
 class IPDBFile;
+class IPDBStreamData;
 
 class MappedBlockStream : public codeview::StreamInterface {
 public:
-  MappedBlockStream(uint32_t StreamIdx, const IPDBFile &File);
+  MappedBlockStream(std::unique_ptr<IPDBStreamData> Data, const IPDBFile &File);
 
   Error readBytes(uint32_t Offset, uint32_t Size,
                   ArrayRef<uint8_t> &Buffer) const override;
 
-  uint32_t getLength() const override { return StreamLength; }
+  uint32_t getLength() const override;
 
   uint32_t getNumBytesCopied() const;
 
 private:
   Error readBytes(uint32_t Offset, MutableArrayRef<uint8_t> Buffer) const;
   bool tryReadContiguously(uint32_t Offset, uint32_t Size,
                            ArrayRef<uint8_t> &Buffer) const;
 
-  uint32_t StreamLength;
-  std::vector<uint32_t> BlockList;
+  const IPDBFile &Pdb;
+  std::unique_ptr<IPDBStreamData> Data;
+
   mutable llvm::BumpPtrAllocator Pool;
   mutable DenseMap<uint32_t, uint8_t *> CacheMap;
-  const IPDBFile &Pdb;
 };
 
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H

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

 
 namespace llvm {
 namespace pdb {
 class PDBFile;
 class ModInfo;
 
 class ModStream {
 public:
-  ModStream(PDBFile &File, const ModInfo &Module);
+  ModStream(const PDBFile &File, const ModInfo &Module);
   ~ModStream();
 
   Error reload();
 
   iterator_range<codeview::CVSymbolArray::Iterator>
   symbols(bool *HadError) const;
 
   iterator_range<codeview::ModuleSubstreamArray::Iterator>

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

 //===- PDBFile.h - Low level interface to a PDB file ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBFILE_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBFILE_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/PDB/Raw/IPDBFile.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 
 #include <memory>
 
 namespace llvm {
public:
   uint32_t getBlockCount() const override;
   uint32_t getNumDirectoryBytes() const;
   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<uint32_t> getStreamBlockList(uint32_t StreamIndex) const override;
+  ArrayRef<support::ulittle32_t>
+  getStreamBlockList(uint32_t StreamIndex) const override;
 
   StringRef getBlockData(uint32_t BlockIndex, uint32_t NumBytes) const override;
 
-  ArrayRef<support::ulittle32_t> getDirectoryBlockArray();
+  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;
   }
 

 private:
   std::unique_ptr<PDBFileContext> Context;
   std::unique_ptr<InfoStream> Info;
   std::unique_ptr<DbiStream> Dbi;
   std::unique_ptr<TpiStream> Tpi;
   std::unique_ptr<TpiStream> Ipi;
   std::unique_ptr<PublicsStream> Publics;
   std::unique_ptr<SymbolStream> Symbols;
+  std::unique_ptr<MappedBlockStream> DirectoryStream;
   std::unique_ptr<MappedBlockStream> StringTableStream;
   std::unique_ptr<NameHashTable> StringTable;
 };
 }
 }
 
 #endif

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

 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class PDBFile;
 
 class SymbolStream {
 public:
-  SymbolStream(PDBFile &File, uint32_t StreamNum);
+  SymbolStream(const PDBFile &File, uint32_t StreamNum);
   ~SymbolStream();
   Error reload();
 
   iterator_range<codeview::CVSymbolArray::Iterator>
   getSymbols(bool *HadError) const;
 
 private:
   codeview::CVSymbolArray SymbolRecords;
   MappedBlockStream MappedStream;
 };
 }
 }
 
 #endif

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

 class PDBFile;
 
 typedef uint32_t (*HashFunctionType)(uint8_t *, uint32_t);
 
 class TpiStream {
   struct HeaderInfo;
 
 public:
-  TpiStream(PDBFile &File, uint32_t StreamIdx);
+  TpiStream(const PDBFile &File, uint32_t StreamIdx);
   ~TpiStream();
   Error reload();
 
   PdbRaw_TpiVer getTpiVersion() const;
 
   uint32_t TypeIndexBegin() const;
   uint32_t TypeIndexEnd() const;
   uint32_t NumTypeRecords() const;
   uint16_t getTypeHashStreamIndex() const;
   uint16_t getTypeHashStreamAuxIndex() const;
 
   codeview::FixedStreamArray<support::ulittle32_t> getHashValues() const;
   codeview::FixedStreamArray<TypeIndexOffset> getTypeIndexOffsets() const;
   codeview::FixedStreamArray<TypeIndexOffset> getHashAdjustments() const;
 
   iterator_range<codeview::CVTypeArray::Iterator> types(bool *HadError) const;
 
 private:
-  PDBFile &Pdb;
+  const PDBFile &Pdb;
   MappedBlockStream Stream;
   HashFunctionType HashFunction;
 
   codeview::CVTypeArray TypeRecords;
 
   std::unique_ptr<MappedBlockStream> HashStream;
   codeview::FixedStreamArray<support::ulittle32_t> HashValues;
   codeview::FixedStreamArray<TypeIndexOffset> TypeIndexOffsets;
   codeview::FixedStreamArray<TypeIndexOffset> HashAdjustments;
 
   const HeaderInfo *Header;
 };
 }
 }
 
 #endif

llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt

add_pdb_impl_folder(DIA
     )
 
     set(LIBPDB_ADDITIONAL_HEADER_DIRS "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/PDB/DIA")
 endif()
 
 add_pdb_impl_folder(Raw
   Raw/DbiStream.cpp
   Raw/EnumTables.cpp
+  Raw/IndexedStreamData.cpp
   Raw/InfoStream.cpp
   Raw/MappedBlockStream.cpp
   Raw/ModInfo.cpp
   Raw/ModStream.cpp
   Raw/NameHashTable.cpp
   Raw/NameMap.cpp
   Raw/PDBFile.cpp
   Raw/PublicsStream.cpp

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

 //===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
 //
 //                     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/DbiStream.h"
 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.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/RawTypes.h"
 #include "llvm/Object/COFF.h"
Error loadSectionContribs(FixedStreamArray<ContribType> &Output,
 
   uint32_t Count = Reader.bytesRemaining() / sizeof(ContribType);
   if (auto EC = Reader.readArray(Output, Count))
     return EC;
   return Error::success();
 }
 
 DbiStream::DbiStream(PDBFile &File)
-    : Pdb(File), Stream(StreamDBI, File), Header(nullptr) {
+    : Pdb(File),
+      Stream(llvm::make_unique<IndexedStreamData>(StreamDBI, File), File),
+      Header(nullptr) {
   static_assert(sizeof(HeaderInfo) == 64, "Invalid HeaderInfo size!");
 }
 
 DbiStream::~DbiStream() {}
 
 Error DbiStream::reload() {
   StreamReader Reader(Stream);
 
Error DbiStream::initializeSectionContributionData() {
 
   return make_error<RawError>(raw_error_code::feature_unsupported,
                               "Unsupported DBI Section Contribution version");
 }
 
 // Initializes this->SectionHeaders.
 Error DbiStream::initializeSectionHeadersData() {
   uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::SectionHdr);
-  SectionHeaderStream.reset(new MappedBlockStream(StreamNum, Pdb));
+  SectionHeaderStream.reset(new MappedBlockStream(
+      llvm::make_unique<IndexedStreamData>(StreamNum, Pdb), Pdb));
 
   size_t StreamLen = SectionHeaderStream->getLength();
   if (StreamLen % sizeof(object::coff_section))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Corrupted section header stream.");
 
   size_t NumSections = StreamLen / sizeof(object::coff_section);
   codeview::StreamReader Reader(*SectionHeaderStream);
   if (auto EC = Reader.readArray(SectionHeaders, NumSections))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Could not read a bitmap.");
   return Error::success();
 }
 
 // Initializes this->Fpos.
 Error DbiStream::initializeFpoRecords() {
   uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::NewFPO);
-  FpoStream.reset(new MappedBlockStream(StreamNum, Pdb));
+  FpoStream.reset(new MappedBlockStream(
+      llvm::make_unique<IndexedStreamData>(StreamNum, Pdb), Pdb));
 
   size_t StreamLen = FpoStream->getLength();
   if (StreamLen % sizeof(object::FpoData))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Corrupted New FPO stream.");
 
   size_t NumRecords = StreamLen / sizeof(object::FpoData);
   codeview::StreamReader Reader(*FpoStream);

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

+//===- IndexedStreamData.cpp - Standard PDB Stream Data ---------*- 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/IndexedStreamData.h"
+#include "llvm/DebugInfo/PDB/Raw/IPDBFile.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+
+IndexedStreamData::IndexedStreamData(uint32_t StreamIdx, const IPDBFile &File)
+    : StreamIdx(StreamIdx), File(File) {}
+
+uint32_t IndexedStreamData::getLength() {
+  return File.getStreamByteSize(StreamIdx);
+}
+
+ArrayRef<support::ulittle32_t> IndexedStreamData::getStreamBlocks() {
+  return File.getStreamBlockList(StreamIdx);
+}

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

 //===- InfoStream.cpp - PDB Info Stream (Stream 1) Access -------*- 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/InfoStream.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
-InfoStream::InfoStream(PDBFile &File) : Pdb(File), Stream(StreamPDB, File) {}
+InfoStream::InfoStream(const PDBFile &File)
+    : Stream(llvm::make_unique<IndexedStreamData>(StreamPDB, File), File) {}
 
 Error InfoStream::reload() {
   codeview::StreamReader Reader(Stream);
 
   struct Header {
     support::ulittle32_t Version;
     support::ulittle32_t Signature;
     support::ulittle32_t Age;

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

 //===- MappedBlockStream.cpp - Reads stream data from a PDBFile -----------===//
 //
 //                     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/MappedBlockStream.h"
+#include "llvm/DebugInfo/PDB/Raw/IPDBStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
-MappedBlockStream::MappedBlockStream(uint32_t StreamIdx, const IPDBFile &File)
-    : Pdb(File) {
-  if (StreamIdx >= Pdb.getNumStreams()) {
-    StreamLength = 0;
-  } else {
-    StreamLength = Pdb.getStreamByteSize(StreamIdx);
-    BlockList = Pdb.getStreamBlockList(StreamIdx);
-  }
-}
+MappedBlockStream::MappedBlockStream(std::unique_ptr<IPDBStreamData> Data,
+                                     const IPDBFile &Pdb)
+    : Pdb(Pdb), Data(std::move(Data)) {}
 
 Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size,
                                    ArrayRef<uint8_t> &Buffer) const {
   // Make sure we aren't trying to read beyond the end of the stream.
-  if (Size > StreamLength)
+  if (Size > Data->getLength())
     return make_error<RawError>(raw_error_code::insufficient_buffer);
-  if (Offset > StreamLength - Size)
+  if (Offset > Data->getLength() - Size)
     return make_error<RawError>(raw_error_code::insufficient_buffer);
 
   if (tryReadContiguously(Offset, Size, Buffer))
     return Error::success();
 
   auto CacheIter = CacheMap.find(Offset);
   if (CacheIter != CacheMap.end()) {
     // In a more general solution, we would need to guarantee that the
Error MappedBlockStream::readBytes(uint32_t Offset, uint32_t Size,
 
   if (auto EC = readBytes(Offset, MutableArrayRef<uint8_t>(WriteBuffer, Size)))
     return EC;
   CacheMap.insert(std::make_pair(Offset, WriteBuffer));
   Buffer = ArrayRef<uint8_t>(WriteBuffer, Size);
   return Error::success();
 }
 
+uint32_t MappedBlockStream::getLength() const { return Data->getLength(); }
+
 bool MappedBlockStream::tryReadContiguously(uint32_t Offset, uint32_t Size,
                                             ArrayRef<uint8_t> &Buffer) const {
   // Attempt to fulfill the request with a reference directly into the stream.
   // This can work even if the request crosses a block boundary, provided that
   // all subsequent blocks are contiguous.  For example, a 10k read with a 4k
   // block size can be filled with a reference if, from the starting offset,
   // 3 blocks in a row are contiguous.
   uint32_t BlockNum = Offset / Pdb.getBlockSize();
   uint32_t OffsetInBlock = Offset % Pdb.getBlockSize();
   uint32_t BytesFromFirstBlock =
       std::min(Size, Pdb.getBlockSize() - OffsetInBlock);
   uint32_t NumAdditionalBlocks =
       llvm::alignTo(Size - BytesFromFirstBlock, Pdb.getBlockSize()) /
       Pdb.getBlockSize();
 
+  auto BlockList = Data->getStreamBlocks();
   uint32_t RequiredContiguousBlocks = NumAdditionalBlocks + 1;
   uint32_t E = BlockList[BlockNum];
   for (uint32_t I = 0; I < RequiredContiguousBlocks; ++I, ++E) {
     if (BlockList[I + BlockNum] != E)
       return false;
   }
 
   uint32_t FirstBlockAddr = BlockList[BlockNum];
   StringRef Str = Pdb.getBlockData(FirstBlockAddr, Pdb.getBlockSize());
   Str = Str.drop_front(OffsetInBlock);
   Buffer =
       ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(Str.data()), Size);
   return true;
 }
 
 Error MappedBlockStream::readBytes(uint32_t Offset,
                                    MutableArrayRef<uint8_t> Buffer) const {
   uint32_t BlockNum = Offset / Pdb.getBlockSize();
   uint32_t OffsetInBlock = Offset % Pdb.getBlockSize();
 
   // Make sure we aren't trying to read beyond the end of the stream.
-  if (Buffer.size() > StreamLength)
+  if (Buffer.size() > Data->getLength())
     return make_error<RawError>(raw_error_code::insufficient_buffer);
-  if (Offset > StreamLength - Buffer.size())
+  if (Offset > Data->getLength() - Buffer.size())
     return make_error<RawError>(raw_error_code::insufficient_buffer);
 
   uint32_t BytesLeft = Buffer.size();
   uint32_t BytesWritten = 0;
   uint8_t *WriteBuffer = Buffer.data();
+  auto BlockList = Data->getStreamBlocks();
   while (BytesLeft > 0) {
     uint32_t StreamBlockAddr = BlockList[BlockNum];
 
     StringRef Data = Pdb.getBlockData(StreamBlockAddr, Pdb.getBlockSize());
 
     const char *ChunkStart = Data.data() + OffsetInBlock;
     uint32_t BytesInChunk =
         std::min(BytesLeft, Pdb.getBlockSize() - OffsetInBlock);

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

 //===- ModStream.cpp - PDB Module Info Stream Access ----------------------===//
 //
 //                     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/ModStream.h"
 
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
-ModStream::ModStream(PDBFile &File, const ModInfo &Module)
-    : Mod(Module), Stream(Module.getModuleStreamIndex(), File) {}
+ModStream::ModStream(const PDBFile &File, const ModInfo &Module)
+    : Mod(Module), Stream(llvm::make_unique<IndexedStreamData>(
+                              Module.getModuleStreamIndex(), File),
+                          File) {}
 
 ModStream::~ModStream() {}
 
 Error ModStream::reload() {
   codeview::StreamReader Reader(Stream);
 
   uint32_t SymbolSize = Mod.getSymbolDebugInfoByteSize();
   uint32_t C11Size = Mod.getLineInfoByteSize();

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

 //===- PDBFile.cpp - Low level interface to a PDB file ----------*- 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/PDBFile.h"
+
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/DebugInfo/CodeView/StreamArray.h"
+#include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
+#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/MemoryBuffer.h"
struct SuperBlock {
   support::ulittle32_t NumBlocks;
   // This contains the number of bytes which make up the directory.
   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;
 };
+
+class DirectoryStreamData : public IPDBStreamData {
+public:
+  DirectoryStreamData(const PDBFile &File) : File(File) {}
+
+  virtual uint32_t getLength() { return File.getNumDirectoryBytes(); }
+  virtual llvm::ArrayRef<llvm::support::ulittle32_t> getStreamBlocks() {
+    return File.getDirectoryBlockArray();
+  }
+
+private:
+  const PDBFile &File;
+};
+
+typedef codeview::FixedStreamArray<support::ulittle32_t> ulittle_array;
 }
 
 struct llvm::pdb::PDBFileContext {
   std::unique_ptr<MemoryBuffer> Buffer;
   const SuperBlock *SB;
-  std::vector<uint32_t> StreamSizes;
-  DenseMap<uint32_t, std::vector<uint32_t>> StreamMap;
+  ArrayRef<support::ulittle32_t> StreamSizes;
+  std::vector<ulittle_array> StreamMap;
 };
 
 static Error checkOffset(MemoryBufferRef M, uintptr_t Addr,
                          const uint64_t Size) {
   if (Addr + Size < Addr || Addr + Size < Size ||
       Addr + Size > uintptr_t(M.getBufferEnd()) ||
       Addr < uintptr_t(M.getBufferStart())) {
     return make_error<RawError>(raw_error_code::corrupt_file,

 }
 
 uint32_t PDBFile::getNumStreams() const { return Context->StreamSizes.size(); }
 
 uint32_t PDBFile::getStreamByteSize(uint32_t StreamIndex) const {
   return Context->StreamSizes[StreamIndex];
 }
 
-llvm::ArrayRef<uint32_t>
+ArrayRef<support::ulittle32_t>
 PDBFile::getStreamBlockList(uint32_t StreamIndex) const {
-  auto &Data = Context->StreamMap[StreamIndex];
-  return llvm::ArrayRef<uint32_t>(Data);
+  auto Result = Context->StreamMap[StreamIndex];
+  codeview::StreamReader Reader(Result.getUnderlyingStream());
+  ArrayRef<support::ulittle32_t> Array;
+  if (auto EC = Reader.readArray(Array, Result.size()))
+    return ArrayRef<support::ulittle32_t>();
+  return Array;
 }
 
 StringRef PDBFile::getBlockData(uint32_t BlockIndex, uint32_t NumBytes) const {
   uint64_t StreamBlockOffset = blockToOffset(BlockIndex, getBlockSize());
 
   return StringRef(Context->Buffer->getBufferStart() + StreamBlockOffset,
                    NumBytes);
 }
Error PDBFile::parseFileHeaders() {
   if (auto EC = checkOffset(BufferRef, getDirectoryBlockArray()))
     return EC;
 
   return Error::success();
 }
 
 Error PDBFile::parseStreamData() {
   assert(Context && Context->SB);
+  if (DirectoryStream)
+    return Error::success();
 
-  bool SeenNumStreams = false;
+  // bool SeenNumStreams = false;
   uint32_t NumStreams = 0;
-  uint32_t StreamIdx = 0;
-  uint64_t DirectoryBytesRead = 0;
+  // uint32_t StreamIdx = 0;
+  // uint64_t DirectoryBytesRead = 0;
 
-  MemoryBufferRef M = *Context->Buffer;
   const SuperBlock *SB = Context->SB;
 
-  auto DirectoryBlocks = getDirectoryBlockArray();
-
-  // The structure of the directory is as follows:
-  //    struct PDBDirectory {
-  //      uint32_t NumStreams;
-  //      uint32_t StreamSizes[NumStreams];
-  //      uint32_t StreamMap[NumStreams][];
-  //    };
-  //
-  //  Empty streams don't consume entries in the StreamMap.
-  for (uint32_t DirectoryBlockAddr : DirectoryBlocks) {
-    uint64_t DirectoryBlockOffset =
-        blockToOffset(DirectoryBlockAddr, SB->BlockSize);
-    auto DirectoryBlock =
-        makeArrayRef(reinterpret_cast<const support::ulittle32_t *>(
-                         M.getBufferStart() + DirectoryBlockOffset),
-                     SB->BlockSize / sizeof(support::ulittle32_t));
-    if (auto EC = checkOffset(M, DirectoryBlock))
-      return EC;
+  // Normally you can't use a MappedBlockStream without having fully parsed the
+  // PDB file, because it accesses the directory and various other things, which
+  // is exactly what we are attempting to parse.  By specifying a custom
+  // subclass of IPDBStreamData which only accesses the fields that have already
+  // been parsed, we can avoid this and reuse MappedBlockStream.
+  auto SD = llvm::make_unique<DirectoryStreamData>(*this);
+  DirectoryStream = llvm::make_unique<MappedBlockStream>(std::move(SD), *this);
+  codeview::StreamReader Reader(*DirectoryStream);
+  if (auto EC = Reader.readInteger(NumStreams))
 
-    // We read data out of the directory four bytes at a time.  Depending on
-    // where we are in the directory, the contents may be: the number of streams
-    // in the directory, a stream's size, or a block in the stream map.
-    for (uint32_t Data : DirectoryBlock) {
-      // Don't read beyond the end of the directory.
-      if (DirectoryBytesRead == SB->NumDirectoryBytes)
-        break;
-
-      DirectoryBytesRead += sizeof(Data);
-
-      // This data must be the number of streams if we haven't seen it yet.
-      if (!SeenNumStreams) {
-        NumStreams = Data;
-        SeenNumStreams = true;
-        continue;
-      }
-      // This data must be a stream size if we have not seen them all yet.
-      if (Context->StreamSizes.size() < NumStreams) {
-        // It seems like some streams have their set to -1 when their contents
-        // are not present.  Treat them like empty streams for now.
-        if (Data == UINT32_MAX)
-          Context->StreamSizes.push_back(0);
-        else
-          Context->StreamSizes.push_back(Data);
-        continue;
-      }
-
-      // This data must be a stream block number if we have seen all of the
-      // stream sizes.
-      std::vector<uint32_t> *StreamBlocks = nullptr;
-      // Figure out which stream this block number belongs to.
-      while (StreamIdx < NumStreams) {
-        uint64_t NumExpectedStreamBlocks =
-            bytesToBlocks(Context->StreamSizes[StreamIdx], SB->BlockSize);
-        StreamBlocks = &Context->StreamMap[StreamIdx];
-        if (NumExpectedStreamBlocks > StreamBlocks->size())
-          break;
-        ++StreamIdx;
-      }
-      // It seems this block doesn't belong to any stream?  The stream is either
-      // corrupt or something more mysterious is going on.
-      if (StreamIdx == NumStreams)
-        return make_error<RawError>(raw_error_code::corrupt_file,
-                                    "Orphaned block found?");
-
-      uint64_t BlockOffset = blockToOffset(Data, getBlockSize());
-      if (BlockOffset + getBlockSize() < BlockOffset)
-        return make_error<RawError>(raw_error_code::corrupt_file,
-                                    "Bogus stream block number");
-      if (BlockOffset + getBlockSize() > M.getBufferSize())
-        return make_error<RawError>(raw_error_code::corrupt_file,
-                                    "Stream block number is out of bounds");
-
-      StreamBlocks->push_back(Data);
-    }
-  }
-
-  if (Context->StreamSizes.size() != NumStreams)
-    return make_error<RawError>(
-        raw_error_code::corrupt_file,
-        "The directory has fewer streams then expected");
-
-  for (uint32_t I = 0; I != NumStreams; ++I) {
+  if (auto EC = Reader.readArray(Context->StreamSizes, NumStreams))
+    return EC;
+  for (uint32_t I = 0; I < NumStreams; ++I) {
     uint64_t NumExpectedStreamBlocks =
-        bytesToBlocks(getStreamByteSize(I), getBlockSize());
-    size_t NumStreamBlocks = getStreamBlockList(I).size();
-    if (NumExpectedStreamBlocks != NumStreamBlocks)
-      return make_error<RawError>(raw_error_code::corrupt_file,
-                                  "The number of stream blocks is not "
-                                  "sufficient for the size of this stream");
+        bytesToBlocks(getStreamByteSize(I), SB->BlockSize);
+    ulittle_array Blocks;
+    if (auto EC = Reader.readArray(Blocks, NumExpectedStreamBlocks))
+      return EC;
+    Context->StreamMap.push_back(Blocks);
   }
 
   // We should have read exactly SB->NumDirectoryBytes bytes.
-  assert(DirectoryBytesRead == SB->NumDirectoryBytes);
+  assert(Reader.bytesRemaining() == 0);
   return Error::success();
 }
 
-llvm::ArrayRef<support::ulittle32_t> PDBFile::getDirectoryBlockArray() {
+llvm::ArrayRef<support::ulittle32_t> PDBFile::getDirectoryBlockArray() const {
   return makeArrayRef(
       reinterpret_cast<const support::ulittle32_t *>(
           Context->Buffer->getBufferStart() + getBlockMapOffset()),
       getNumDirectoryBlocks());
 }
 
 Expected<InfoStream &> PDBFile::getPDBInfoStream() {
   if (!Info) {
if (!StringTable || !StringTableStream) {
     auto InfoS = getPDBInfoStream();
     if (auto EC = InfoS.takeError())
       return std::move(EC);
     auto &IS = InfoS.get();
     uint32_t NameStreamIndex = IS.getNamedStreamIndex("/names");
 
     if (NameStreamIndex == 0)
       return make_error<RawError>(raw_error_code::no_stream);
-    auto S = llvm::make_unique<MappedBlockStream>(NameStreamIndex, *this);
+    auto SD = llvm::make_unique<IndexedStreamData>(NameStreamIndex, *this);
+    auto S = llvm::make_unique<MappedBlockStream>(std::move(SD), *this);
     codeview::StreamReader Reader(*S);
     auto N = llvm::make_unique<NameHashTable>();
     if (auto EC = N->load(Reader))
       return std::move(EC);
     StringTable = std::move(N);
     StringTableStream = std::move(S);
   }
   return *StringTable;
 }

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

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.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/SymbolStream.h"
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/Support/Endian.h"
struct PublicsStream::GSIHashHeader {
   };
   ulittle32_t VerSignature;
   ulittle32_t VerHdr;
   ulittle32_t HrSize;
   ulittle32_t NumBuckets;
 };
 
 PublicsStream::PublicsStream(PDBFile &File, uint32_t StreamNum)
-    : Pdb(File), StreamNum(StreamNum), Stream(StreamNum, File) {}
+    : Pdb(File), StreamNum(StreamNum),
+      Stream(llvm::make_unique<IndexedStreamData>(StreamNum, File), File) {}
 
 PublicsStream::~PublicsStream() {}
 
 uint32_t PublicsStream::getSymHash() const { return Header->SymHash; }
 uint32_t PublicsStream::getAddrMap() const { return Header->AddrMap; }
 
 // Publics stream contains fixed-size headers and a serialized hash table.
 // This implementation is not complete yet. It reads till the end of the

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

 //===- SymbolStream.cpp - PDB Symbol Stream Access ------------------------===//
 //
 //                     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/SymbolStream.h"
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
 using namespace llvm::support;
 using namespace llvm::pdb;
 
-SymbolStream::SymbolStream(PDBFile &File, uint32_t StreamNum)
-    : MappedStream(StreamNum, File) {}
+SymbolStream::SymbolStream(const PDBFile &File, uint32_t StreamNum)
+    : MappedStream(llvm::make_unique<IndexedStreamData>(StreamNum, File),
+                   File) {}
 
 SymbolStream::~SymbolStream() {}
 
 Error SymbolStream::reload() {
   codeview::StreamReader Reader(MappedStream);
 
   if (auto EC = Reader.readArray(SymbolRecords, MappedStream.getLength()))
     return EC;
 
   return Error::success();
 }
 
 iterator_range<codeview::CVSymbolArray::Iterator>
 SymbolStream::getSymbols(bool *HadError) const {
   return llvm::make_range(SymbolRecords.begin(HadError), SymbolRecords.end());
 }

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

 //===- TpiStream.cpp - PDB Type Info (TPI) Stream 2 Access ----------------===//
 //
 //                     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/TpiStream.h"
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.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/RawTypes.h"
 
 #include "llvm/Support/Endian.h"
 
struct TpiStream::HeaderInfo {
   ulittle32_t HashKeySize;
   ulittle32_t NumHashBuckets;
 
   EmbeddedBuf HashValueBuffer;
   EmbeddedBuf IndexOffsetBuffer;
   EmbeddedBuf HashAdjBuffer;
 };
 
-TpiStream::TpiStream(PDBFile &File, uint32_t StreamIdx)
-    : Pdb(File), Stream(StreamIdx, File), HashFunction(nullptr) {}
+TpiStream::TpiStream(const PDBFile &File, uint32_t StreamIdx)
+    : Pdb(File),
+      Stream(llvm::make_unique<IndexedStreamData>(StreamIdx, File), File),
+      HashFunction(nullptr) {}
 
 TpiStream::~TpiStream() {}
 
 Error TpiStream::reload() {
   codeview::StreamReader Reader(Stream);
 
   if (Reader.bytesRemaining() < sizeof(HeaderInfo))
     return make_error<RawError>(raw_error_code::corrupt_file,
Error TpiStream::reload() {
 
   HashFunction = HashBufferV8;
 
   // The actual type records themselves come from this stream
   if (auto EC = Reader.readArray(TypeRecords, Header->TypeRecordBytes))
     return EC;
 
   // Hash indices, hash values, etc come from the hash stream.
-  HashStream.reset(new MappedBlockStream(Header->HashStreamIndex, Pdb));
+  HashStream.reset(new MappedBlockStream(
+      llvm::make_unique<IndexedStreamData>(Header->HashStreamIndex, Pdb), Pdb));
   codeview::StreamReader HSR(*HashStream);
 
   uint32_t NumHashValues = Header->HashValueBuffer.Length / sizeof(ulittle32_t);
   if (NumHashValues != NumTypeRecords())
     return make_error<RawError>(
         raw_error_code::corrupt_file,
         "TPI hash count does not match with the number of type records.");
   HSR.setOffset(Header->HashValueBuffer.Off);

llvm/trunk/lib/DebugInfo/PDB/Raw/TpiStream.cpp.rej

+diff a/lib/DebugInfo/PDB/Raw/TpiStream.cpp b/lib/DebugInfo/PDB/Raw/TpiStream.cpp  (rejected hunks)
+@@ -101,7 +104,8 @@
+     return EC;
+ 
+   // Hash indices, hash values, etc come from the hash stream.
+-  HashStream.reset(new MappedBlockStream(Header->HashStreamIndex, Pdb));
++  HashStream.reset(new MappedBlockStream(
++      llvm::make_unique<IndexedStreamData>(Header->HashStreamIndex, Pdb), Pdb));
+   codeview::StreamReader HSR(*HashStream);
+   uint32_t NumHashValues = Header->HashValueBuffer.Length / sizeof(ulittle32_t);
+   HSR.setOffset(Header->HashValueBuffer.Off);

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

 #include "llvm-pdbdump.h"
 #include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h"
 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Raw/EnumTables.h"
 #include "llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h"
+#include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/ModStream.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
 #include "llvm/Object/COFF.h"

 Error LLVMOutputStyle::dumpStreamData() {
   uint32_t StreamCount = File.getNumStreams();
   StringRef DumpStreamStr = opts::DumpStreamDataIdx;
   uint32_t DumpStreamNum;
   if (DumpStreamStr.getAsInteger(/*Radix=*/0U, DumpStreamNum) ||
       DumpStreamNum >= StreamCount)
     return Error::success();
 
-  MappedBlockStream S(DumpStreamNum, File);
+  MappedBlockStream S(llvm::make_unique<IndexedStreamData>(DumpStreamNum, File),
+                      File);
   codeview::StreamReader R(S);
   while (R.bytesRemaining() > 0) {
     ArrayRef<uint8_t> Data;
     uint32_t BytesToReadInBlock = std::min(
         R.bytesRemaining(), static_cast<uint32_t>(File.getBlockSize()));
     if (auto EC = R.readBytes(Data, BytesToReadInBlock))
       return EC;
     P.printBinaryBlock(
Error LLVMOutputStyle::dumpNamedStream() {
 
   if (NameStreamIndex != 0) {
     std::string Name("Stream '");
     Name += opts::DumpStreamDataName;
     Name += "'";
     DictScope D(P, Name);
     P.printNumber("Index", NameStreamIndex);
 
-    MappedBlockStream NameStream(NameStreamIndex, File);
+    MappedBlockStream NameStream(
+        llvm::make_unique<IndexedStreamData>(NameStreamIndex, File), File);
     codeview::StreamReader Reader(NameStream);
 
     NameHashTable NameTable;
     if (auto EC = NameTable.load(Reader))
       return EC;
 
     P.printHex("Signature", NameTable.getSignature());
     P.printNumber("Version", NameTable.getHashVersion());