1 //===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
11 #include "llvm/ADT/StringRef.h"
12 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
13 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
14 #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
15 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
16 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
17 #include "llvm/DebugInfo/PDB/Native/RawError.h"
18 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
19 #include "llvm/DebugInfo/PDB/PDBTypes.h"
20 #include "llvm/Object/COFF.h"
21 #include "llvm/Support/BinaryStreamArray.h"
22 #include "llvm/Support/BinaryStreamReader.h"
23 #include "llvm/Support/Error.h"
24 #include <algorithm>
25 #include <cstddef>
26 #include <cstdint>
27
28 using namespace llvm;
29 using namespace llvm::codeview;
30 using namespace llvm::msf;
31 using namespace llvm::pdb;
32 using namespace llvm::support;
33
34 template <typename ContribType>
loadSectionContribs(FixedStreamArray<ContribType> & Output,BinaryStreamReader & Reader)35 static Error loadSectionContribs(FixedStreamArray<ContribType> &Output,
36 BinaryStreamReader &Reader) {
37 if (Reader.bytesRemaining() % sizeof(ContribType) != 0)
38 return make_error<RawError>(
39 raw_error_code::corrupt_file,
40 "Invalid number of bytes of section contributions");
41
42 uint32_t Count = Reader.bytesRemaining() / sizeof(ContribType);
43 if (auto EC = Reader.readArray(Output, Count))
44 return EC;
45 return Error::success();
46 }
47
DbiStream(std::unique_ptr<BinaryStream> Stream)48 DbiStream::DbiStream(std::unique_ptr<BinaryStream> Stream)
49 : Stream(std::move(Stream)), Header(nullptr) {}
50
51 DbiStream::~DbiStream() = default;
52
reload(PDBFile * Pdb)53 Error DbiStream::reload(PDBFile *Pdb) {
54 BinaryStreamReader Reader(*Stream);
55
56 if (Stream->getLength() < sizeof(DbiStreamHeader))
57 return make_error<RawError>(raw_error_code::corrupt_file,
58 "DBI Stream does not contain a header.");
59 if (auto EC = Reader.readObject(Header))
60 return make_error<RawError>(raw_error_code::corrupt_file,
61 "DBI Stream does not contain a header.");
62
63 if (Header->VersionSignature != -1)
64 return make_error<RawError>(raw_error_code::corrupt_file,
65 "Invalid DBI version signature.");
66
67 // Require at least version 7, which should be present in all PDBs
68 // produced in the last decade and allows us to avoid having to
69 // special case all kinds of complicated arcane formats.
70 if (Header->VersionHeader < PdbDbiV70)
71 return make_error<RawError>(raw_error_code::feature_unsupported,
72 "Unsupported DBI version.");
73
74 if (Stream->getLength() !=
75 sizeof(DbiStreamHeader) + Header->ModiSubstreamSize +
76 Header->SecContrSubstreamSize + Header->SectionMapSize +
77 Header->FileInfoSize + Header->TypeServerSize +
78 Header->OptionalDbgHdrSize + Header->ECSubstreamSize)
79 return make_error<RawError>(raw_error_code::corrupt_file,
80 "DBI Length does not equal sum of substreams.");
81
82 // Only certain substreams are guaranteed to be aligned. Validate
83 // them here.
84 if (Header->ModiSubstreamSize % sizeof(uint32_t) != 0)
85 return make_error<RawError>(raw_error_code::corrupt_file,
86 "DBI MODI substream not aligned.");
87 if (Header->SecContrSubstreamSize % sizeof(uint32_t) != 0)
88 return make_error<RawError>(
89 raw_error_code::corrupt_file,
90 "DBI section contribution substream not aligned.");
91 if (Header->SectionMapSize % sizeof(uint32_t) != 0)
92 return make_error<RawError>(raw_error_code::corrupt_file,
93 "DBI section map substream not aligned.");
94 if (Header->FileInfoSize % sizeof(uint32_t) != 0)
95 return make_error<RawError>(raw_error_code::corrupt_file,
96 "DBI file info substream not aligned.");
97 if (Header->TypeServerSize % sizeof(uint32_t) != 0)
98 return make_error<RawError>(raw_error_code::corrupt_file,
99 "DBI type server substream not aligned.");
100
101 if (auto EC = Reader.readSubstream(ModiSubstream, Header->ModiSubstreamSize))
102 return EC;
103
104 if (auto EC = Reader.readSubstream(SecContrSubstream,
105 Header->SecContrSubstreamSize))
106 return EC;
107 if (auto EC = Reader.readSubstream(SecMapSubstream, Header->SectionMapSize))
108 return EC;
109 if (auto EC = Reader.readSubstream(FileInfoSubstream, Header->FileInfoSize))
110 return EC;
111 if (auto EC =
112 Reader.readSubstream(TypeServerMapSubstream, Header->TypeServerSize))
113 return EC;
114 if (auto EC = Reader.readSubstream(ECSubstream, Header->ECSubstreamSize))
115 return EC;
116 if (auto EC = Reader.readArray(
117 DbgStreams, Header->OptionalDbgHdrSize / sizeof(ulittle16_t)))
118 return EC;
119
120 if (auto EC = Modules.initialize(ModiSubstream.StreamData,
121 FileInfoSubstream.StreamData))
122 return EC;
123
124 if (auto EC = initializeSectionContributionData())
125 return EC;
126 if (auto EC = initializeSectionHeadersData(Pdb))
127 return EC;
128 if (auto EC = initializeSectionMapData())
129 return EC;
130 if (auto EC = initializeFpoRecords(Pdb))
131 return EC;
132
133 if (Reader.bytesRemaining() > 0)
134 return make_error<RawError>(raw_error_code::corrupt_file,
135 "Found unexpected bytes in DBI Stream.");
136
137 if (!ECSubstream.empty()) {
138 BinaryStreamReader ECReader(ECSubstream.StreamData);
139 if (auto EC = ECNames.reload(ECReader))
140 return EC;
141 }
142
143 return Error::success();
144 }
145
getDbiVersion() const146 PdbRaw_DbiVer DbiStream::getDbiVersion() const {
147 uint32_t Value = Header->VersionHeader;
148 return static_cast<PdbRaw_DbiVer>(Value);
149 }
150
getAge() const151 uint32_t DbiStream::getAge() const { return Header->Age; }
152
getPublicSymbolStreamIndex() const153 uint16_t DbiStream::getPublicSymbolStreamIndex() const {
154 return Header->PublicSymbolStreamIndex;
155 }
156
getGlobalSymbolStreamIndex() const157 uint16_t DbiStream::getGlobalSymbolStreamIndex() const {
158 return Header->GlobalSymbolStreamIndex;
159 }
160
getFlags() const161 uint16_t DbiStream::getFlags() const { return Header->Flags; }
162
isIncrementallyLinked() const163 bool DbiStream::isIncrementallyLinked() const {
164 return (Header->Flags & DbiFlags::FlagIncrementalMask) != 0;
165 }
166
hasCTypes() const167 bool DbiStream::hasCTypes() const {
168 return (Header->Flags & DbiFlags::FlagHasCTypesMask) != 0;
169 }
170
isStripped() const171 bool DbiStream::isStripped() const {
172 return (Header->Flags & DbiFlags::FlagStrippedMask) != 0;
173 }
174
getBuildNumber() const175 uint16_t DbiStream::getBuildNumber() const { return Header->BuildNumber; }
176
getBuildMajorVersion() const177 uint16_t DbiStream::getBuildMajorVersion() const {
178 return (Header->BuildNumber & DbiBuildNo::BuildMajorMask) >>
179 DbiBuildNo::BuildMajorShift;
180 }
181
getBuildMinorVersion() const182 uint16_t DbiStream::getBuildMinorVersion() const {
183 return (Header->BuildNumber & DbiBuildNo::BuildMinorMask) >>
184 DbiBuildNo::BuildMinorShift;
185 }
186
getPdbDllRbld() const187 uint16_t DbiStream::getPdbDllRbld() const { return Header->PdbDllRbld; }
188
getPdbDllVersion() const189 uint32_t DbiStream::getPdbDllVersion() const { return Header->PdbDllVersion; }
190
getSymRecordStreamIndex() const191 uint32_t DbiStream::getSymRecordStreamIndex() const {
192 return Header->SymRecordStreamIndex;
193 }
194
getMachineType() const195 PDB_Machine DbiStream::getMachineType() const {
196 uint16_t Machine = Header->MachineType;
197 return static_cast<PDB_Machine>(Machine);
198 }
199
getSectionHeaders()200 FixedStreamArray<object::coff_section> DbiStream::getSectionHeaders() {
201 return SectionHeaders;
202 }
203
getFpoRecords()204 FixedStreamArray<object::FpoData> DbiStream::getFpoRecords() {
205 return FpoRecords;
206 }
207
modules() const208 const DbiModuleList &DbiStream::modules() const { return Modules; }
209
getSectionMap() const210 FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const {
211 return SectionMap;
212 }
213
visitSectionContributions(ISectionContribVisitor & Visitor) const214 void DbiStream::visitSectionContributions(
215 ISectionContribVisitor &Visitor) const {
216 if (!SectionContribs.empty()) {
217 assert(SectionContribVersion == DbiSecContribVer60);
218 for (auto &SC : SectionContribs)
219 Visitor.visit(SC);
220 } else if (!SectionContribs2.empty()) {
221 assert(SectionContribVersion == DbiSecContribV2);
222 for (auto &SC : SectionContribs2)
223 Visitor.visit(SC);
224 }
225 }
226
getECName(uint32_t NI) const227 Expected<StringRef> DbiStream::getECName(uint32_t NI) const {
228 return ECNames.getStringForID(NI);
229 }
230
initializeSectionContributionData()231 Error DbiStream::initializeSectionContributionData() {
232 if (SecContrSubstream.empty())
233 return Error::success();
234
235 BinaryStreamReader SCReader(SecContrSubstream.StreamData);
236 if (auto EC = SCReader.readEnum(SectionContribVersion))
237 return EC;
238
239 if (SectionContribVersion == DbiSecContribVer60)
240 return loadSectionContribs<SectionContrib>(SectionContribs, SCReader);
241 if (SectionContribVersion == DbiSecContribV2)
242 return loadSectionContribs<SectionContrib2>(SectionContribs2, SCReader);
243
244 return make_error<RawError>(raw_error_code::feature_unsupported,
245 "Unsupported DBI Section Contribution version");
246 }
247
248 // Initializes this->SectionHeaders.
initializeSectionHeadersData(PDBFile * Pdb)249 Error DbiStream::initializeSectionHeadersData(PDBFile *Pdb) {
250 if (!Pdb)
251 return Error::success();
252
253 if (DbgStreams.size() == 0)
254 return Error::success();
255
256 uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::SectionHdr);
257 if (StreamNum == kInvalidStreamIndex)
258 return Error::success();
259
260 if (StreamNum >= Pdb->getNumStreams())
261 return make_error<RawError>(raw_error_code::no_stream);
262
263 auto SHS = MappedBlockStream::createIndexedStream(
264 Pdb->getMsfLayout(), Pdb->getMsfBuffer(), StreamNum, Pdb->getAllocator());
265
266 size_t StreamLen = SHS->getLength();
267 if (StreamLen % sizeof(object::coff_section))
268 return make_error<RawError>(raw_error_code::corrupt_file,
269 "Corrupted section header stream.");
270
271 size_t NumSections = StreamLen / sizeof(object::coff_section);
272 BinaryStreamReader Reader(*SHS);
273 if (auto EC = Reader.readArray(SectionHeaders, NumSections))
274 return make_error<RawError>(raw_error_code::corrupt_file,
275 "Could not read a bitmap.");
276
277 SectionHeaderStream = std::move(SHS);
278 return Error::success();
279 }
280
281 // Initializes this->Fpos.
initializeFpoRecords(PDBFile * Pdb)282 Error DbiStream::initializeFpoRecords(PDBFile *Pdb) {
283 if (!Pdb)
284 return Error::success();
285
286 if (DbgStreams.size() == 0)
287 return Error::success();
288
289 uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::NewFPO);
290
291 // This means there is no FPO data.
292 if (StreamNum == kInvalidStreamIndex)
293 return Error::success();
294
295 if (StreamNum >= Pdb->getNumStreams())
296 return make_error<RawError>(raw_error_code::no_stream);
297
298 auto FS = MappedBlockStream::createIndexedStream(
299 Pdb->getMsfLayout(), Pdb->getMsfBuffer(), StreamNum, Pdb->getAllocator());
300
301 size_t StreamLen = FS->getLength();
302 if (StreamLen % sizeof(object::FpoData))
303 return make_error<RawError>(raw_error_code::corrupt_file,
304 "Corrupted New FPO stream.");
305
306 size_t NumRecords = StreamLen / sizeof(object::FpoData);
307 BinaryStreamReader Reader(*FS);
308 if (auto EC = Reader.readArray(FpoRecords, NumRecords))
309 return make_error<RawError>(raw_error_code::corrupt_file,
310 "Corrupted New FPO stream.");
311 FpoStream = std::move(FS);
312 return Error::success();
313 }
314
getSectionContributionData() const315 BinarySubstreamRef DbiStream::getSectionContributionData() const {
316 return SecContrSubstream;
317 }
318
getSecMapSubstreamData() const319 BinarySubstreamRef DbiStream::getSecMapSubstreamData() const {
320 return SecMapSubstream;
321 }
322
getModiSubstreamData() const323 BinarySubstreamRef DbiStream::getModiSubstreamData() const {
324 return ModiSubstream;
325 }
326
getFileInfoSubstreamData() const327 BinarySubstreamRef DbiStream::getFileInfoSubstreamData() const {
328 return FileInfoSubstream;
329 }
330
getTypeServerMapSubstreamData() const331 BinarySubstreamRef DbiStream::getTypeServerMapSubstreamData() const {
332 return TypeServerMapSubstream;
333 }
334
getECSubstreamData() const335 BinarySubstreamRef DbiStream::getECSubstreamData() const { return ECSubstream; }
336
initializeSectionMapData()337 Error DbiStream::initializeSectionMapData() {
338 if (SecMapSubstream.empty())
339 return Error::success();
340
341 BinaryStreamReader SMReader(SecMapSubstream.StreamData);
342 const SecMapHeader *Header;
343 if (auto EC = SMReader.readObject(Header))
344 return EC;
345 if (auto EC = SMReader.readArray(SectionMap, Header->SecCount))
346 return EC;
347 return Error::success();
348 }
349
getDebugStreamIndex(DbgHeaderType Type) const350 uint32_t DbiStream::getDebugStreamIndex(DbgHeaderType Type) const {
351 uint16_t T = static_cast<uint16_t>(Type);
352 if (T >= DbgStreams.size())
353 return kInvalidStreamIndex;
354 return DbgStreams[T];
355 }
356