Resubmit "Refactor PDB into its own library"

[zturner]

Summary

Hi Daniel,

Would you mind testing this patch out on a big endian system before I resubmit?

[dsanders]

Sorry, I missed this patch when you first sent it. Do you still need me to look into this? It looks like this has already been committed and passed the buildbots so it should probably be marked closed.

include/llvm/DebugInfo/PDB/IPDBSession.h

 #define LLVM_DEBUGINFO_PDB_IPDBSESSION_H
 
 #include "PDBTypes.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <memory>
 

include/llvm/DebugInfo/PDB/PDBTypes.h

 
 #include "llvm/Config/llvm-config.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/Support/Endian.h"
 #include <functional>
 #include <cstdint>
 #include <cstring>

 /// of PDB_ReaderType::DIA is supported.
 enum class PDB_ReaderType {
   DIA = 0,
+  Raw = 1,
 };
 
 /// Defines a 128-bit unique identifier.  This maps to a GUID on Windows, but

   }
 };
 
-namespace PDB {
-static const char Magic[] = {'M',  'i',  'c',    'r', 'o', 's',  'o',  'f',
-                             't',  ' ',  'C',    '/', 'C', '+',  '+',  ' ',
-                             'M',  'S',  'F',    ' ', '7', '.',  '0',  '0',
-                             '\r', '\n', '\x1a', 'D', 'S', '\0', '\0', '\0'};
-
-// The superblock is overlaid at the beginning of the file (offset 0).
-// It starts with a magic header and is followed by information which describes
-// the layout of the file system.
-struct SuperBlock {
-  char MagicBytes[sizeof(Magic)];
-  // The file system is split into a variable number of fixed size elements.
-  // These elements are referred to as blocks.  The size of a block may vary
-  // from system to system.
-  support::ulittle32_t BlockSize;
-  // This field's purpose is not yet known.
-  support::ulittle32_t Unknown0;
-  // This contains the number of blocks resident in the file system.  In
-  // practice, NumBlocks * BlockSize is equivalent to the size of the PDB file.
-  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;
-};
-} // end namespace PDB
-
 } // end namespace llvm
 
 namespace std {

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/Support/Endian.h"
+#include "llvm/Support/MathExtras.h"
+
+#include <memory>
+
+namespace llvm {
+class MemoryBuffer;
+
+struct PDBFileContext;
+
+class PDBFile {
+public:
+  explicit PDBFile(std::unique_ptr<MemoryBuffer> MemBuffer);
+  ~PDBFile();
+
+  uint32_t getBlockSize() const;
+  uint32_t getUnknown0() const;
+  uint32_t getBlockCount() const;
+  uint32_t getNumDirectoryBytes() const;
+  uint32_t getBlockMapIndex() const;
+  uint32_t getUnknown1() const;
+  uint32_t getNumDirectoryBlocks() const;
+  uint64_t getBlockMapOffset() const;
+
+  uint32_t getNumStreams() const;
+  uint32_t getStreamByteSize(uint32_t StreamIndex) const;
+  llvm::ArrayRef<uint32_t> getStreamBlockList(uint32_t StreamIndex) const;
+
+  StringRef getBlockData(uint32_t BlockIndex, uint32_t NumBytes) const;
+
+  llvm::ArrayRef<support::ulittle32_t> getDirectoryBlockArray();
+
+  std::error_code parseFileHeaders();
+  std::error_code 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;
+  }
+
+private:
+  std::unique_ptr<PDBFileContext> Context;
+};
+}
+
+#endif

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

+//===- PDBStream.h - Low level interface to a PDB stream --------*- 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_PDBSTREAM_H
+#define LLVM_DEBUGINFO_PDB_RAW_PDBSTREAM_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+class MemoryBufferRef;
+class PDBFile;
+
+class PDBStream {
+public:
+  PDBStream(uint32_t StreamIdx, const PDBFile &File);
+
+  std::error_code readInteger(uint32_t &Dest);
+  std::error_code readZeroString(std::string &Dest);
+  std::error_code readBytes(void *Dest, uint32_t Length);
+
+  void setOffset(uint32_t Off);
+  uint32_t getOffset() const;
+  uint32_t getLength() const;
+
+  template <typename T> std::error_code readObject(T *Dest) {
+    return readBytes(reinterpret_cast<void *>(Dest), sizeof(T));
+  }
+
+private:
+  uint32_t Offset;
+
+  uint32_t StreamLength;
+  std::vector<uint32_t> BlockList;
+  const PDBFile &Pdb;
+};
+}
+
+#endif

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

