[llvm] r267049 - Refactor raw pdb dumper into library
Zachary Turner via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 21 17:03:24 PDT 2016
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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160422/1902978c/attachment-0001.html>
More information about the llvm-commits
mailing list