mirror of
https://github.com/RPCS3/llvm.git
synced 2025-04-18 05:50:38 +00:00
45ab259f8d
When dumping huge PDB files, too many of the options were grouped together so you would get neverending spew of output. This patch introduces more granular display options so you can only dump the fields you actually care about. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@270607 91177308-0d34-0410-b5e6-96231b3b80d8
305 lines
12 KiB
C++
305 lines
12 KiB
C++
//===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
|
|
//
|
|
// 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/DbiStream.h"
|
|
|
|
#include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
|
|
#include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
|
|
#include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
|
|
#include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
|
|
#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
|
|
#include "llvm/DebugInfo/PDB/Raw/RawError.h"
|
|
#include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::pdb;
|
|
using namespace llvm::support;
|
|
|
|
namespace {
|
|
// Some of the values are stored in bitfields. Since this needs to be portable
|
|
// across compilers and architectures (big / little endian in particular) we
|
|
// can't use the actual structures below, but must instead do the shifting
|
|
// and masking ourselves. The struct definitions are provided for reference.
|
|
|
|
// struct DbiFlags {
|
|
// uint16_t IncrementalLinking : 1; // True if linked incrementally
|
|
// uint16_t IsStripped : 1; // True if private symbols were stripped.
|
|
// uint16_t HasCTypes : 1; // True if linked with /debug:ctypes.
|
|
// uint16_t Reserved : 13;
|
|
//};
|
|
const uint16_t FlagIncrementalMask = 0x0001;
|
|
const uint16_t FlagStrippedMask = 0x0002;
|
|
const uint16_t FlagHasCTypesMask = 0x0004;
|
|
|
|
// struct DbiBuildNo {
|
|
// uint16_t MinorVersion : 8;
|
|
// uint16_t MajorVersion : 7;
|
|
// uint16_t NewVersionFormat : 1;
|
|
//};
|
|
const uint16_t BuildMinorMask = 0x00FF;
|
|
const uint16_t BuildMinorShift = 0;
|
|
|
|
const uint16_t BuildMajorMask = 0x7F00;
|
|
const uint16_t BuildMajorShift = 8;
|
|
}
|
|
|
|
struct DbiStream::HeaderInfo {
|
|
little32_t VersionSignature;
|
|
ulittle32_t VersionHeader;
|
|
ulittle32_t Age; // Should match InfoStream.
|
|
ulittle16_t GlobalSymbolStreamIndex; // Global symbol stream #
|
|
ulittle16_t BuildNumber; // See DbiBuildNo structure.
|
|
ulittle16_t PublicSymbolStreamIndex; // Public symbols stream #
|
|
ulittle16_t PdbDllVersion; // version of mspdbNNN.dll
|
|
ulittle16_t SymRecordStreamIndex; // Symbol records stream #
|
|
ulittle16_t PdbDllRbld; // rbld number of mspdbNNN.dll
|
|
little32_t ModiSubstreamSize; // Size of module info stream
|
|
little32_t SecContrSubstreamSize; // Size of sec. contribution stream
|
|
little32_t SectionMapSize; // Size of sec. map substream
|
|
little32_t FileInfoSize; // Size of file info substream
|
|
little32_t TypeServerSize; // Size of type server map
|
|
ulittle32_t MFCTypeServerIndex; // Index of MFC Type Server
|
|
little32_t OptionalDbgHdrSize; // Size of DbgHeader info
|
|
little32_t ECSubstreamSize; // Size of EC stream (what is EC?)
|
|
ulittle16_t Flags; // See DbiFlags enum.
|
|
ulittle16_t MachineType; // See PDB_MachineType enum.
|
|
|
|
ulittle32_t Reserved; // Pad to 64 bytes
|
|
};
|
|
|
|
DbiStream::DbiStream(PDBFile &File) : Pdb(File), Stream(StreamDBI, File) {
|
|
static_assert(sizeof(HeaderInfo) == 64, "Invalid HeaderInfo size!");
|
|
}
|
|
|
|
DbiStream::~DbiStream() {}
|
|
|
|
Error DbiStream::reload() {
|
|
StreamReader Reader(Stream);
|
|
|
|
Header.reset(new HeaderInfo());
|
|
|
|
if (Stream.getLength() < sizeof(HeaderInfo))
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI Stream does not contain a header.");
|
|
if (auto EC = Reader.readObject(Header.get()))
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI Stream does not contain a header.");
|
|
|
|
if (Header->VersionSignature != -1)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"Invalid DBI version signature.");
|
|
|
|
// Require at least version 7, which should be present in all PDBs
|
|
// produced in the last decade and allows us to avoid having to
|
|
// special case all kinds of complicated arcane formats.
|
|
if (Header->VersionHeader < PdbDbiV70)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"Unsupported DBI version.");
|
|
|
|
auto InfoStream = Pdb.getPDBInfoStream();
|
|
if (auto EC = InfoStream.takeError())
|
|
return EC;
|
|
|
|
if (Header->Age != InfoStream.get().getAge())
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI Age does not match PDB Age.");
|
|
|
|
if (Stream.getLength() !=
|
|
sizeof(HeaderInfo) + Header->ModiSubstreamSize +
|
|
Header->SecContrSubstreamSize + Header->SectionMapSize +
|
|
Header->FileInfoSize + Header->TypeServerSize +
|
|
Header->OptionalDbgHdrSize + Header->ECSubstreamSize)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI Length does not equal sum of substreams.");
|
|
|
|
// Only certain substreams are guaranteed to be aligned. Validate
|
|
// them here.
|
|
if (Header->ModiSubstreamSize % sizeof(uint32_t) != 0)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI MODI substream not aligned.");
|
|
if (Header->SecContrSubstreamSize % sizeof(uint32_t) != 0)
|
|
return make_error<RawError>(
|
|
raw_error_code::corrupt_file,
|
|
"DBI section contribution substream not aligned.");
|
|
if (Header->SectionMapSize % sizeof(uint32_t) != 0)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI section map substream not aligned.");
|
|
if (Header->FileInfoSize % sizeof(uint32_t) != 0)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI file info substream not aligned.");
|
|
if (Header->TypeServerSize % sizeof(uint32_t) != 0)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"DBI type server substream not aligned.");
|
|
|
|
if (auto EC = ModInfoSubstream.initialize(Reader, Header->ModiSubstreamSize))
|
|
return EC;
|
|
|
|
// Since each ModInfo in the stream is a variable length, we have to iterate
|
|
// them to know how many there actually are.
|
|
auto Range =
|
|
llvm::make_range(ModInfoIterator(&ModInfoSubstream.data().front()),
|
|
ModInfoIterator(&ModInfoSubstream.data().back() + 1));
|
|
for (auto Info : Range)
|
|
ModuleInfos.push_back(ModuleInfoEx(Info));
|
|
|
|
if (auto EC =
|
|
SecContrSubstream.initialize(Reader, Header->SecContrSubstreamSize))
|
|
return EC;
|
|
if (auto EC = SecMapSubstream.initialize(Reader, Header->SectionMapSize))
|
|
return EC;
|
|
if (auto EC = FileInfoSubstream.initialize(Reader, Header->FileInfoSize))
|
|
return EC;
|
|
if (auto EC =
|
|
TypeServerMapSubstream.initialize(Reader, Header->TypeServerSize))
|
|
return EC;
|
|
if (auto EC = ECSubstream.initialize(Reader, Header->ECSubstreamSize))
|
|
return EC;
|
|
if (auto EC = DbgHeader.initialize(Reader, Header->OptionalDbgHdrSize))
|
|
return EC;
|
|
|
|
if (auto EC = initializeFileInfo())
|
|
return EC;
|
|
|
|
if (Reader.bytesRemaining() > 0)
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"Found unexpected bytes in DBI Stream.");
|
|
|
|
StreamReader ECReader(ECSubstream);
|
|
if (auto EC = ECNames.load(ECReader))
|
|
return EC;
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
PdbRaw_DbiVer DbiStream::getDbiVersion() const {
|
|
uint32_t Value = Header->VersionHeader;
|
|
return static_cast<PdbRaw_DbiVer>(Value);
|
|
}
|
|
|
|
uint32_t DbiStream::getAge() const { return Header->Age; }
|
|
|
|
uint16_t DbiStream::getPublicSymbolStreamIndex() const {
|
|
return Header->PublicSymbolStreamIndex;
|
|
}
|
|
|
|
uint16_t DbiStream::getGlobalSymbolStreamIndex() const {
|
|
return Header->GlobalSymbolStreamIndex;
|
|
}
|
|
|
|
bool DbiStream::isIncrementallyLinked() const {
|
|
return (Header->Flags & FlagIncrementalMask) != 0;
|
|
}
|
|
|
|
bool DbiStream::hasCTypes() const {
|
|
return (Header->Flags & FlagHasCTypesMask) != 0;
|
|
}
|
|
|
|
bool DbiStream::isStripped() const {
|
|
return (Header->Flags & FlagStrippedMask) != 0;
|
|
}
|
|
|
|
uint16_t DbiStream::getBuildMajorVersion() const {
|
|
return (Header->BuildNumber & BuildMajorMask) >> BuildMajorShift;
|
|
}
|
|
|
|
uint16_t DbiStream::getBuildMinorVersion() const {
|
|
return (Header->BuildNumber & BuildMinorMask) >> BuildMinorShift;
|
|
}
|
|
|
|
uint32_t DbiStream::getPdbDllVersion() const { return Header->PdbDllVersion; }
|
|
|
|
uint32_t DbiStream::getSymRecordStreamIndex() const {
|
|
return Header->SymRecordStreamIndex;
|
|
}
|
|
|
|
PDB_Machine DbiStream::getMachineType() const {
|
|
uint16_t Machine = Header->MachineType;
|
|
return static_cast<PDB_Machine>(Machine);
|
|
}
|
|
|
|
ArrayRef<ModuleInfoEx> DbiStream::modules() const { return ModuleInfos; }
|
|
|
|
Error DbiStream::initializeFileInfo() {
|
|
struct FileInfoSubstreamHeader {
|
|
ulittle16_t NumModules; // Total # of modules, should match number of
|
|
// records in the ModuleInfo substream.
|
|
ulittle16_t NumSourceFiles; // Total # of source files. This value is not
|
|
// accurate because PDB actually supports more
|
|
// than 64k source files, so we ignore it and
|
|
// compute the value from other stream fields.
|
|
};
|
|
|
|
// The layout of the FileInfoSubstream is like this:
|
|
// struct {
|
|
// ulittle16_t NumModules;
|
|
// ulittle16_t NumSourceFiles;
|
|
// ulittle16_t ModIndices[NumModules];
|
|
// ulittle16_t ModFileCounts[NumModules];
|
|
// ulittle32_t FileNameOffsets[NumSourceFiles];
|
|
// char Names[][NumSourceFiles];
|
|
// };
|
|
// with the caveat that `NumSourceFiles` cannot be trusted, so
|
|
// it is computed by summing `ModFileCounts`.
|
|
//
|
|
const uint8_t *Buf = &FileInfoSubstream.data().front();
|
|
auto FI = reinterpret_cast<const FileInfoSubstreamHeader *>(Buf);
|
|
Buf += sizeof(FileInfoSubstreamHeader);
|
|
// The number of modules in the stream should be the same as reported by
|
|
// the FileInfoSubstreamHeader.
|
|
if (FI->NumModules != ModuleInfos.size())
|
|
return make_error<RawError>(raw_error_code::corrupt_file,
|
|
"FileInfo substream count doesn't match DBI.");
|
|
|
|
// First is an array of `NumModules` module indices. This is not used for the
|
|
// same reason that `NumSourceFiles` is not used. It's an array of uint16's,
|
|
// but it's possible there are more than 64k source files, which would imply
|
|
// more than 64k modules (e.g. object files) as well. So we ignore this
|
|
// field.
|
|
llvm::ArrayRef<ulittle16_t> ModIndexArray(
|
|
reinterpret_cast<const ulittle16_t *>(Buf), ModuleInfos.size());
|
|
|
|
llvm::ArrayRef<ulittle16_t> ModFileCountArray(ModIndexArray.end(),
|
|
ModuleInfos.size());
|
|
|
|
// Compute the real number of source files.
|
|
uint32_t NumSourceFiles = 0;
|
|
for (auto Count : ModFileCountArray)
|
|
NumSourceFiles += Count;
|
|
|
|
// This is the array that in the reference implementation corresponds to
|
|
// `ModInfo::FileLayout::FileNameOffs`, which is commented there as being a
|
|
// pointer. Due to the mentioned problems of pointers causing difficulty
|
|
// when reading from the file on 64-bit systems, we continue to ignore that
|
|
// field in `ModInfo`, and instead build a vector of StringRefs and stores
|
|
// them in `ModuleInfoEx`. The value written to and read from the file is
|
|
// not used anyway, it is only there as a way to store the offsets for the
|
|
// purposes of later accessing the names at runtime.
|
|
llvm::ArrayRef<little32_t> FileNameOffsets(
|
|
reinterpret_cast<const little32_t *>(ModFileCountArray.end()),
|
|
NumSourceFiles);
|
|
|
|
const char *Names = reinterpret_cast<const char *>(FileNameOffsets.end());
|
|
|
|
// We go through each ModuleInfo, determine the number N of source files for
|
|
// that module, and then get the next N offsets from the Offsets array, using
|
|
// them to get the corresponding N names from the Names buffer and associating
|
|
// each one with the corresponding module.
|
|
uint32_t NextFileIndex = 0;
|
|
for (size_t I = 0; I < ModuleInfos.size(); ++I) {
|
|
uint32_t NumFiles = ModFileCountArray[I];
|
|
ModuleInfos[I].SourceFiles.resize(NumFiles);
|
|
for (size_t J = 0; J < NumFiles; ++J, ++NextFileIndex) {
|
|
uint32_t FileIndex = FileNameOffsets[NextFileIndex];
|
|
ModuleInfos[I].SourceFiles[J] = StringRef(Names + FileIndex);
|
|
}
|
|
}
|
|
|
|
return Error::success();
|
|
}
|