+//===- RawSession.h - Native implementation of IPDBSession ------*- 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_RAWSESSION_H
+#define LLVM_DEBUGINFO_PDB_RAW_RAWSESSION_H
+
+#include "llvm/DebugInfo/PDB/IPDBSession.h"
+
+namespace llvm {
+class PDBFile;
+class StringRef;
+
+class RawSession : public IPDBSession {
+public:
+  explicit RawSession(std::unique_ptr<PDBFile> PdbFile);
+  ~RawSession() override;
+
+  static PDB_ErrorCode createFromPdb(StringRef Path,
+                                     std::unique_ptr<IPDBSession> &Session);
+  static PDB_ErrorCode createFromExe(StringRef Path,
+                                     std::unique_ptr<IPDBSession> &Session);
+
+  uint64_t getLoadAddress() const override;
+  void setLoadAddress(uint64_t Address) override;
+  std::unique_ptr<PDBSymbolExe> getGlobalScope() const override;
+  std::unique_ptr<PDBSymbol> getSymbolById(uint32_t SymbolId) const override;
+
+  std::unique_ptr<PDBSymbol>
+  findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
+
+  std::unique_ptr<IPDBEnumLineNumbers>
+  findLineNumbers(const PDBSymbolCompiland &Compiland,
+                  const IPDBSourceFile &File) const override;
+  std::unique_ptr<IPDBEnumLineNumbers>
+  findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override;
+
+  std::unique_ptr<IPDBEnumSourceFiles>
+  findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern,
+                  PDB_NameSearchFlags Flags) const override;
+  std::unique_ptr<IPDBSourceFile>
+  findOneSourceFile(const PDBSymbolCompiland *Compiland,
+                    llvm::StringRef Pattern,
+                    PDB_NameSearchFlags Flags) const override;
+  std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
+  findCompilandsForSourceFile(llvm::StringRef Pattern,
+                              PDB_NameSearchFlags Flags) const override;
+  std::unique_ptr<PDBSymbolCompiland>
+  findOneCompilandForSourceFile(llvm::StringRef Pattern,
+                                PDB_NameSearchFlags Flags) const override;
+  std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const override;
+  std::unique_ptr<IPDBEnumSourceFiles> getSourceFilesForCompiland(
+      const PDBSymbolCompiland &Compiland) const override;
+  std::unique_ptr<IPDBSourceFile>
+  getSourceFileById(uint32_t FileId) const override;
+
+  std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const override;
+
+  PDBFile &getPDBFile() { return *Pdb; }
+  const PDBFile &getPDBFile() const { return *Pdb; }
+
+private:
+  std::unique_ptr<PDBFile> Pdb;
+};
+}
+
+#endif

lib/DebugInfo/PDB/CMakeLists.txt

     )
 
     set(LIBPDB_ADDITIONAL_HEADER_DIRS "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/PDB/DIA")
-
 endif()
 
