[llvm] r267049 - Refactor raw pdb dumper into library
Richard Smith via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 21 19:16:23 PDT 2016
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/20160421/0d35a8db/attachment-0001.html>
More information about the llvm-commits
mailing list