maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/DebugInfo/PDB/Raw/DbiStream.cpp

295 lines
12 KiB
C++
Raw Blame History

//===- 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 GSSyms; // Number of global symbols
ulittle16_t BuildNumber; // See DbiBuildNo structure.
ulittle16_t PSSyms; // Number of public symbols
ulittle16_t PdbDllVersion; // version of mspdbNNN.dll
ulittle16_t SymRecords; // Number of symbols
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; }
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::getNumberOfSymbols() const { return Header->SymRecords; }
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();
}
Reference in New Issue View Git Blame Copy Permalink