1 //===- LLVMOutputStyle.cpp ------------------------------------ *- C++ --*-===//
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 "LLVMOutputStyle.h"
11
12 #include "llvm-pdbdump.h"
13 #include "llvm/DebugInfo/CodeView/EnumTables.h"
14 #include "llvm/DebugInfo/CodeView/ModuleSubstreamVisitor.h"
15 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
16 #include "llvm/DebugInfo/PDB/PDBExtras.h"
17 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
18 #include "llvm/DebugInfo/PDB/Raw/EnumTables.h"
19 #include "llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h"
20 #include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
21 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
22 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
23 #include "llvm/DebugInfo/PDB/Raw/ModStream.h"
24 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
25 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
26 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
27 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
28 #include "llvm/Object/COFF.h"
29
30 #include <unordered_map>
31
32 using namespace llvm;
33 using namespace llvm::codeview;
34 using namespace llvm::pdb;
35
printSectionOffset(llvm::raw_ostream & OS,const SectionOffset & Off)36 static void printSectionOffset(llvm::raw_ostream &OS,
37 const SectionOffset &Off) {
38 OS << Off.Off << ", " << Off.Isect;
39 }
40
LLVMOutputStyle(PDBFile & File)41 LLVMOutputStyle::LLVMOutputStyle(PDBFile &File)
42 : File(File), P(outs()), TD(&P, false) {}
43
dump()44 Error LLVMOutputStyle::dump() {
45 if (auto EC = dumpFileHeaders())
46 return EC;
47
48 if (auto EC = dumpStreamSummary())
49 return EC;
50
51 if (auto EC = dumpStreamBlocks())
52 return EC;
53
54 if (auto EC = dumpStreamData())
55 return EC;
56
57 if (auto EC = dumpInfoStream())
58 return EC;
59
60 if (auto EC = dumpNamedStream())
61 return EC;
62
63 if (auto EC = dumpTpiStream(StreamTPI))
64 return EC;
65
66 if (auto EC = dumpTpiStream(StreamIPI))
67 return EC;
68
69 if (auto EC = dumpDbiStream())
70 return EC;
71
72 if (auto EC = dumpSectionContribs())
73 return EC;
74
75 if (auto EC = dumpSectionMap())
76 return EC;
77
78 if (auto EC = dumpPublicsStream())
79 return EC;
80
81 if (auto EC = dumpSectionHeaders())
82 return EC;
83
84 if (auto EC = dumpFpoStream())
85 return EC;
86
87 flush();
88
89 return Error::success();
90 }
91
dumpFileHeaders()92 Error LLVMOutputStyle::dumpFileHeaders() {
93 if (!opts::raw::DumpHeaders)
94 return Error::success();
95
96 DictScope D(P, "FileHeaders");
97 P.printNumber("BlockSize", File.getBlockSize());
98 P.printNumber("Unknown0", File.getUnknown0());
99 P.printNumber("NumBlocks", File.getBlockCount());
100 P.printNumber("NumDirectoryBytes", File.getNumDirectoryBytes());
101 P.printNumber("Unknown1", File.getUnknown1());
102 P.printNumber("BlockMapAddr", File.getBlockMapIndex());
103 P.printNumber("NumDirectoryBlocks", File.getNumDirectoryBlocks());
104 P.printNumber("BlockMapOffset", File.getBlockMapOffset());
105
106 // The directory is not contiguous. Instead, the block map contains a
107 // contiguous list of block numbers whose contents, when concatenated in
108 // order, make up the directory.
109 P.printList("DirectoryBlocks", File.getDirectoryBlockArray());
110 P.printNumber("NumStreams", File.getNumStreams());
111 return Error::success();
112 }
113
dumpStreamSummary()114 Error LLVMOutputStyle::dumpStreamSummary() {
115 if (!opts::raw::DumpStreamSummary)
116 return Error::success();
117
118 // It's OK if we fail to load some of these streams, we still attempt to print
119 // what we can.
120 auto Dbi = File.getPDBDbiStream();
121 auto Tpi = File.getPDBTpiStream();
122 auto Ipi = File.getPDBIpiStream();
123 auto Info = File.getPDBInfoStream();
124
125 ListScope L(P, "Streams");
126 uint32_t StreamCount = File.getNumStreams();
127 std::unordered_map<uint16_t, const ModuleInfoEx *> ModStreams;
128 std::unordered_map<uint16_t, std::string> NamedStreams;
129
130 if (Dbi) {
131 for (auto &ModI : Dbi->modules()) {
132 uint16_t SN = ModI.Info.getModuleStreamIndex();
133 ModStreams[SN] = &ModI;
134 }
135 }
136 if (Info) {
137 for (auto &NSE : Info->named_streams()) {
138 NamedStreams[NSE.second] = NSE.first();
139 }
140 }
141
142 for (uint16_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
143 std::string Label("Stream ");
144 Label += to_string(StreamIdx);
145 std::string Value;
146 if (StreamIdx == OldMSFDirectory)
147 Value = "Old MSF Directory";
148 else if (StreamIdx == StreamPDB)
149 Value = "PDB Stream";
150 else if (StreamIdx == StreamDBI)
151 Value = "DBI Stream";
152 else if (StreamIdx == StreamTPI)
153 Value = "TPI Stream";
154 else if (StreamIdx == StreamIPI)
155 Value = "IPI Stream";
156 else if (Dbi && StreamIdx == Dbi->getGlobalSymbolStreamIndex())
157 Value = "Global Symbol Hash";
158 else if (Dbi && StreamIdx == Dbi->getPublicSymbolStreamIndex())
159 Value = "Public Symbol Hash";
160 else if (Dbi && StreamIdx == Dbi->getSymRecordStreamIndex())
161 Value = "Public Symbol Records";
162 else if (Tpi && StreamIdx == Tpi->getTypeHashStreamIndex())
163 Value = "TPI Hash";
164 else if (Tpi && StreamIdx == Tpi->getTypeHashStreamAuxIndex())
165 Value = "TPI Aux Hash";
166 else if (Ipi && StreamIdx == Ipi->getTypeHashStreamIndex())
167 Value = "IPI Hash";
168 else if (Ipi && StreamIdx == Ipi->getTypeHashStreamAuxIndex())
169 Value = "IPI Aux Hash";
170 else if (Dbi &&
171 StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Exception))
172 Value = "Exception Data";
173 else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Fixup))
174 Value = "Fixup Data";
175 else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::FPO))
176 Value = "FPO Data";
177 else if (Dbi &&
178 StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::NewFPO))
179 Value = "New FPO Data";
180 else if (Dbi &&
181 StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::OmapFromSrc))
182 Value = "Omap From Source Data";
183 else if (Dbi &&
184 StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::OmapToSrc))
185 Value = "Omap To Source Data";
186 else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Pdata))
187 Value = "Pdata";
188 else if (Dbi &&
189 StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::SectionHdr))
190 Value = "Section Header Data";
191 else if (Dbi &&
192 StreamIdx ==
193 Dbi->getDebugStreamIndex(DbgHeaderType::SectionHdrOrig))
194 Value = "Section Header Original Data";
195 else if (Dbi &&
196 StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::TokenRidMap))
197 Value = "Token Rid Data";
198 else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Xdata))
199 Value = "Xdata";
200 else {
201 auto ModIter = ModStreams.find(StreamIdx);
202 auto NSIter = NamedStreams.find(StreamIdx);
203 if (ModIter != ModStreams.end()) {
204 Value = "Module \"";
205 Value += ModIter->second->Info.getModuleName().str();
206 Value += "\"";
207 } else if (NSIter != NamedStreams.end()) {
208 Value = "Named Stream \"";
209 Value += NSIter->second;
210 Value += "\"";
211 } else {
212 Value = "???";
213 }
214 }
215 Value = "[" + Value + "]";
216 Value =
217 Value + " (" + to_string(File.getStreamByteSize(StreamIdx)) + " bytes)";
218
219 P.printString(Label, Value);
220 }
221
222 // Consume errors from missing streams.
223 if (!Dbi)
224 consumeError(Dbi.takeError());
225 if (!Tpi)
226 consumeError(Tpi.takeError());
227 if (!Ipi)
228 consumeError(Ipi.takeError());
229 if (!Info)
230 consumeError(Info.takeError());
231
232 P.flush();
233 return Error::success();
234 }
235
dumpStreamBlocks()236 Error LLVMOutputStyle::dumpStreamBlocks() {
237 if (!opts::raw::DumpStreamBlocks)
238 return Error::success();
239
240 ListScope L(P, "StreamBlocks");
241 uint32_t StreamCount = File.getNumStreams();
242 for (uint32_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
243 std::string Name("Stream ");
244 Name += to_string(StreamIdx);
245 auto StreamBlocks = File.getStreamBlockList(StreamIdx);
246 P.printList(Name, StreamBlocks);
247 }
248 return Error::success();
249 }
250
dumpStreamData()251 Error LLVMOutputStyle::dumpStreamData() {
252 uint32_t StreamCount = File.getNumStreams();
253 StringRef DumpStreamStr = opts::raw::DumpStreamDataIdx;
254 uint32_t DumpStreamNum;
255 if (DumpStreamStr.getAsInteger(/*Radix=*/0U, DumpStreamNum))
256 return Error::success();
257
258 if (DumpStreamNum >= StreamCount)
259 return make_error<RawError>(raw_error_code::no_stream);
260
261 auto S = MappedBlockStream::createIndexedStream(DumpStreamNum, File);
262 if (!S)
263 return S.takeError();
264 codeview::StreamReader R(**S);
265 while (R.bytesRemaining() > 0) {
266 ArrayRef<uint8_t> Data;
267 uint32_t BytesToReadInBlock = std::min(
268 R.bytesRemaining(), static_cast<uint32_t>(File.getBlockSize()));
269 if (auto EC = R.readBytes(Data, BytesToReadInBlock))
270 return EC;
271 P.printBinaryBlock(
272 "Data",
273 StringRef(reinterpret_cast<const char *>(Data.begin()), Data.size()));
274 }
275 return Error::success();
276 }
277
dumpInfoStream()278 Error LLVMOutputStyle::dumpInfoStream() {
279 if (!opts::raw::DumpHeaders)
280 return Error::success();
281 auto IS = File.getPDBInfoStream();
282 if (!IS)
283 return IS.takeError();
284
285 DictScope D(P, "PDB Stream");
286 P.printNumber("Version", IS->getVersion());
287 P.printHex("Signature", IS->getSignature());
288 P.printNumber("Age", IS->getAge());
289 P.printObject("Guid", IS->getGuid());
290 return Error::success();
291 }
292
dumpNamedStream()293 Error LLVMOutputStyle::dumpNamedStream() {
294 if (opts::raw::DumpStreamDataName.empty())
295 return Error::success();
296
297 auto IS = File.getPDBInfoStream();
298 if (!IS)
299 return IS.takeError();
300
301 uint32_t NameStreamIndex =
302 IS->getNamedStreamIndex(opts::raw::DumpStreamDataName);
303 if (NameStreamIndex == 0 || NameStreamIndex >= File.getNumStreams())
304 return make_error<RawError>(raw_error_code::no_stream);
305
306 if (NameStreamIndex != 0) {
307 std::string Name("Stream '");
308 Name += opts::raw::DumpStreamDataName;
309 Name += "'";
310 DictScope D(P, Name);
311 P.printNumber("Index", NameStreamIndex);
312
313 auto NameStream =
314 MappedBlockStream::createIndexedStream(NameStreamIndex, File);
315 if (!NameStream)
316 return NameStream.takeError();
317 codeview::StreamReader Reader(**NameStream);
318
319 NameHashTable NameTable;
320 if (auto EC = NameTable.load(Reader))
321 return EC;
322
323 P.printHex("Signature", NameTable.getSignature());
324 P.printNumber("Version", NameTable.getHashVersion());
325 P.printNumber("Name Count", NameTable.getNameCount());
326 ListScope L(P, "Names");
327 for (uint32_t ID : NameTable.name_ids()) {
328 StringRef Str = NameTable.getStringForID(ID);
329 if (!Str.empty())
330 P.printString(to_string(ID), Str);
331 }
332 }
333 return Error::success();
334 }
335
printTypeIndexOffset(raw_ostream & OS,const TypeIndexOffset & TIOff)336 static void printTypeIndexOffset(raw_ostream &OS,
337 const TypeIndexOffset &TIOff) {
338 OS << "{" << TIOff.Type.getIndex() << ", " << TIOff.Offset << "}";
339 }
340
dumpTpiHash(ScopedPrinter & P,TpiStream & Tpi)341 static void dumpTpiHash(ScopedPrinter &P, TpiStream &Tpi) {
342 if (!opts::raw::DumpTpiHash)
343 return;
344 DictScope DD(P, "Hash");
345 P.printNumber("Number of Hash Buckets", Tpi.NumHashBuckets());
346 P.printNumber("Hash Key Size", Tpi.getHashKeySize());
347 P.printList("Values", Tpi.getHashValues());
348 P.printList("Type Index Offsets", Tpi.getTypeIndexOffsets(),
349 printTypeIndexOffset);
350 P.printList("Hash Adjustments", Tpi.getHashAdjustments(),
351 printTypeIndexOffset);
352 }
353
dumpTpiStream(uint32_t StreamIdx)354 Error LLVMOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
355 assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
356
357 bool DumpRecordBytes = false;
358 bool DumpRecords = false;
359 StringRef Label;
360 StringRef VerLabel;
361 if (StreamIdx == StreamTPI) {
362 DumpRecordBytes = opts::raw::DumpTpiRecordBytes;
363 DumpRecords = opts::raw::DumpTpiRecords;
364 Label = "Type Info Stream (TPI)";
365 VerLabel = "TPI Version";
366 } else if (StreamIdx == StreamIPI) {
367 DumpRecordBytes = opts::raw::DumpIpiRecordBytes;
368 DumpRecords = opts::raw::DumpIpiRecords;
369 Label = "Type Info Stream (IPI)";
370 VerLabel = "IPI Version";
371 }
372 if (!DumpRecordBytes && !DumpRecords && !opts::raw::DumpModuleSyms)
373 return Error::success();
374
375 auto Tpi = (StreamIdx == StreamTPI) ? File.getPDBTpiStream()
376 : File.getPDBIpiStream();
377 if (!Tpi)
378 return Tpi.takeError();
379
380 if (DumpRecords || DumpRecordBytes) {
381 DictScope D(P, Label);
382
383 P.printNumber(VerLabel, Tpi->getTpiVersion());
384 P.printNumber("Record count", Tpi->NumTypeRecords());
385
386 ListScope L(P, "Records");
387
388 bool HadError = false;
389 for (auto &Type : Tpi->types(&HadError)) {
390 DictScope DD(P, "");
391
392 if (DumpRecords) {
393 if (auto EC = TD.dump(Type))
394 return EC;
395 }
396
397 if (DumpRecordBytes)
398 P.printBinaryBlock("Bytes", Type.Data);
399 }
400 dumpTpiHash(P, *Tpi);
401 if (HadError)
402 return make_error<RawError>(raw_error_code::corrupt_file,
403 "TPI stream contained corrupt record");
404 } else if (opts::raw::DumpModuleSyms) {
405 // Even if the user doesn't want to dump type records, we still need to
406 // iterate them in order to build the list of types so that we can print
407 // them when dumping module symbols. So when they want to dump symbols
408 // but not types, use a null output stream.
409 ScopedPrinter *OldP = TD.getPrinter();
410 TD.setPrinter(nullptr);
411
412 bool HadError = false;
413 for (auto &Type : Tpi->types(&HadError)) {
414 if (auto EC = TD.dump(Type))
415 return EC;
416 }
417
418 TD.setPrinter(OldP);
419 dumpTpiHash(P, *Tpi);
420 if (HadError)
421 return make_error<RawError>(raw_error_code::corrupt_file,
422 "TPI stream contained corrupt record");
423 }
424 P.flush();
425 return Error::success();
426 }
427
dumpDbiStream()428 Error LLVMOutputStyle::dumpDbiStream() {
429 bool DumpModules = opts::raw::DumpModules || opts::raw::DumpModuleSyms ||
430 opts::raw::DumpModuleFiles || opts::raw::DumpLineInfo;
431 if (!opts::raw::DumpHeaders && !DumpModules)
432 return Error::success();
433
434 auto DS = File.getPDBDbiStream();
435 if (!DS)
436 return DS.takeError();
437
438 DictScope D(P, "DBI Stream");
439 P.printNumber("Dbi Version", DS->getDbiVersion());
440 P.printNumber("Age", DS->getAge());
441 P.printBoolean("Incremental Linking", DS->isIncrementallyLinked());
442 P.printBoolean("Has CTypes", DS->hasCTypes());
443 P.printBoolean("Is Stripped", DS->isStripped());
444 P.printObject("Machine Type", DS->getMachineType());
445 P.printNumber("Symbol Record Stream Index", DS->getSymRecordStreamIndex());
446 P.printNumber("Public Symbol Stream Index", DS->getPublicSymbolStreamIndex());
447 P.printNumber("Global Symbol Stream Index", DS->getGlobalSymbolStreamIndex());
448
449 uint16_t Major = DS->getBuildMajorVersion();
450 uint16_t Minor = DS->getBuildMinorVersion();
451 P.printVersion("Toolchain Version", Major, Minor);
452
453 std::string DllName;
454 raw_string_ostream DllStream(DllName);
455 DllStream << "mspdb" << Major << Minor << ".dll version";
456 DllStream.flush();
457 P.printVersion(DllName, Major, Minor, DS->getPdbDllVersion());
458
459 if (DumpModules) {
460 ListScope L(P, "Modules");
461 for (auto &Modi : DS->modules()) {
462 DictScope DD(P);
463 P.printString("Name", Modi.Info.getModuleName().str());
464 P.printNumber("Debug Stream Index", Modi.Info.getModuleStreamIndex());
465 P.printString("Object File Name", Modi.Info.getObjFileName().str());
466 P.printNumber("Num Files", Modi.Info.getNumberOfFiles());
467 P.printNumber("Source File Name Idx", Modi.Info.getSourceFileNameIndex());
468 P.printNumber("Pdb File Name Idx", Modi.Info.getPdbFilePathNameIndex());
469 P.printNumber("Line Info Byte Size", Modi.Info.getLineInfoByteSize());
470 P.printNumber("C13 Line Info Byte Size",
471 Modi.Info.getC13LineInfoByteSize());
472 P.printNumber("Symbol Byte Size", Modi.Info.getSymbolDebugInfoByteSize());
473 P.printNumber("Type Server Index", Modi.Info.getTypeServerIndex());
474 P.printBoolean("Has EC Info", Modi.Info.hasECInfo());
475 if (opts::raw::DumpModuleFiles) {
476 std::string FileListName =
477 to_string(Modi.SourceFiles.size()) + " Contributing Source Files";
478 ListScope LL(P, FileListName);
479 for (auto File : Modi.SourceFiles)
480 P.printString(File.str());
481 }
482 bool HasModuleDI =
483 (Modi.Info.getModuleStreamIndex() < File.getNumStreams());
484 bool ShouldDumpSymbols =
485 (opts::raw::DumpModuleSyms || opts::raw::DumpSymRecordBytes);
486 if (HasModuleDI && (ShouldDumpSymbols || opts::raw::DumpLineInfo)) {
487 auto ModStreamData = MappedBlockStream::createIndexedStream(
488 Modi.Info.getModuleStreamIndex(), File);
489 if (!ModStreamData)
490 return ModStreamData.takeError();
491 ModStream ModS(Modi.Info, std::move(*ModStreamData));
492 if (auto EC = ModS.reload())
493 return EC;
494
495 if (ShouldDumpSymbols) {
496 ListScope SS(P, "Symbols");
497 codeview::CVSymbolDumper SD(P, TD, nullptr, false);
498 bool HadError = false;
499 for (const auto &S : ModS.symbols(&HadError)) {
500 DictScope DD(P, "");
501
502 if (opts::raw::DumpModuleSyms)
503 SD.dump(S);
504 if (opts::raw::DumpSymRecordBytes)
505 P.printBinaryBlock("Bytes", S.Data);
506 }
507 if (HadError)
508 return make_error<RawError>(
509 raw_error_code::corrupt_file,
510 "DBI stream contained corrupt symbol record");
511 }
512 if (opts::raw::DumpLineInfo) {
513 ListScope SS(P, "LineInfo");
514 bool HadError = false;
515 // Define a locally scoped visitor to print the different
516 // substream types types.
517 class RecordVisitor : public codeview::IModuleSubstreamVisitor {
518 public:
519 RecordVisitor(ScopedPrinter &P, PDBFile &F) : P(P), F(F) {}
520 Error visitUnknown(ModuleSubstreamKind Kind,
521 StreamRef Stream) override {
522 DictScope DD(P, "Unknown");
523 ArrayRef<uint8_t> Data;
524 StreamReader R(Stream);
525 if (auto EC = R.readBytes(Data, R.bytesRemaining())) {
526 return make_error<RawError>(
527 raw_error_code::corrupt_file,
528 "DBI stream contained corrupt line info record");
529 }
530 P.printBinaryBlock("Data", Data);
531 return Error::success();
532 }
533 Error
534 visitFileChecksums(StreamRef Data,
535 const FileChecksumArray &Checksums) override {
536 DictScope DD(P, "FileChecksums");
537 for (const auto &C : Checksums) {
538 DictScope DDD(P, "Checksum");
539 if (auto Result = getFileNameForOffset(C.FileNameOffset))
540 P.printString("FileName", Result.get());
541 else
542 return Result.takeError();
543 P.flush();
544 P.printEnum("Kind", uint8_t(C.Kind), getFileChecksumNames());
545 P.printBinaryBlock("Checksum", C.Checksum);
546 }
547 return Error::success();
548 }
549
550 Error visitLines(StreamRef Data, const LineSubstreamHeader *Header,
551 const LineInfoArray &Lines) override {
552 DictScope DD(P, "Lines");
553 for (const auto &L : Lines) {
554 if (auto Result = getFileNameForOffset2(L.NameIndex))
555 P.printString("FileName", Result.get());
556 else
557 return Result.takeError();
558 P.flush();
559 for (const auto &N : L.LineNumbers) {
560 DictScope DDD(P, "Line");
561 LineInfo LI(N.Flags);
562 P.printNumber("Offset", N.Offset);
563 if (LI.isAlwaysStepInto())
564 P.printString("StepInto", StringRef("Always"));
565 else if (LI.isNeverStepInto())
566 P.printString("StepInto", StringRef("Never"));
567 else
568 P.printNumber("LineNumberStart", LI.getStartLine());
569 P.printNumber("EndDelta", LI.getLineDelta());
570 P.printBoolean("IsStatement", LI.isStatement());
571 }
572 for (const auto &C : L.Columns) {
573 DictScope DDD(P, "Column");
574 P.printNumber("Start", C.StartColumn);
575 P.printNumber("End", C.EndColumn);
576 }
577 }
578 return Error::success();
579 }
580
581 private:
582 Expected<StringRef> getFileNameForOffset(uint32_t Offset) {
583 auto ST = F.getStringTable();
584 if (!ST)
585 return ST.takeError();
586
587 return ST->getStringForID(Offset);
588 }
589 Expected<StringRef> getFileNameForOffset2(uint32_t Offset) {
590 auto DS = F.getPDBDbiStream();
591 if (!DS)
592 return DS.takeError();
593 return DS->getFileNameForIndex(Offset);
594 }
595 ScopedPrinter &P;
596 PDBFile &F;
597 };
598
599 RecordVisitor V(P, File);
600 for (const auto &L : ModS.lines(&HadError)) {
601 if (auto EC = codeview::visitModuleSubstream(L, V))
602 return EC;
603 }
604 }
605 }
606 }
607 }
608 return Error::success();
609 }
610
dumpSectionContribs()611 Error LLVMOutputStyle::dumpSectionContribs() {
612 if (!opts::raw::DumpSectionContribs)
613 return Error::success();
614
615 auto Dbi = File.getPDBDbiStream();
616 if (!Dbi)
617 return Dbi.takeError();
618
619 ListScope L(P, "Section Contributions");
620 class Visitor : public ISectionContribVisitor {
621 public:
622 Visitor(ScopedPrinter &P, DbiStream &DS) : P(P), DS(DS) {}
623 void visit(const SectionContrib &SC) override {
624 DictScope D(P, "Contribution");
625 P.printNumber("ISect", SC.ISect);
626 P.printNumber("Off", SC.Off);
627 P.printNumber("Size", SC.Size);
628 P.printFlags("Characteristics", SC.Characteristics,
629 codeview::getImageSectionCharacteristicNames(),
630 COFF::SectionCharacteristics(0x00F00000));
631 {
632 DictScope DD(P, "Module");
633 P.printNumber("Index", SC.Imod);
634 auto M = DS.modules();
635 if (M.size() > SC.Imod) {
636 P.printString("Name", M[SC.Imod].Info.getModuleName());
637 }
638 }
639 P.printNumber("Data CRC", SC.DataCrc);
640 P.printNumber("Reloc CRC", SC.RelocCrc);
641 P.flush();
642 }
643 void visit(const SectionContrib2 &SC) override {
644 visit(SC.Base);
645 P.printNumber("ISect Coff", SC.ISectCoff);
646 P.flush();
647 }
648
649 private:
650 ScopedPrinter &P;
651 DbiStream &DS;
652 };
653 Visitor V(P, *Dbi);
654 Dbi->visitSectionContributions(V);
655 return Error::success();
656 }
657
dumpSectionMap()658 Error LLVMOutputStyle::dumpSectionMap() {
659 if (!opts::raw::DumpSectionMap)
660 return Error::success();
661
662 auto Dbi = File.getPDBDbiStream();
663 if (!Dbi)
664 return Dbi.takeError();
665
666 ListScope L(P, "Section Map");
667 for (auto &M : Dbi->getSectionMap()) {
668 DictScope D(P, "Entry");
669 P.printFlags("Flags", M.Flags, getOMFSegMapDescFlagNames());
670 P.printNumber("Flags", M.Flags);
671 P.printNumber("Ovl", M.Ovl);
672 P.printNumber("Group", M.Group);
673 P.printNumber("Frame", M.Frame);
674 P.printNumber("SecName", M.SecName);
675 P.printNumber("ClassName", M.ClassName);
676 P.printNumber("Offset", M.Offset);
677 P.printNumber("SecByteLength", M.SecByteLength);
678 P.flush();
679 }
680 return Error::success();
681 }
682
dumpPublicsStream()683 Error LLVMOutputStyle::dumpPublicsStream() {
684 if (!opts::raw::DumpPublics)
685 return Error::success();
686
687 DictScope D(P, "Publics Stream");
688 auto Publics = File.getPDBPublicsStream();
689 if (!Publics)
690 return Publics.takeError();
691
692 auto Dbi = File.getPDBDbiStream();
693 if (!Dbi)
694 return Dbi.takeError();
695
696 P.printNumber("Stream number", Dbi->getPublicSymbolStreamIndex());
697 P.printNumber("SymHash", Publics->getSymHash());
698 P.printNumber("AddrMap", Publics->getAddrMap());
699 P.printNumber("Number of buckets", Publics->getNumBuckets());
700 P.printList("Hash Buckets", Publics->getHashBuckets());
701 P.printList("Address Map", Publics->getAddressMap());
702 P.printList("Thunk Map", Publics->getThunkMap());
703 P.printList("Section Offsets", Publics->getSectionOffsets(),
704 printSectionOffset);
705 ListScope L(P, "Symbols");
706 codeview::CVSymbolDumper SD(P, TD, nullptr, false);
707 bool HadError = false;
708 for (auto S : Publics->getSymbols(&HadError)) {
709 DictScope DD(P, "");
710
711 SD.dump(S);
712 if (opts::raw::DumpSymRecordBytes)
713 P.printBinaryBlock("Bytes", S.Data);
714 }
715 if (HadError)
716 return make_error<RawError>(
717 raw_error_code::corrupt_file,
718 "Public symbol stream contained corrupt record");
719
720 return Error::success();
721 }
722
dumpSectionHeaders()723 Error LLVMOutputStyle::dumpSectionHeaders() {
724 if (!opts::raw::DumpSectionHeaders)
725 return Error::success();
726
727 auto Dbi = File.getPDBDbiStream();
728 if (!Dbi)
729 return Dbi.takeError();
730
731 ListScope D(P, "Section Headers");
732 for (const object::coff_section &Section : Dbi->getSectionHeaders()) {
733 DictScope DD(P, "");
734
735 // If a name is 8 characters long, there is no NUL character at end.
736 StringRef Name(Section.Name, strnlen(Section.Name, sizeof(Section.Name)));
737 P.printString("Name", Name);
738 P.printNumber("Virtual Size", Section.VirtualSize);
739 P.printNumber("Virtual Address", Section.VirtualAddress);
740 P.printNumber("Size of Raw Data", Section.SizeOfRawData);
741 P.printNumber("File Pointer to Raw Data", Section.PointerToRawData);
742 P.printNumber("File Pointer to Relocations", Section.PointerToRelocations);
743 P.printNumber("File Pointer to Linenumbers", Section.PointerToLinenumbers);
744 P.printNumber("Number of Relocations", Section.NumberOfRelocations);
745 P.printNumber("Number of Linenumbers", Section.NumberOfLinenumbers);
746 P.printFlags("Characteristics", Section.Characteristics,
747 getImageSectionCharacteristicNames());
748 }
749 return Error::success();
750 }
751
dumpFpoStream()752 Error LLVMOutputStyle::dumpFpoStream() {
753 if (!opts::raw::DumpFpo)
754 return Error::success();
755
756 auto Dbi = File.getPDBDbiStream();
757 if (!Dbi)
758 return Dbi.takeError();
759
760 ListScope D(P, "New FPO");
761 for (const object::FpoData &Fpo : Dbi->getFpoRecords()) {
762 DictScope DD(P, "");
763 P.printNumber("Offset", Fpo.Offset);
764 P.printNumber("Size", Fpo.Size);
765 P.printNumber("Number of locals", Fpo.NumLocals);
766 P.printNumber("Number of params", Fpo.NumParams);
767 P.printNumber("Size of Prolog", Fpo.getPrologSize());
768 P.printNumber("Number of Saved Registers", Fpo.getNumSavedRegs());
769 P.printBoolean("Has SEH", Fpo.hasSEH());
770 P.printBoolean("Use BP", Fpo.useBP());
771 P.printNumber("Frame Pointer", Fpo.getFP());
772 }
773 return Error::success();
774 }
775
flush()776 void LLVMOutputStyle::flush() { P.flush(); }
777