+add_pdb_impl_folder(Raw
+  Raw/PDBFile.cpp
+  Raw/PDBStream.cpp
+  Raw/RawSession.cpp)
+
 list(APPEND LIBPDB_ADDITIONAL_HEADER_DIRS "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/PDB")
 
 add_llvm_library(LLVMDebugInfoPDB

lib/DebugInfo/PDB/PDB.cpp

 #if HAVE_DIA_SDK
 #include "llvm/DebugInfo/PDB/DIA/DIASession.h"
 #endif
+#include "llvm/DebugInfo/PDB/Raw/RawSession.h"
 
 using namespace llvm;
 
 PDB_ErrorCode llvm::loadDataForPDB(PDB_ReaderType Type, StringRef Path,
                                    std::unique_ptr<IPDBSession> &Session) {
   // Create the correct concrete instance type based on the value of Type.
+  if (Type == PDB_ReaderType::Raw)
+    return RawSession::createFromPdb(Path, Session);
+
 #if HAVE_DIA_SDK
   return DIASession::createFromPdb(Path, Session);
-#endif
+#else
   return PDB_ErrorCode::NoDiaSupport;
+#endif
 }
 
 PDB_ErrorCode llvm::loadDataForEXE(PDB_ReaderType Type, StringRef Path,
                                    std::unique_ptr<IPDBSession> &Session) {
   // Create the correct concrete instance type based on the value of Type.
+  if (Type == PDB_ReaderType::Raw)
+    return RawSession::createFromExe(Path, Session);
+
 #if HAVE_DIA_SDK
   return DIASession::createFromExe(Path, Session);
-#endif
+#else
   return PDB_ErrorCode::NoDiaSupport;
+#endif
 }

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/Support/Endian.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+using namespace llvm;
+
+namespace {
+static const char Magic[] = {'M',  'i',  'c',    'r', 'o', 's',  'o',  'f',
+                             't',  ' ',  'C',    '/', 'C', '+',  '+',  ' ',
+                             'M',  'S',  'F',    ' ', '7', '.',  '0',  '0',
+                             '\r', '\n', '\x1a', 'D', 'S', '\0', '\0', '\0'};
+
+// The superblock is overlaid at the beginning of the file (offset 0).
+// It starts with a magic header and is followed by information which describes
+// the layout of the file system.
+struct SuperBlock {
+  char MagicBytes[sizeof(Magic)];
+  // The file system is split into a variable number of fixed size elements.
+  // These elements are referred to as blocks.  The size of a block may vary
+  // from system to system.
+  support::ulittle32_t BlockSize;
+  // This field's purpose is not yet known.
+  support::ulittle32_t Unknown0;
+  // This contains the number of blocks resident in the file system.  In
+  // practice, NumBlocks * BlockSize is equivalent to the size of the PDB file.
+  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;
+};
+}
+
+struct llvm::PDBFileContext {
+  std::unique_ptr<MemoryBuffer> Buffer;
+  const SuperBlock *SB;
+  std::vector<uint32_t> StreamSizes;
+  DenseMap<uint32_t, std::vector<uint32_t>> StreamMap;
+};
+
+static std::error_code 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 std::make_error_code(std::errc::bad_address);
+  }
+  return std::error_code();
+}
+
+template <typename T>
+static std::error_code checkOffset(MemoryBufferRef M, ArrayRef<T> AR) {
+  return checkOffset(M, uintptr_t(AR.data()), (uint64_t)AR.size() * sizeof(T));
+}
+
+PDBFile::PDBFile(std::unique_ptr<MemoryBuffer> MemBuffer) {
+  Context.reset(new PDBFileContext());
+  Context->Buffer = std::move(MemBuffer);
+}
+
+PDBFile::~PDBFile() {}
+
+uint32_t PDBFile::getBlockSize() const { return Context->SB->BlockSize; }
+
+uint32_t PDBFile::getUnknown0() const { return Context->SB->Unknown0; }
+
+uint32_t PDBFile::getBlockCount() const { return Context->SB->NumBlocks; }
+
+uint32_t PDBFile::getNumDirectoryBytes() const {
+  return Context->SB->NumDirectoryBytes;
+}
+
+uint32_t PDBFile::getBlockMapIndex() const { return Context->SB->BlockMapAddr; }
+
+uint32_t PDBFile::getUnknown1() const { return Context->SB->Unknown1; }
+
+uint32_t PDBFile::getNumDirectoryBlocks() const {
+  return bytesToBlocks(Context->SB->NumDirectoryBytes, Context->SB->BlockSize);
+}
+
+uint64_t PDBFile::getBlockMapOffset() const {
+  return (uint64_t)Context->SB->BlockMapAddr * Context->SB->BlockSize;
+}
+
+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>
+PDBFile::getStreamBlockList(uint32_t StreamIndex) const {
+  auto &Data = Context->StreamMap[StreamIndex];
+  return llvm::ArrayRef<uint32_t>(Data);
+}
+
+StringRef PDBFile::getBlockData(uint32_t BlockIndex, uint32_t NumBytes) const {
+  uint64_t StreamBlockOffset = blockToOffset(BlockIndex, getBlockSize());
+
+  return StringRef(Context->Buffer->getBufferStart() + StreamBlockOffset,
+                   NumBytes);
+}
+
+std::error_code PDBFile::parseFileHeaders() {
+  std::error_code EC;
+  MemoryBufferRef BufferRef = *Context->Buffer;
+
+  Context->SB =
+      reinterpret_cast<const SuperBlock *>(BufferRef.getBufferStart());
+  const SuperBlock *SB = Context->SB;
+  // Check the magic bytes.
+  if (memcmp(SB->MagicBytes, Magic, sizeof(Magic)) != 0)
+    return std::make_error_code(std::errc::illegal_byte_sequence);
+
+  // We don't support blocksizes which aren't a multiple of four bytes.
+  if (SB->BlockSize % sizeof(support::ulittle32_t) != 0)
+    return std::make_error_code(std::errc::not_supported);
+
+  // We don't support directories whose sizes aren't a multiple of four bytes.
+  if (SB->NumDirectoryBytes % sizeof(support::ulittle32_t) != 0)
+    return std::make_error_code(std::errc::not_supported);
+
+  // The number of blocks which comprise the directory is a simple function of
+  // the number of bytes it contains.
+  uint64_t NumDirectoryBlocks = getNumDirectoryBlocks();
+
+  // The block map, as we understand it, is a block which consists of a list of
+  // block numbers.
+  // It is unclear what would happen if the number of blocks couldn't fit on a
+  // single block.
+  if (NumDirectoryBlocks > SB->BlockSize / sizeof(support::ulittle32_t))
+    return std::make_error_code(std::errc::illegal_byte_sequence);
+
+  return std::error_code();
+}
+
+std::error_code PDBFile::parseStreamData() {
+  assert(Context && Context->SB);
+
+  bool SeenNumStreams = false;
+  uint32_t NumStreams = 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;
+
+    // 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 std::make_error_code(std::errc::illegal_byte_sequence);
+
+      StreamBlocks->push_back(Data);
+    }
+  }
+
+  // We should have read exactly SB->NumDirectoryBytes bytes.
+  assert(DirectoryBytesRead == SB->NumDirectoryBytes);
+  return std::error_code();
+}
+
+llvm::ArrayRef<support::ulittle32_t> PDBFile::getDirectoryBlockArray() {
+  return makeArrayRef(
+      reinterpret_cast<const support::ulittle32_t *>(
+          Context->Buffer->getBufferStart() + getBlockMapOffset()),
+      getNumDirectoryBlocks());
+}

lib/DebugInfo/PDB/Raw/PDBStream.cpp

