[llvm] r267049 - Refactor raw pdb dumper into library
Daniel Sanders via llvm-commits
llvm-commits at lists.llvm.org
Fri Apr 22 01:59:28 PDT 2016
Hi,
This test still fails for clang-cmake-mips (http://lab.llvm.org:8011/builders/clang-cmake-mips/builds/13208). I'll take a look once I've reverted the commit responsible for the other failing tests in that build.
From: llvm-commits [mailto:llvm-commits-bounces at lists.llvm.org] On Behalf Of Mike Aizatsky via llvm-commits
Sent: 22 April 2016 01:01
To: Zachary Turner; David Blaikie
Cc: llvm-commits
Subject: Re: [llvm] r267049 - Refactor raw pdb dumper into library
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<mailto: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<mailto: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<mailto: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<mailto: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<mailto: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<mailto: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<mailto: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/d01e03d9/attachment.html>
More information about the llvm-commits
mailing list