1 //===- BytesOutputStyle.cpp ----------------------------------- *- C++ --*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "BytesOutputStyle.h"
10
11 #include "FormatUtil.h"
12 #include "StreamUtil.h"
13 #include "llvm-pdbutil.h"
14
15 #include "llvm/DebugInfo/CodeView/Formatters.h"
16 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
17 #include "llvm/DebugInfo/MSF/MSFCommon.h"
18 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
19 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
20 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
21 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
22 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
23 #include "llvm/DebugInfo/PDB/Native/RawError.h"
24 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
25 #include "llvm/Support/BinaryStreamReader.h"
26 #include "llvm/Support/FormatAdapters.h"
27 #include "llvm/Support/FormatVariadic.h"
28
29 using namespace llvm;
30 using namespace llvm::codeview;
31 using namespace llvm::msf;
32 using namespace llvm::pdb;
33
34 namespace {
35 struct StreamSpec {
36 uint32_t SI = 0;
37 uint32_t Begin = 0;
38 uint32_t Size = 0;
39 };
40 } // namespace
41
parseStreamSpec(StringRef Str)42 static Expected<StreamSpec> parseStreamSpec(StringRef Str) {
43 StreamSpec Result;
44 if (Str.consumeInteger(0, Result.SI))
45 return make_error<RawError>(raw_error_code::invalid_format,
46 "Invalid Stream Specification");
47 if (Str.consume_front(":")) {
48 if (Str.consumeInteger(0, Result.Begin))
49 return make_error<RawError>(raw_error_code::invalid_format,
50 "Invalid Stream Specification");
51 }
52 if (Str.consume_front("@")) {
53 if (Str.consumeInteger(0, Result.Size))
54 return make_error<RawError>(raw_error_code::invalid_format,
55 "Invalid Stream Specification");
56 }
57
58 if (!Str.empty())
59 return make_error<RawError>(raw_error_code::invalid_format,
60 "Invalid Stream Specification");
61 return Result;
62 }
63
parseStreamSpecs(LinePrinter & P)64 static SmallVector<StreamSpec, 2> parseStreamSpecs(LinePrinter &P) {
65 SmallVector<StreamSpec, 2> Result;
66
67 for (auto &Str : opts::bytes::DumpStreamData) {
68 auto ESS = parseStreamSpec(Str);
69 if (!ESS) {
70 P.formatLine("Error parsing stream spec {0}: {1}", Str,
71 toString(ESS.takeError()));
72 continue;
73 }
74 Result.push_back(*ESS);
75 }
76 return Result;
77 }
78
printHeader(LinePrinter & P,const Twine & S)79 static void printHeader(LinePrinter &P, const Twine &S) {
80 P.NewLine();
81 P.formatLine("{0,=60}", S);
82 P.formatLine("{0}", fmt_repeat('=', 60));
83 }
84
BytesOutputStyle(PDBFile & File)85 BytesOutputStyle::BytesOutputStyle(PDBFile &File)
86 : File(File), P(2, false, outs()) {}
87
dump()88 Error BytesOutputStyle::dump() {
89
90 if (opts::bytes::DumpBlockRange.hasValue()) {
91 auto &R = *opts::bytes::DumpBlockRange;
92 uint32_t Max = R.Max.getValueOr(R.Min);
93
94 if (Max < R.Min)
95 return make_error<StringError>(
96 "Invalid block range specified. Max < Min",
97 inconvertibleErrorCode());
98 if (Max >= File.getBlockCount())
99 return make_error<StringError>(
100 "Invalid block range specified. Requested block out of bounds",
101 inconvertibleErrorCode());
102
103 dumpBlockRanges(R.Min, Max);
104 P.NewLine();
105 }
106
107 if (opts::bytes::DumpByteRange.hasValue()) {
108 auto &R = *opts::bytes::DumpByteRange;
109 uint32_t Max = R.Max.getValueOr(File.getFileSize());
110
111 if (Max < R.Min)
112 return make_error<StringError>("Invalid byte range specified. Max < Min",
113 inconvertibleErrorCode());
114 if (Max >= File.getFileSize())
115 return make_error<StringError>(
116 "Invalid byte range specified. Requested byte larger than file size",
117 inconvertibleErrorCode());
118
119 dumpByteRanges(R.Min, Max);
120 P.NewLine();
121 }
122
123 if (opts::bytes::Fpm) {
124 dumpFpm();
125 P.NewLine();
126 }
127
128 if (!opts::bytes::DumpStreamData.empty()) {
129 dumpStreamBytes();
130 P.NewLine();
131 }
132
133 if (opts::bytes::NameMap) {
134 dumpNameMap();
135 P.NewLine();
136 }
137
138 if (opts::bytes::SectionContributions) {
139 dumpSectionContributions();
140 P.NewLine();
141 }
142
143 if (opts::bytes::SectionMap) {
144 dumpSectionMap();
145 P.NewLine();
146 }
147
148 if (opts::bytes::ModuleInfos) {
149 dumpModuleInfos();
150 P.NewLine();
151 }
152
153 if (opts::bytes::FileInfo) {
154 dumpFileInfo();
155 P.NewLine();
156 }
157
158 if (opts::bytes::TypeServerMap) {
159 dumpTypeServerMap();
160 P.NewLine();
161 }
162
163 if (opts::bytes::ECData) {
164 dumpECData();
165 P.NewLine();
166 }
167
168 if (!opts::bytes::TypeIndex.empty()) {
169 dumpTypeIndex(StreamTPI, opts::bytes::TypeIndex);
170 P.NewLine();
171 }
172
173 if (!opts::bytes::IdIndex.empty()) {
174 dumpTypeIndex(StreamIPI, opts::bytes::IdIndex);
175 P.NewLine();
176 }
177
178 if (opts::bytes::ModuleSyms) {
179 dumpModuleSyms();
180 P.NewLine();
181 }
182
183 if (opts::bytes::ModuleC11) {
184 dumpModuleC11();
185 P.NewLine();
186 }
187
188 if (opts::bytes::ModuleC13) {
189 dumpModuleC13();
190 P.NewLine();
191 }
192
193 return Error::success();
194 }
195
dumpNameMap()196 void BytesOutputStyle::dumpNameMap() {
197 printHeader(P, "Named Stream Map");
198
199 AutoIndent Indent(P);
200
201 auto &InfoS = Err(File.getPDBInfoStream());
202 BinarySubstreamRef NS = InfoS.getNamedStreamsBuffer();
203 auto Layout = File.getStreamLayout(StreamPDB);
204 P.formatMsfStreamData("Named Stream Map", File, Layout, NS);
205 }
206
dumpBlockRanges(uint32_t Min,uint32_t Max)207 void BytesOutputStyle::dumpBlockRanges(uint32_t Min, uint32_t Max) {
208 printHeader(P, "MSF Blocks");
209
210 AutoIndent Indent(P);
211 for (uint32_t I = Min; I <= Max; ++I) {
212 uint64_t Base = I;
213 Base *= File.getBlockSize();
214
215 auto ExpectedData = File.getBlockData(I, File.getBlockSize());
216 if (!ExpectedData) {
217 P.formatLine("Could not get block {0}. Reason = {1}", I,
218 toString(ExpectedData.takeError()));
219 continue;
220 }
221 std::string Label = formatv("Block {0}", I).str();
222 P.formatBinary(Label, *ExpectedData, Base, 0);
223 }
224 }
225
dumpSectionContributions()226 void BytesOutputStyle::dumpSectionContributions() {
227 printHeader(P, "Section Contributions");
228
229 AutoIndent Indent(P);
230
231 auto &DbiS = Err(File.getPDBDbiStream());
232 BinarySubstreamRef NS = DbiS.getSectionContributionData();
233 auto Layout = File.getStreamLayout(StreamDBI);
234 P.formatMsfStreamData("Section Contributions", File, Layout, NS);
235 }
236
dumpSectionMap()237 void BytesOutputStyle::dumpSectionMap() {
238 printHeader(P, "Section Map");
239
240 AutoIndent Indent(P);
241
242 auto &DbiS = Err(File.getPDBDbiStream());
243 BinarySubstreamRef NS = DbiS.getSecMapSubstreamData();
244 auto Layout = File.getStreamLayout(StreamDBI);
245 P.formatMsfStreamData("Section Map", File, Layout, NS);
246 }
247
dumpModuleInfos()248 void BytesOutputStyle::dumpModuleInfos() {
249 printHeader(P, "Module Infos");
250
251 AutoIndent Indent(P);
252
253 auto &DbiS = Err(File.getPDBDbiStream());
254 BinarySubstreamRef NS = DbiS.getModiSubstreamData();
255 auto Layout = File.getStreamLayout(StreamDBI);
256 P.formatMsfStreamData("Module Infos", File, Layout, NS);
257 }
258
dumpFileInfo()259 void BytesOutputStyle::dumpFileInfo() {
260 printHeader(P, "File Info");
261
262 AutoIndent Indent(P);
263
264 auto &DbiS = Err(File.getPDBDbiStream());
265 BinarySubstreamRef NS = DbiS.getFileInfoSubstreamData();
266 auto Layout = File.getStreamLayout(StreamDBI);
267 P.formatMsfStreamData("File Info", File, Layout, NS);
268 }
269
dumpTypeServerMap()270 void BytesOutputStyle::dumpTypeServerMap() {
271 printHeader(P, "Type Server Map");
272
273 AutoIndent Indent(P);
274
275 auto &DbiS = Err(File.getPDBDbiStream());
276 BinarySubstreamRef NS = DbiS.getTypeServerMapSubstreamData();
277 auto Layout = File.getStreamLayout(StreamDBI);
278 P.formatMsfStreamData("Type Server Map", File, Layout, NS);
279 }
280
dumpECData()281 void BytesOutputStyle::dumpECData() {
282 printHeader(P, "Edit and Continue Data");
283
284 AutoIndent Indent(P);
285
286 auto &DbiS = Err(File.getPDBDbiStream());
287 BinarySubstreamRef NS = DbiS.getECSubstreamData();
288 auto Layout = File.getStreamLayout(StreamDBI);
289 P.formatMsfStreamData("Edit and Continue Data", File, Layout, NS);
290 }
291
dumpTypeIndex(uint32_t StreamIdx,ArrayRef<uint32_t> Indices)292 void BytesOutputStyle::dumpTypeIndex(uint32_t StreamIdx,
293 ArrayRef<uint32_t> Indices) {
294 assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
295 assert(!Indices.empty());
296
297 bool IsTpi = (StreamIdx == StreamTPI);
298
299 StringRef Label = IsTpi ? "Type (TPI) Records" : "Index (IPI) Records";
300 printHeader(P, Label);
301 auto &Stream = Err(IsTpi ? File.getPDBTpiStream() : File.getPDBIpiStream());
302
303 AutoIndent Indent(P);
304
305 auto Substream = Stream.getTypeRecordsSubstream();
306 auto &Types = Err(initializeTypes(StreamIdx));
307 auto Layout = File.getStreamLayout(StreamIdx);
308 for (const auto &Id : Indices) {
309 TypeIndex TI(Id);
310 if (TI.toArrayIndex() >= Types.capacity()) {
311 P.formatLine("Error: TypeIndex {0} does not exist", TI);
312 continue;
313 }
314
315 auto Type = Types.getType(TI);
316 uint32_t Offset = Types.getOffsetOfType(TI);
317 auto OneType = Substream.slice(Offset, Type.length());
318 P.formatMsfStreamData(formatv("Type {0}", TI).str(), File, Layout, OneType);
319 }
320 }
321
322 template <typename CallbackT>
iterateOneModule(PDBFile & File,LinePrinter & P,const DbiModuleList & Modules,uint32_t I,uint32_t Digits,uint32_t IndentLevel,CallbackT Callback)323 static void iterateOneModule(PDBFile &File, LinePrinter &P,
324 const DbiModuleList &Modules, uint32_t I,
325 uint32_t Digits, uint32_t IndentLevel,
326 CallbackT Callback) {
327 if (I >= Modules.getModuleCount()) {
328 P.formatLine("Mod {0:4} | Invalid module index ",
329 fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)));
330 return;
331 }
332
333 auto Modi = Modules.getModuleDescriptor(I);
334 P.formatLine("Mod {0:4} | `{1}`: ",
335 fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)),
336 Modi.getModuleName());
337
338 uint16_t ModiStream = Modi.getModuleStreamIndex();
339 AutoIndent Indent2(P, IndentLevel);
340 if (ModiStream == kInvalidStreamIndex)
341 return;
342
343 auto ModStreamData = File.createIndexedStream(ModiStream);
344 ModuleDebugStreamRef ModStream(Modi, std::move(ModStreamData));
345 if (auto EC = ModStream.reload()) {
346 P.formatLine("Could not parse debug information.");
347 return;
348 }
349 auto Layout = File.getStreamLayout(ModiStream);
350 Callback(I, ModStream, Layout);
351 }
352
353 template <typename CallbackT>
iterateModules(PDBFile & File,LinePrinter & P,uint32_t IndentLevel,CallbackT Callback)354 static void iterateModules(PDBFile &File, LinePrinter &P, uint32_t IndentLevel,
355 CallbackT Callback) {
356 AutoIndent Indent(P);
357 if (!File.hasPDBDbiStream()) {
358 P.formatLine("DBI Stream not present");
359 return;
360 }
361
362 ExitOnError Err("Unexpected error processing modules");
363
364 auto &Stream = Err(File.getPDBDbiStream());
365
366 const DbiModuleList &Modules = Stream.modules();
367
368 if (opts::bytes::ModuleIndex.getNumOccurrences() > 0) {
369 iterateOneModule(File, P, Modules, opts::bytes::ModuleIndex, 1, IndentLevel,
370 Callback);
371 } else {
372 uint32_t Count = Modules.getModuleCount();
373 uint32_t Digits = NumDigits(Count);
374 for (uint32_t I = 0; I < Count; ++I) {
375 iterateOneModule(File, P, Modules, I, Digits, IndentLevel, Callback);
376 }
377 }
378 }
379
dumpModuleSyms()380 void BytesOutputStyle::dumpModuleSyms() {
381 printHeader(P, "Module Symbols");
382
383 AutoIndent Indent(P);
384
385 iterateModules(File, P, 2,
386 [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
387 const MSFStreamLayout &Layout) {
388 auto Symbols = Stream.getSymbolsSubstream();
389 P.formatMsfStreamData("Symbols", File, Layout, Symbols);
390 });
391 }
392
dumpModuleC11()393 void BytesOutputStyle::dumpModuleC11() {
394 printHeader(P, "C11 Debug Chunks");
395
396 AutoIndent Indent(P);
397
398 iterateModules(File, P, 2,
399 [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
400 const MSFStreamLayout &Layout) {
401 auto Chunks = Stream.getC11LinesSubstream();
402 P.formatMsfStreamData("C11 Debug Chunks", File, Layout,
403 Chunks);
404 });
405 }
406
dumpModuleC13()407 void BytesOutputStyle::dumpModuleC13() {
408 printHeader(P, "Debug Chunks");
409
410 AutoIndent Indent(P);
411
412 iterateModules(
413 File, P, 2,
414 [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
415 const MSFStreamLayout &Layout) {
416 auto Chunks = Stream.getC13LinesSubstream();
417 if (opts::bytes::SplitChunks) {
418 for (const auto &SS : Stream.subsections()) {
419 BinarySubstreamRef ThisChunk;
420 std::tie(ThisChunk, Chunks) = Chunks.split(SS.getRecordLength());
421 P.formatMsfStreamData(formatChunkKind(SS.kind()), File, Layout,
422 ThisChunk);
423 }
424 } else {
425 P.formatMsfStreamData("Debug Chunks", File, Layout, Chunks);
426 }
427 });
428 }
429
dumpByteRanges(uint32_t Min,uint32_t Max)430 void BytesOutputStyle::dumpByteRanges(uint32_t Min, uint32_t Max) {
431 printHeader(P, "MSF Bytes");
432
433 AutoIndent Indent(P);
434
435 BinaryStreamReader Reader(File.getMsfBuffer());
436 ArrayRef<uint8_t> Data;
437 consumeError(Reader.skip(Min));
438 uint32_t Size = Max - Min + 1;
439 auto EC = Reader.readBytes(Data, Size);
440 assert(!EC);
441 consumeError(std::move(EC));
442 P.formatBinary("Bytes", Data, Min);
443 }
444
445 Expected<codeview::LazyRandomTypeCollection &>
initializeTypes(uint32_t StreamIdx)446 BytesOutputStyle::initializeTypes(uint32_t StreamIdx) {
447 auto &TypeCollection = (StreamIdx == StreamTPI) ? TpiTypes : IpiTypes;
448 if (TypeCollection)
449 return *TypeCollection;
450
451 auto Tpi = (StreamIdx == StreamTPI) ? File.getPDBTpiStream()
452 : File.getPDBIpiStream();
453 if (!Tpi)
454 return Tpi.takeError();
455
456 auto &Types = Tpi->typeArray();
457 uint32_t Count = Tpi->getNumTypeRecords();
458 auto Offsets = Tpi->getTypeIndexOffsets();
459 TypeCollection =
460 std::make_unique<LazyRandomTypeCollection>(Types, Count, Offsets);
461
462 return *TypeCollection;
463 }
464
dumpFpm()465 void BytesOutputStyle::dumpFpm() {
466 printHeader(P, "Free Page Map");
467
468 msf::MSFStreamLayout FpmLayout = File.getFpmStreamLayout();
469 P.formatMsfStreamBlocks(File, FpmLayout);
470 }
471
dumpStreamBytes()472 void BytesOutputStyle::dumpStreamBytes() {
473 if (StreamPurposes.empty())
474 discoverStreamPurposes(File, StreamPurposes);
475
476 printHeader(P, "Stream Data");
477 ExitOnError Err("Unexpected error reading stream data");
478
479 auto Specs = parseStreamSpecs(P);
480
481 for (const auto &Spec : Specs) {
482 AutoIndent Indent(P);
483 if (Spec.SI >= StreamPurposes.size()) {
484 P.formatLine("Stream {0}: Not present", Spec.SI);
485 continue;
486 }
487 P.formatMsfStreamData("Data", File, Spec.SI,
488 StreamPurposes[Spec.SI].getShortName(), Spec.Begin,
489 Spec.Size);
490 }
491 }
492