+//===- PDBStream.cpp - Low level interface to a PDB stream ------*- 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/PDBStream.h"
+#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
+
+using namespace llvm;
+
+PDBStream::PDBStream(uint32_t StreamIdx, const PDBFile &File) : Pdb(File) {
+  this->StreamLength = Pdb.getStreamByteSize(StreamIdx);
+  this->BlockList = Pdb.getStreamBlockList(StreamIdx);
+  this->Offset = 0;
+}
+
+std::error_code PDBStream::readInteger(uint32_t &Dest) {
+  support::ulittle32_t P;
+  if (std::error_code EC = readObject(&P))
+    return EC;
+  Dest = P;
+  return std::error_code();
+}
+
+std::error_code PDBStream::readZeroString(std::string &Dest) {
+  char C;
+  do {
+    readObject(&C);
+    if (C != '\0')
+      Dest.push_back(C);
+  } while (C != '\0');
+  return std::error_code();
+}
+
+std::error_code PDBStream::readBytes(void *Dest, uint32_t Length) {
+  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 (this->Offset + Length > this->StreamLength)
+    return std::make_error_code(std::errc::bad_address);
+
+  // Modify the passed in offset to point to the data after the object.
+  Offset += Length;
+
+  // Handle the contiguous case: the offset + size stays within a block.
+  if (OffsetInBlock + Length <= Pdb.getBlockSize()) {
+    uint32_t StreamBlockAddr = this->BlockList[BlockNum];
+
+    StringRef Data = Pdb.getBlockData(StreamBlockAddr, Pdb.getBlockSize());
+    ::memcpy(Dest, Data.data() + OffsetInBlock, Length);
+    return std::error_code();
+  }
+
+  // The non-contiguous case: we will stitch together non-contiguous chunks
+  uint32_t BytesLeft = Length;
+  uint32_t BytesWritten = 0;
+  char *WriteBuffer = static_cast<char *>(Dest);
+  while (BytesLeft > 0) {
+    uint32_t StreamBlockAddr = this->BlockList[BlockNum];
+    uint64_t StreamBlockOffset =
+        PDBFile::blockToOffset(StreamBlockAddr, Pdb.getBlockSize()) +
+        OffsetInBlock;
+
+    StringRef Data = Pdb.getBlockData(StreamBlockAddr, Pdb.getBlockSize());
+
+    const char *ChunkStart = Data.data() + StreamBlockOffset;
+    uint32_t BytesInChunk =
+        std::min(BytesLeft, Pdb.getBlockSize() - OffsetInBlock);
+    ::memcpy(WriteBuffer + BytesWritten, ChunkStart, BytesInChunk);
+
+    BytesWritten += BytesInChunk;
+    BytesLeft -= BytesInChunk;
+    ++BlockNum;
+    OffsetInBlock = 0;
+  }
+  return std::error_code();
+}
+
+void PDBStream::setOffset(uint32_t O) { this->Offset = O; }
+
+uint32_t PDBStream::getOffset() const { return this->Offset; }
+
+uint32_t PDBStream::getLength() const { return this->StreamLength; }

lib/DebugInfo/PDB/Raw/RawSession.cpp

+//===- RawSession.cpp - Raw implementation of IPDBSession -------*- 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/RawSession.h"
+#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
+#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
+
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+using namespace llvm;
+
+RawSession::RawSession(std::unique_ptr<PDBFile> PdbFile)
+    : Pdb(std::move(PdbFile)) {}
+
+RawSession::~RawSession() {}
+
+PDB_ErrorCode RawSession::createFromPdb(StringRef Path,
+                                        std::unique_ptr<IPDBSession> &Session) {
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
+      MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
+                                   /*RequiresNullTerminator=*/false);
+
+  std::error_code EC;
+  if ((EC = ErrorOrBuffer.getError()))
+    return PDB_ErrorCode::CouldNotCreateImpl;
+
+  std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
+
+  std::unique_ptr<PDBFile> File(new PDBFile(std::move(Buffer)));
+  if ((EC = File->parseFileHeaders()))
+    return PDB_ErrorCode::InvalidFileFormat;
+  if ((EC = File->parseStreamData()))
+    return PDB_ErrorCode::InvalidFileFormat;
+
+  Session.reset(new RawSession(std::move(File)));
+
+  return PDB_ErrorCode::Success;
+}
+
+PDB_ErrorCode RawSession::createFromExe(StringRef Path,
+                                        std::unique_ptr<IPDBSession> &Session) {
+  return PDB_ErrorCode::CouldNotCreateImpl;
+}
+
+uint64_t RawSession::getLoadAddress() const { return 0; }
+
+void RawSession::setLoadAddress(uint64_t Address) {}
+
+std::unique_ptr<PDBSymbolExe> RawSession::getGlobalScope() const {
+  return nullptr;
+}
+
+std::unique_ptr<PDBSymbol> RawSession::getSymbolById(uint32_t SymbolId) const {
+  return nullptr;
+}
+
+std::unique_ptr<PDBSymbol>
+RawSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumLineNumbers>
+RawSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
+                            const IPDBSourceFile &File) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumLineNumbers>
+RawSession::findLineNumbersByAddress(uint64_t Address, uint32_t Length) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumSourceFiles>
+RawSession::findSourceFiles(const PDBSymbolCompiland *Compiland,
+                            llvm::StringRef Pattern,
+                            PDB_NameSearchFlags Flags) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBSourceFile>
+RawSession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
+                              llvm::StringRef Pattern,
+                              PDB_NameSearchFlags Flags) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
+RawSession::findCompilandsForSourceFile(llvm::StringRef Pattern,
+                                        PDB_NameSearchFlags Flags) const {
+  return nullptr;
+}
+
+std::unique_ptr<PDBSymbolCompiland>
+RawSession::findOneCompilandForSourceFile(llvm::StringRef Pattern,
+                                          PDB_NameSearchFlags Flags) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumSourceFiles> RawSession::getAllSourceFiles() const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumSourceFiles> RawSession::getSourceFilesForCompiland(
+    const PDBSymbolCompiland &Compiland) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBSourceFile>
+RawSession::getSourceFileById(uint32_t FileId) const {
+  return nullptr;
+}
+
+std::unique_ptr<IPDBEnumDataStreams> RawSession::getDebugStreams() const {
+  return nullptr;
+}

test/DebugInfo/PDB/pdbdump-headers.test

 ; CHECK-NEXT: Version: 20000404
 ; CHECK-NEXT: Signature: 54e507e2
 ; CHECK-NEXT: Age: 1
