[llvm] r267049 - Refactor raw pdb dumper into library

Zachary Turner via llvm-commits llvm-commits at lists.llvm.org
Thu Apr 21 19:30:55 PDT 2016


Sorry I can't fix this until tomorrow. If you can rename one of them that
would be great, otherwise you can revert if you need to (it's a few CLs)
On Thu, Apr 21, 2016 at 7:16 PM Richard Smith <richard at metafoo.co.uk> wrote:

> This is still breaking the modules buildbot:
>
>
> http://lab.llvm.org:8011/builders/clang-x86_64-linux-selfhost-modules/builds/14806/steps/compile.llvm.stage2/logs/stdio
>
> Looks like an ODR violation: there seem to now be two different classes
> called llvm::PDBContext.
>
> On Thu, Apr 21, 2016 at 5:03 PM, Zachary Turner via llvm-commits <
> llvm-commits at lists.llvm.org> wrote:
>
>> That one is probably someone else's. Sorry can't help with that :(
>>
>> Sorry again for breaking it in the first place
>>
>> On Thu, Apr 21, 2016 at 5:01 PM Mike Aizatsky <aizatsky at google.com>
>> wrote:
>>
>>> This particular one passes at
>>> https://llvm.org/svn/llvm-project/llvm/trunk@267080
>>> Thanks.
>>>
>>> CodeGen/ARM/Windows/division.ll fails though. Arghhhh!
>>>
>>> On Thu, Apr 21, 2016 at 4:58 PM Zachary Turner <zturner at google.com>
>>> wrote:
>>>
>>>> A fix for this should already be in. Can you sync and verify?
>>>> On Thu, Apr 21, 2016 at 4:56 PM Mike Aizatsky <aizatsky at google.com>
>>>> wrote:
>>>>
>>>>> The pdb test fails on several bots and on my computer:
>>>>>
>>>>>     LLVM :: DebugInfo/PDB/pdbdump-headers.test
>>>>>
>>>>> How about full rollback?
>>>>>
>>>>> On Thu, Apr 21, 2016 at 3:22 PM Zachary Turner via llvm-commits <
>>>>> llvm-commits at lists.llvm.org> wrote:
>>>>>
>>>>>> Fixed in r267068.
>>>>>>
>>>>>> On Thu, Apr 21, 2016 at 3:17 PM David Blaikie <dblaikie at gmail.com>
>>>>>> wrote:
>>>>>>
>>>>>>> On Thu, Apr 21, 2016 at 1:58 PM, Zachary Turner via llvm-commits <
>>>>>>> llvm-commits at lists.llvm.org> wrote:
>>>>>>>
>>>>>>>> Author: zturner
>>>>>>>> Date: Thu Apr 21 15:58:35 2016
>>>>>>>> New Revision: 267049
>>>>>>>>
>>>>>>>> URL: http://llvm.org/viewvc/llvm-project?rev=267049&view=rev
>>>>>>>> Log:
>>>>>>>> Refactor raw pdb dumper into library
>>>>>>>>
>>>>>>>> PDB parsing code was hand-rolled into llvm-pdbdump. This patch
>>>>>>>> moves the
>>>>>>>> parsing of this code into DebugInfoPDB and makes the dumper use
>>>>>>>> this.
>>>>>>>>
>>>>>>>> This is achieved by implementing the skeleton of RawPdbSession, the
>>>>>>>> non-DIA counterpart to the existing PDB read interface. None of the
>>>>>>>> type /
>>>>>>>> source file / etc information is accessible yet, so this
>>>>>>>> implementation is
>>>>>>>> not yet close to achieving parity with the DIA counterpart, but the
>>>>>>>> RawSession class simply holds a reference to a PDBFile class which
>>>>>>>> handles
>>>>>>>> parsing the file format. Additionally a PDBStream class is
>>>>>>>> introduced
>>>>>>>> which allows accessing the bytes of a particular stream in a PDB
>>>>>>>> file.
>>>>>>>>
>>>>>>>> Differential Revision: http://reviews.llvm.org/D19343
>>>>>>>> Reviewed By: majnemer
>>>>>>>>
>>>>>>>> Added:
>>>>>>>>     llvm/trunk/include/llvm/DebugInfo/PDB/Raw/
>>>>>>>>     llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h
>>>>>>>>     llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBStream.h
>>>>>>>>     llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawSession.h
>>>>>>>>     llvm/trunk/lib/DebugInfo/PDB/Raw/
>>>>>>>>     llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp
>>>>>>>>     llvm/trunk/lib/DebugInfo/PDB/Raw/PDBStream.cpp
>>>>>>>>     llvm/trunk/lib/DebugInfo/PDB/Raw/RawSession.cpp
>>>>>>>> Modified:
>>>>>>>>     llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h
>>>>>>>>     llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h
>>>>>>>>     llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt
>>>>>>>>     llvm/trunk/lib/DebugInfo/PDB/PDB.cpp
>>>>>>>>     llvm/trunk/tools/llvm-pdbdump/BuiltinDumper.h
>>>>>>>>     llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp
>>>>>>>>
>>>>>>>> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h?rev=267049&r1=267048&r2=267049&view=diff
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h (original)
>>>>>>>> +++ llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -11,6 +11,7 @@
>>>>>>>>  #define LLVM_DEBUGINFO_PDB_IPDBSESSION_H
>>>>>>>>
>>>>>>>>  #include "PDBTypes.h"
>>>>>>>> +#include "llvm/ADT/StringRef.h"
>>>>>>>>  #include "llvm/Support/Casting.h"
>>>>>>>>  #include <memory>
>>>>>>>>
>>>>>>>>
>>>>>>>> Modified: llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h?rev=267049&r1=267048&r2=267049&view=diff
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h (original)
>>>>>>>> +++ llvm/trunk/include/llvm/DebugInfo/PDB/PDBTypes.h Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -12,7 +12,6 @@
>>>>>>>>
>>>>>>>>  #include "llvm/Config/llvm-config.h"
>>>>>>>>  #include "llvm/DebugInfo/CodeView/CodeView.h"
>>>>>>>> -#include "llvm/Support/Endian.h"
>>>>>>>>  #include <functional>
>>>>>>>>  #include <cstdint>
>>>>>>>>  #include <cstring>
>>>>>>>> @@ -70,6 +69,7 @@ class PDBSymbolUnknown;
>>>>>>>>  /// 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
>>>>>>>> @@ -429,35 +429,6 @@ struct Variant {
>>>>>>>>    }
>>>>>>>>  };
>>>>>>>>
>>>>>>>> -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 {
>>>>>>>>
>>>>>>>> Added: llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h?rev=267049&view=auto
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h (added)
>>>>>>>> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBFile.h Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -0,0 +1,53 @@
>>>>>>>> +//===- 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 <memory>
>>>>>>>> +
>>>>>>>> +namespace llvm {
>>>>>>>> +class MemoryBuffer;
>>>>>>>> +
>>>>>>>> +struct PDBContext;
>>>>>>>> +
>>>>>>>> +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<uint32_t> getDirectoryBlockArray();
>>>>>>>> +
>>>>>>>> +  std::error_code parseFileHeaders();
>>>>>>>> +  std::error_code parseStreamData();
>>>>>>>> +
>>>>>>>> +private:
>>>>>>>> +  std::unique_ptr<PDBContext> Context;
>>>>>>>> +};
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +#endif
>>>>>>>>
>>>>>>>> Added: llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBStream.h
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBStream.h?rev=267049&view=auto
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBStream.h (added)
>>>>>>>> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/PDBStream.h Thu Apr
>>>>>>>> 21 15:58:35 2016
>>>>>>>> @@ -0,0 +1,46 @@
>>>>>>>> +//===- 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
>>>>>>>>
>>>>>>>> Added: llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawSession.h
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawSession.h?rev=267049&view=auto
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawSession.h (added)
>>>>>>>> +++ llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawSession.h Thu Apr
>>>>>>>> 21 15:58:35 2016
>>>>>>>> @@ -0,0 +1,72 @@
>>>>>>>> +//===- 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
>>>>>>>>
>>>>>>>> Modified: llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt?rev=267049&r1=267048&r2=267049&view=diff
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt (original)
>>>>>>>> +++ llvm/trunk/lib/DebugInfo/PDB/CMakeLists.txt Thu Apr 21 15:58:35
>>>>>>>> 2016
>>>>>>>> @@ -24,9 +24,13 @@ if(HAVE_DIA_SDK)
>>>>>>>>      )
>>>>>>>>
>>>>>>>>      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
>>>>>>>>
>>>>>>>> Modified: llvm/trunk/lib/DebugInfo/PDB/PDB.cpp
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/PDB.cpp?rev=267049&r1=267048&r2=267049&view=diff
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/lib/DebugInfo/PDB/PDB.cpp (original)
>>>>>>>> +++ llvm/trunk/lib/DebugInfo/PDB/PDB.cpp Thu Apr 21 15:58:35 2016
>>>>>>>> @@ -17,23 +17,28 @@
>>>>>>>>  #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
>>>>>>>> -  return PDB_ErrorCode::NoDiaSupport;
>>>>>>>>
>>>>>>>
>>>>>>> Tihs (& the same below) triggers -Wreturn-type in the case where
>>>>>>> HAVE_DIA_SDK is false. I'm not sure what the right fix is? Should the old
>>>>>>> return be added back again?
>>>>>>>
>>>>>>>
>>>>>>>>  }
>>>>>>>>
>>>>>>>>  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
>>>>>>>> -  return PDB_ErrorCode::NoDiaSupport;
>>>>>>>>  }
>>>>>>>>
>>>>>>>> Added: llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp?rev=267049&view=auto
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp (added)
>>>>>>>> +++ llvm/trunk/lib/DebugInfo/PDB/Raw/PDBFile.cpp Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -0,0 +1,249 @@
>>>>>>>> +//===- 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::PDBContext {
>>>>>>>> +  std::unique_ptr<MemoryBuffer> Buffer;
>>>>>>>> +  const SuperBlock *SB;
>>>>>>>> +  std::vector<uint32_t> StreamSizes;
>>>>>>>> +  DenseMap<uint32_t, std::vector<uint32_t>> StreamMap;
>>>>>>>> +};
>>>>>>>> +
>>>>>>>> +namespace {
>>>>>>>> +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>
>>>>>>>> +std::error_code checkOffset(MemoryBufferRef M, ArrayRef<T> AR) {
>>>>>>>> +  return checkOffset(M, uintptr_t(AR.data()), (uint64_t)AR.size()
>>>>>>>> * sizeof(T));
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +std::error_code checkOffset(MemoryBufferRef M, StringRef SR) {
>>>>>>>> +  return checkOffset(M, uintptr_t(SR.data()), SR.size());
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +uint64_t bytesToBlocks(uint64_t NumBytes, uint64_t BlockSize) {
>>>>>>>> +  return alignTo(NumBytes, BlockSize) / BlockSize;
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +uint64_t blockToOffset(uint64_t BlockNumber, uint64_t BlockSize) {
>>>>>>>> +  return BlockNumber * BlockSize;
>>>>>>>> +}
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +PDBFile::PDBFile(std::unique_ptr<MemoryBuffer> MemBuffer) {
>>>>>>>> +  Context.reset(new PDBContext());
>>>>>>>> +  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;
>>>>>>>> +  // 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;
>>>>>>>> +  std::error_code EC;
>>>>>>>> +
>>>>>>>> +  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 uint32_t
>>>>>>>> *>(M.getBufferStart() +
>>>>>>>> +
>>>>>>>> DirectoryBlockOffset),
>>>>>>>> +                     SB->BlockSize / sizeof(support::ulittle32_t));
>>>>>>>> +    if (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<uint32_t> PDBFile::getDirectoryBlockArray() {
>>>>>>>> +  return makeArrayRef(
>>>>>>>> +      reinterpret_cast<const uint32_t
>>>>>>>> *>(Context->Buffer->getBufferStart() +
>>>>>>>> +                                         getBlockMapOffset()),
>>>>>>>> +      getNumDirectoryBlocks());
>>>>>>>> +}
>>>>>>>>
>>>>>>>> Added: llvm/trunk/lib/DebugInfo/PDB/Raw/PDBStream.cpp
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Raw/PDBStream.cpp?rev=267049&view=auto
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/lib/DebugInfo/PDB/Raw/PDBStream.cpp (added)
>>>>>>>> +++ llvm/trunk/lib/DebugInfo/PDB/Raw/PDBStream.cpp Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -0,0 +1,97 @@
>>>>>>>> +//===- 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;
>>>>>>>> +
>>>>>>>> +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;
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +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::detail::packed_endian_specific_integral<uint32_t,
>>>>>>>> support::little,
>>>>>>>> +
>>>>>>>>  support::unaligned>
>>>>>>>> +      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 =
>>>>>>>> +        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;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Added: llvm/trunk/lib/DebugInfo/PDB/Raw/RawSession.cpp
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/DebugInfo/PDB/Raw/RawSession.cpp?rev=267049&view=auto
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/lib/DebugInfo/PDB/Raw/RawSession.cpp (added)
>>>>>>>> +++ llvm/trunk/lib/DebugInfo/PDB/Raw/RawSession.cpp Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -0,0 +1,126 @@
>>>>>>>> +//===- 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;
>>>>>>>> +}
>>>>>>>>
>>>>>>>> Modified: llvm/trunk/tools/llvm-pdbdump/BuiltinDumper.h
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/BuiltinDumper.h?rev=267049&r1=267048&r2=267049&view=diff
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/tools/llvm-pdbdump/BuiltinDumper.h (original)
>>>>>>>> +++ llvm/trunk/tools/llvm-pdbdump/BuiltinDumper.h Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -10,6 +10,7 @@
>>>>>>>>  #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 {
>>>>>>>>
>>>>>>>> Modified: llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp
>>>>>>>> URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp?rev=267049&r1=267048&r2=267049&view=diff
>>>>>>>>
>>>>>>>> ==============================================================================
>>>>>>>> --- llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp (original)
>>>>>>>> +++ llvm/trunk/tools/llvm-pdbdump/llvm-pdbdump.cpp Thu Apr 21
>>>>>>>> 15:58:35 2016
>>>>>>>> @@ -35,6 +35,9 @@
>>>>>>>>  #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"
>>>>>>>> @@ -43,8 +46,8 @@
>>>>>>>>  #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
>>>>>>>> @@ -152,186 +155,32 @@ static void reportError(StringRef Input,
>>>>>>>>    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';
>>>>>>>> +    outs() << "NumDirectoryBlocks: " <<
>>>>>>>> File.getNumDirectoryBlocks() << '\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));
>>>>>>>> -
>>>>>>>> -  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 uint32_t &DirectoryBlockAddr : DirectoryBlocks) {
>>>>>>>>        if (&DirectoryBlockAddr != &DirectoryBlocks.front())
>>>>>>>>          outs() << ", ";
>>>>>>>>        outs() << DirectoryBlockAddr;
>>>>>>>> @@ -339,96 +188,23 @@ static void dumpStructure(MemoryBufferRe
>>>>>>>>      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; 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";
>>>>>>>>      }
>>>>>>>> @@ -437,103 +213,107 @@ static void dumpStructure(MemoryBufferRe
>>>>>>>>    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';
>>>>>>>>    }
>>>>>>>> @@ -554,26 +334,25 @@ static void dumpStructure(MemoryBufferRe
>>>>>>>>
>>>>>>>>      // 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});
>>>>>>>>    }
>>>>>>>> @@ -581,45 +360,38 @@ static void dumpStructure(MemoryBufferRe
>>>>>>>>    // 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:
>>>>>>>>
>>>>>>>>
>>>>>>>> _______________________________________________
>>>>>>>> llvm-commits mailing list
>>>>>>>> llvm-commits at lists.llvm.org
>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>>>>>>>
>>>>>>> _______________________________________________
>>>>>> llvm-commits mailing list
>>>>>> llvm-commits at lists.llvm.org
>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>>>>>
>>>>> --
>>>>> Mike
>>>>> Sent from phone
>>>>
>>>> --
>>> Mike
>>> Sent from phone
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160422/4cde91be/attachment.html>


More information about the llvm-commits mailing list