-; CHECK-NEXT: Guid: b 35 56 41 86 a0 a2 49 89 6f 99 88 fa e5 2f f0
+; CHECK-NEXT: Guid: {0B355641-86A0-A249-896F-9988FAE52FF0}
 ; CHECK-NEXT: NumberOfBytes: 34
 ; CHECK-NEXT: HashSize: 3
 ; CHECK-NEXT: MaxNumberOfStrings: 6

tools/llvm-pdbdump/BuiltinDumper.h

 #ifndef LLVM_TOOLS_LLVMPDBDUMP_BUILTINDUMPER_H
 #define LLVM_TOOLS_LLVMPDBDUMP_BUILTINDUMPER_H
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/PDB/PDBSymDumper.h"
 
 namespace llvm {

tools/llvm-pdbdump/llvm-pdbdump.cpp

 #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/PDBStream.h"
+#include "llvm/DebugInfo/PDB/Raw/RawSession.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/raw_ostream.h"
 
 #if defined(HAVE_DIA_SDK)
 #ifndef NOMINMAX

   reportError(Input, EC.message());
 }
 
-static std::error_code 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 std::make_error_code(std::errc::bad_address);
-  }
-  return std::error_code();
-}
-
-template <typename T>
-static std::error_code checkOffset(MemoryBufferRef M, ArrayRef<T> AR) {
-  return checkOffset(M, uintptr_t(AR.data()), (uint64_t)AR.size() * sizeof(T));
-}
-
-static std::error_code checkOffset(MemoryBufferRef M, StringRef SR) {
-  return checkOffset(M, uintptr_t(SR.data()), SR.size());
-}
-
-// Sets Obj unless any bytes in [addr, addr + size) fall outsize of m.
-// Returns unexpected_eof if error.
-template <typename T>
-static std::error_code getObject(const T *&Obj, MemoryBufferRef M,
-                                 const void *Ptr,
-                                 const uint64_t Size = sizeof(T)) {
-  uintptr_t Addr = uintptr_t(Ptr);
-  if (std::error_code EC = checkOffset(M, Addr, Size))
-    return EC;
-  Obj = reinterpret_cast<const T *>(Addr);
-  return std::error_code();
-}
-
-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;
-}
-
-struct PDBStructureContext {
-  const PDB::SuperBlock *SB;
-  MemoryBufferRef M;
-  std::vector<uint32_t> StreamSizes;
-  DenseMap<uint32_t, std::vector<uint32_t>> StreamMap;
-
-  SmallVector<char, 512> Scratch;
-
-  // getObject tries to stitch together non-contiguous blocks into a contiguous
-  // value.  The storage for the value comes from the memory mapped file if the
-  // memory would be contiguous.  Otherwise, it uses 'Scratch' to buffer the
-  // data.
-  template <typename T>
-  void getObject(const T *&Obj, uint32_t StreamIdx, uint32_t &Offset) {
-    // Make sure the stream index is valid.
-    auto StreamBlockI = StreamMap.find(StreamIdx);
-    if (StreamBlockI == StreamMap.end())
-      reportError(M.getBufferIdentifier(),
-                  std::make_error_code(std::errc::bad_address));
-
-    auto &StreamBlocks = StreamBlockI->second;
-    uint32_t BlockNum = Offset / SB->BlockSize;
-    uint32_t OffsetInBlock = Offset % SB->BlockSize;
-
-    // Make sure we aren't trying to read beyond the end of the stream.
-    if (Offset + sizeof(T) > StreamSizes[StreamIdx])
-      reportError(M.getBufferIdentifier(),
-                  std::make_error_code(std::errc::bad_address));
-
-    // Modify the passed in offset to point to the data after the object.
-    Offset += sizeof(T);
-
-    // Handle the contiguous case: the offset + size stays within a block.
-    if (OffsetInBlock + sizeof(T) <= SB->BlockSize) {
-      uint32_t StreamBlockAddr = StreamBlocks[BlockNum];
-      uint64_t StreamBlockOffset =
-          blockToOffset(StreamBlockAddr, SB->BlockSize) + OffsetInBlock;
-      // Return a pointer to the memory buffer.
-      Obj = reinterpret_cast<const T *>(M.getBufferStart() + StreamBlockOffset);
-      return;
-    }
-
-    // The non-contiguous case: we will stitch together non-contiguous chunks
-    // into the scratch buffer.
-    Scratch.clear();
-
-    uint32_t BytesLeft = sizeof(T);
-    while (BytesLeft > 0) {
-      uint32_t StreamBlockAddr = StreamBlocks[BlockNum];
-      uint64_t StreamBlockOffset =
-          blockToOffset(StreamBlockAddr, SB->BlockSize) + OffsetInBlock;
-
-      const char *ChunkStart =
-          M.getBufferStart() + StreamBlockOffset;
-      uint32_t BytesInChunk =
-          std::min(BytesLeft, SB->BlockSize - OffsetInBlock);
-      Scratch.append(ChunkStart, ChunkStart + BytesInChunk);
-
-      BytesLeft -= BytesInChunk;
-      ++BlockNum;
-      OffsetInBlock = 0;
-    }
-
-    // Return a pointer to the scratch buffer.
-    Obj = reinterpret_cast<const T *>(Scratch.data());
-  }
-
-  template <typename T>
-  T getInt(uint32_t StreamIdx, uint32_t &Offset) {
-    const support::detail::packed_endian_specific_integral<
-        T, support::little, support::unaligned> *P;
-    getObject(P, StreamIdx, Offset);
-    return *P;
-  }
-
-  template <typename T>
-  T getObject(uint32_t StreamIdx, uint32_t &Offset) {
-    const T *P;
-    getObject(P, StreamIdx, Offset);
-    return *P;
-  }
-};
-
-static void dumpStructure(MemoryBufferRef M) {
-  const PDB::SuperBlock *SB;
-
-  auto Error = [&](std::error_code EC) {
-    if (EC)
-      reportError(M.getBufferIdentifier(), EC);
-  };
-
-  Error(getObject(SB, M, M.getBufferStart()));
+static void dumpStructure(RawSession &RS) {
+  PDBFile &File = RS.getPDBFile();
 
   if (opts::DumpHeaders) {
-    outs() << "BlockSize: " << SB->BlockSize << '\n';
-    outs() << "Unknown0: " << SB->Unknown0 << '\n';
-    outs() << "NumBlocks: " << SB->NumBlocks << '\n';
-    outs() << "NumDirectoryBytes: " << SB->NumDirectoryBytes << '\n';
-    outs() << "Unknown1: " << SB->Unknown1 << '\n';
-    outs() << "BlockMapAddr: " << SB->BlockMapAddr << '\n';
+    outs() << "BlockSize: " << File.getBlockSize() << '\n';
+    outs() << "Unknown0: " << File.getUnknown0() << '\n';
+    outs() << "NumBlocks: " << File.getBlockCount() << '\n';
+    outs() << "NumDirectoryBytes: " << File.getNumDirectoryBytes() << '\n';
+    outs() << "Unknown1: " << File.getUnknown1() << '\n';
+    outs() << "BlockMapAddr: " << File.getBlockMapIndex() << '\n';
   }
 
-  // We don't support blocksizes which aren't a multiple of four bytes.
-  if (SB->BlockSize % sizeof(support::ulittle32_t) != 0)
-    Error(std::make_error_code(std::errc::not_supported));
-
-  // We don't support directories whose sizes aren't a multiple of four bytes.
-  if (SB->NumDirectoryBytes % sizeof(support::ulittle32_t) != 0)
-    Error(std::make_error_code(std::errc::not_supported));
-
-  // The number of blocks which comprise the directory is a simple function of
-  // the number of bytes it contains.
-  uint64_t NumDirectoryBlocks =
-      bytesToBlocks(SB->NumDirectoryBytes, SB->BlockSize);
   if (opts::DumpHeaders)
-    outs() << "NumDirectoryBlocks: " << NumDirectoryBlocks << '\n';
-
-  // The block map, as we understand it, is a block which consists of a list of
-  // block numbers.
-  // It is unclear what would happen if the number of blocks couldn't fit on a
-  // single block.
-  if (NumDirectoryBlocks > SB->BlockSize / sizeof(support::ulittle32_t))
-    Error(std::make_error_code(std::errc::illegal_byte_sequence));
+    outs() << "NumDirectoryBlocks: " << File.getNumDirectoryBlocks() << '\n';
 
-  uint64_t BlockMapOffset = (uint64_t)SB->BlockMapAddr * SB->BlockSize;
   if (opts::DumpHeaders)
-    outs() << "BlockMapOffset: " << BlockMapOffset << '\n';
+    outs() << "BlockMapOffset: " << File.getBlockMapOffset() << '\n';
 
   // The directory is not contiguous.  Instead, the block map contains a
   // contiguous list of block numbers whose contents, when concatenated in
   // order, make up the directory.
-  auto DirectoryBlocks =
-      makeArrayRef(reinterpret_cast<const support::ulittle32_t *>(
-                       M.getBufferStart() + BlockMapOffset),
-                   NumDirectoryBlocks);
-  Error(checkOffset(M, DirectoryBlocks));
+  auto DirectoryBlocks = File.getDirectoryBlockArray();
 
   if (opts::DumpHeaders) {
     outs() << "DirectoryBlocks: [";
-    for (const support::ulittle32_t &DirectoryBlockAddr : DirectoryBlocks) {
+    for (const auto &DirectoryBlockAddr : DirectoryBlocks) {
       if (&DirectoryBlockAddr != &DirectoryBlocks.front())
         outs() << ", ";
       outs() << DirectoryBlockAddr;

     outs() << "]\n";
   }
 
-  bool SeenNumStreams = false;
-  uint32_t NumStreams = 0;
-  uint32_t StreamIdx = 0;
-  uint64_t DirectoryBytesRead = 0;
-  PDBStructureContext Ctx;
-  Ctx.SB = SB;
-  Ctx.M = M;
-  // 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));
-    Error(checkOffset(M, DirectoryBlock));
-
-    // 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 (Ctx.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)
-          Ctx.StreamSizes.push_back(0);
-        else
-          Ctx.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(Ctx.StreamSizes[StreamIdx], SB->BlockSize);
-        StreamBlocks = &Ctx.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)
-        Error(std::make_error_code(std::errc::illegal_byte_sequence));
-
-      StreamBlocks->push_back(Data);
-    }
-  }
-
-  // We should have read exactly SB->NumDirectoryBytes bytes.
-  assert(DirectoryBytesRead == SB->NumDirectoryBytes);
-
   if (opts::DumpHeaders)
-    outs() << "NumStreams: " << NumStreams << '\n';
-  if (opts::DumpStreamSizes)
-    for (uint32_t StreamIdx = 0; StreamIdx < NumStreams; ++StreamIdx)
+    outs() << "NumStreams: " << File.getNumStreams() << '\n';
+  uint32_t StreamCount = File.getNumStreams();
+  if (opts::DumpStreamSizes) {
+    for (uint32_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx)
       outs() << "StreamSizes[" << StreamIdx
-             << "]: " << Ctx.StreamSizes[StreamIdx] << '\n';
+             << "]: " << File.getStreamByteSize(StreamIdx) << '\n';
+  }
 
   if (opts::DumpStreamBlocks) {
-    for (uint32_t StreamIdx = 0; StreamIdx < NumStreams; ++StreamIdx) {
+    for (uint32_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
       outs() << "StreamBlocks[" << StreamIdx << "]: [";
-      std::vector<uint32_t> &StreamBlocks = Ctx.StreamMap[StreamIdx];
-      for (uint32_t &StreamBlock : StreamBlocks) {
-        if (&StreamBlock != &StreamBlocks.front())
+      auto StreamBlocks = File.getStreamBlockList(StreamIdx);
+      for (size_t i = 0; i < StreamBlocks.size(); ++i) {
+        if (i != 0)
           outs() << ", ";
-        outs() << StreamBlock;
+        outs() << StreamBlocks[i];
       }
       outs() << "]\n";
     }

   StringRef DumpStreamStr = opts::DumpStreamData;
   uint32_t DumpStreamNum;
   if (!DumpStreamStr.getAsInteger(/*Radix=*/0U, DumpStreamNum) &&
-      DumpStreamNum < NumStreams) {
+      DumpStreamNum < StreamCount) {
     uint32_t StreamBytesRead = 0;
-    uint32_t StreamSize = Ctx.StreamSizes[DumpStreamNum];
-    std::vector<uint32_t> &StreamBlocks = Ctx.StreamMap[DumpStreamNum];
-    for (uint32_t &StreamBlockAddr : StreamBlocks) {
-      uint64_t StreamBlockOffset = blockToOffset(StreamBlockAddr, SB->BlockSize);
+    uint32_t StreamSize = File.getStreamByteSize(DumpStreamNum);
+    auto StreamBlocks = File.getStreamBlockList(DumpStreamNum);
+
+    for (uint32_t StreamBlockAddr : StreamBlocks) {
       uint32_t BytesLeftToReadInStream = StreamSize - StreamBytesRead;
       if (BytesLeftToReadInStream == 0)
         break;
 
       uint32_t BytesToReadInBlock = std::min(
-          BytesLeftToReadInStream, static_cast<uint32_t>(SB->BlockSize));
+          BytesLeftToReadInStream, static_cast<uint32_t>(File.getBlockSize()));
       auto StreamBlockData =
-          StringRef(M.getBufferStart() + StreamBlockOffset, BytesToReadInBlock);
-      Error(checkOffset(M, StreamBlockData));
+          File.getBlockData(StreamBlockAddr, BytesToReadInBlock);
 
       outs() << StreamBlockData;
       StreamBytesRead += StreamBlockData.size();
     }
   }
 
-  uint32_t Offset = 0;
-
   // Stream 1 starts with the following header:
   //   uint32_t Version;
   //   uint32_t Signature;
   //   uint32_t Age;
   //   GUID Guid;
-  auto Version = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
-  outs() << "Version: " << Version << '\n';
+  PDBStream Stream1(1, File);
+  uint32_t Version;
+  uint32_t Signature;
+  uint32_t Age;
+  PDB_UniqueId Guid;
 
+  Stream1.readInteger(Version);
+  outs() << "Version: " << Version << '\n';
   // PDB's with versions before PDBImpvVC70 might not have the Guid field, we
   // don't support them.
   if (Version < 20000404)
-    Error(std::make_error_code(std::errc::not_supported));
+    reportError("", std::make_error_code(std::errc::not_supported));
 
   // This appears to be the time the PDB was last opened by an MSVC tool?
   // It is definitely a timestamp of some sort.
-  auto Signature = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  Stream1.readInteger(Signature);
   outs() << "Signature: ";
   outs().write_hex(Signature) << '\n';
 
   // This appears to be a number which is used to determine that the PDB is kept
   // in sync with the EXE.
-  auto Age = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  Stream1.readInteger(Age);
   outs() << "Age: " << Age << '\n';
 
   // I'm not sure what the purpose of the GUID is.
-  using GuidTy = char[16];
-  const GuidTy *Guid;
-  Ctx.getObject(Guid, /*PDBStream=*/1, Offset);
-  outs() << "Guid: ";
-  for (char C : *Guid)
-    outs().write_hex(C & 0xff) << ' ';
-  outs() << '\n';
+  Stream1.readObject(&Guid);
+  outs() << "Guid: " << Guid << '\n';
 
   // This is some sort of weird string-set/hash table encoded in the stream.
   // It starts with the number of bytes in the table.
-  auto NumberOfBytes = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  uint32_t NumberOfBytes;
+  Stream1.readInteger(NumberOfBytes);
   outs() << "NumberOfBytes: " << NumberOfBytes << '\n';
 
   // Following that field is the starting offset of strings in the name table.
-  uint32_t StringsOffset = Offset;
-  Offset += NumberOfBytes;
+  uint32_t StringsOffset = Stream1.getOffset();
+  Stream1.setOffset(StringsOffset + NumberOfBytes);
 
   // This appears to be equivalent to the total number of strings *actually*
   // in the name table.
-  auto HashSize = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  uint32_t HashSize;
+  Stream1.readInteger(HashSize);
   outs() << "HashSize: " << HashSize << '\n';
 
   // This appears to be an upper bound on the number of strings in the name
   // table.
-  auto MaxNumberOfStrings = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  uint32_t MaxNumberOfStrings;
+  Stream1.readInteger(MaxNumberOfStrings);
   outs() << "MaxNumberOfStrings: " << MaxNumberOfStrings << '\n';
 
   // This appears to be a hash table which uses bitfields to determine whether
   // or not a bucket is 'present'.
-  auto NumPresentWords = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  uint32_t NumPresentWords;
+  Stream1.readInteger(NumPresentWords);
   outs() << "NumPresentWords: " << NumPresentWords << '\n';
 
   // Store all the 'present' bits in a vector for later processing.
   SmallVector<uint32_t, 1> PresentWords;
   for (uint32_t I = 0; I != NumPresentWords; ++I) {
-    auto Word = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+    uint32_t Word;
+    Stream1.readInteger(Word);
     PresentWords.push_back(Word);
     outs() << "Word: " << Word << '\n';
   }
 
   // This appears to be a hash table which uses bitfields to determine whether
   // or not a bucket is 'deleted'.
-  auto NumDeletedWords = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+  uint32_t NumDeletedWords;
+  Stream1.readInteger(NumDeletedWords);
   outs() << "NumDeletedWords: " << NumDeletedWords << '\n';
 
   // Store all the 'deleted' bits in a vector for later processing.
   SmallVector<uint32_t, 1> DeletedWords;
   for (uint32_t I = 0; I != NumDeletedWords; ++I) {
-    auto Word = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+    uint32_t Word;
+    Stream1.readInteger(Word);
     DeletedWords.push_back(Word);
     outs() << "Word: " << Word << '\n';
   }

 
     // This appears to be an offset relative to the start of the strings.
     // It tells us where the null-terminated string begins.
-    auto NameOffset = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+    uint32_t NameOffset;
+    Stream1.readInteger(NameOffset);
     outs() << "NameOffset: " << NameOffset << '\n';
 
     // This appears to be a stream number into the stream directory.
-    auto NameIndex = Ctx.getInt<uint32_t>(/*PDBStream=*/1, Offset);
+    uint32_t NameIndex;
+    Stream1.readInteger(NameIndex);
     outs() << "NameIndex: " << NameIndex << '\n';
 
     // Compute the offset of the start of the string relative to the stream.
     uint32_t StringOffset = StringsOffset + NameOffset;
-
+    uint32_t OldOffset = Stream1.getOffset();
     // Pump out our c-string from the stream.
-    SmallString<8> Str;
-    char C;
-    do {
-      C = Ctx.getObject<char>(/*PDBStream=*/1, StringOffset);
-      if (C != '\0')
-        Str += C;
-    } while (C != '\0');
+    std::string Str;
+    Stream1.setOffset(StringOffset);
+    Stream1.readZeroString(Str);
     outs() << "String: " << Str << "\n\n";
 
+    Stream1.setOffset(OldOffset);
     // Add this to a string-map from name to stream number.
     NamedStreams.insert({Str, NameIndex});
   }

   // Let's try to dump out the named stream "/names".
   auto NameI = NamedStreams.find("/names");
   if (NameI != NamedStreams.end()) {
-    uint32_t NameStream = NameI->second;
-    outs() << "NameStream: " << NameStream << '\n';
-
-    uint32_t NameStreamOffset = 0;
+    PDBStream NameStream(NameI->second, File);
+    outs() << "NameStream: " << NameI->second << '\n';
 
     // The name stream appears to start with a signature and version.
-    auto NameStreamSignature =
-        Ctx.getInt<uint32_t>(/*PDBStream=*/NameStream, NameStreamOffset);
+    uint32_t NameStreamSignature;
+    NameStream.readInteger(NameStreamSignature);
     outs() << "NameStreamSignature: ";
     outs().write_hex(NameStreamSignature) << '\n';
 
-    auto NameStreamVersion =
-        Ctx.getInt<uint32_t>(/*PDBStream=*/NameStream, NameStreamOffset);
+    uint32_t NameStreamVersion;
+    NameStream.readInteger(NameStreamVersion);
     outs() << "NameStreamVersion: " << NameStreamVersion << '\n';
 
     // We only support this particular version of the name stream.
     if (NameStreamSignature != 0xeffeeffe || NameStreamVersion != 1)
-      Error(std::make_error_code(std::errc::not_supported));
+      reportError("", std::make_error_code(std::errc::not_supported));
   }
 }
 
 static void dumpInput(StringRef Path) {
+  std::unique_ptr<IPDBSession> Session;
   if (opts::DumpHeaders || !opts::DumpStreamData.empty()) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
-        MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
-                                     /*RequiresNullTerminator=*/false);
-
-    if (std::error_code EC = ErrorOrBuffer.getError())
-      reportError(Path, EC);
-
-    std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
-
-    dumpStructure(Buffer->getMemBufferRef());
+    PDB_ErrorCode Error = loadDataForPDB(PDB_ReaderType::Raw, Path, Session);
+    if (Error == PDB_ErrorCode::Success) {
+      RawSession *RS = static_cast<RawSession *>(Session.get());
+      dumpStructure(*RS);
+    }
 
     outs().flush();
     return;
   }
 
-  std::unique_ptr<IPDBSession> Session;
   PDB_ErrorCode Error = loadDataForPDB(PDB_ReaderType::DIA, Path, Session);
   switch (Error) {
   case PDB_ErrorCode::Success: