109467b48Spatrick //===- DumpOutputStyle.cpp ------------------------------------ *- C++ --*-===//
209467b48Spatrick //
309467b48Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
409467b48Spatrick // See https://llvm.org/LICENSE.txt for license information.
509467b48Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
609467b48Spatrick //
709467b48Spatrick //===----------------------------------------------------------------------===//
809467b48Spatrick
909467b48Spatrick #include "DumpOutputStyle.h"
1009467b48Spatrick
1109467b48Spatrick #include "MinimalSymbolDumper.h"
1209467b48Spatrick #include "MinimalTypeDumper.h"
1309467b48Spatrick #include "StreamUtil.h"
1409467b48Spatrick #include "TypeReferenceTracker.h"
1509467b48Spatrick #include "llvm-pdbutil.h"
1609467b48Spatrick
1709467b48Spatrick #include "llvm/ADT/STLExtras.h"
1809467b48Spatrick #include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
1909467b48Spatrick #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
2009467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
2109467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugCrossExSubsection.h"
2209467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugCrossImpSubsection.h"
2309467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
2409467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
2509467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
2609467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
2709467b48Spatrick #include "llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h"
2809467b48Spatrick #include "llvm/DebugInfo/CodeView/Formatters.h"
2909467b48Spatrick #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
3009467b48Spatrick #include "llvm/DebugInfo/CodeView/Line.h"
3109467b48Spatrick #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
3209467b48Spatrick #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
3309467b48Spatrick #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
3409467b48Spatrick #include "llvm/DebugInfo/CodeView/TypeHashing.h"
3509467b48Spatrick #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
3609467b48Spatrick #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
3709467b48Spatrick #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
3809467b48Spatrick #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
39*d415bd75Srobert #include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
4009467b48Spatrick #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
4109467b48Spatrick #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
4209467b48Spatrick #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
43*d415bd75Srobert #include "llvm/DebugInfo/PDB/Native/InputFile.h"
4409467b48Spatrick #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
45*d415bd75Srobert #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
4609467b48Spatrick #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
4709467b48Spatrick #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
4809467b48Spatrick #include "llvm/DebugInfo/PDB/Native/RawError.h"
4909467b48Spatrick #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
5009467b48Spatrick #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
5109467b48Spatrick #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
5209467b48Spatrick #include "llvm/Object/COFF.h"
5309467b48Spatrick #include "llvm/Support/BinaryStreamReader.h"
5409467b48Spatrick #include "llvm/Support/FormatAdapters.h"
5509467b48Spatrick #include "llvm/Support/FormatVariadic.h"
5609467b48Spatrick
5709467b48Spatrick #include <cctype>
5809467b48Spatrick
5909467b48Spatrick using namespace llvm;
6009467b48Spatrick using namespace llvm::codeview;
6109467b48Spatrick using namespace llvm::msf;
6209467b48Spatrick using namespace llvm::pdb;
6309467b48Spatrick
DumpOutputStyle(InputFile & File)6409467b48Spatrick DumpOutputStyle::DumpOutputStyle(InputFile &File)
65*d415bd75Srobert : File(File), P(2, false, outs(), opts::Filters) {
6609467b48Spatrick if (opts::dump::DumpTypeRefStats)
6709467b48Spatrick RefTracker.reset(new TypeReferenceTracker(File));
6809467b48Spatrick }
6909467b48Spatrick
~DumpOutputStyle()7009467b48Spatrick DumpOutputStyle::~DumpOutputStyle() {}
7109467b48Spatrick
getPdb()7209467b48Spatrick PDBFile &DumpOutputStyle::getPdb() { return File.pdb(); }
getObj()7309467b48Spatrick object::COFFObjectFile &DumpOutputStyle::getObj() { return File.obj(); }
7409467b48Spatrick
printStreamNotValidForObj()7509467b48Spatrick void DumpOutputStyle::printStreamNotValidForObj() {
7609467b48Spatrick AutoIndent Indent(P, 4);
7709467b48Spatrick P.formatLine("Dumping this stream is not valid for object files");
7809467b48Spatrick }
7909467b48Spatrick
printStreamNotPresent(StringRef StreamName)8009467b48Spatrick void DumpOutputStyle::printStreamNotPresent(StringRef StreamName) {
8109467b48Spatrick AutoIndent Indent(P, 4);
8209467b48Spatrick P.formatLine("{0} stream not present", StreamName);
8309467b48Spatrick }
8409467b48Spatrick
dump()8509467b48Spatrick Error DumpOutputStyle::dump() {
8609467b48Spatrick // Walk symbols & globals if we are supposed to mark types referenced.
8709467b48Spatrick if (opts::dump::DumpTypeRefStats)
8809467b48Spatrick RefTracker->mark();
8909467b48Spatrick
9009467b48Spatrick if (opts::dump::DumpSummary) {
9109467b48Spatrick if (auto EC = dumpFileSummary())
9209467b48Spatrick return EC;
9309467b48Spatrick P.NewLine();
9409467b48Spatrick }
9509467b48Spatrick
9609467b48Spatrick if (opts::dump::DumpStreams) {
9709467b48Spatrick if (auto EC = dumpStreamSummary())
9809467b48Spatrick return EC;
9909467b48Spatrick P.NewLine();
10009467b48Spatrick }
10109467b48Spatrick
10209467b48Spatrick if (opts::dump::DumpSymbolStats) {
103*d415bd75Srobert ExitOnError Err("Unexpected error processing module stats: ");
104*d415bd75Srobert Err(dumpSymbolStats());
10509467b48Spatrick P.NewLine();
10609467b48Spatrick }
10709467b48Spatrick
10809467b48Spatrick if (opts::dump::DumpUdtStats) {
10909467b48Spatrick if (auto EC = dumpUdtStats())
11009467b48Spatrick return EC;
11109467b48Spatrick P.NewLine();
11209467b48Spatrick }
11309467b48Spatrick
114097a140dSpatrick if (opts::dump::DumpTypeStats || opts::dump::DumpIDStats) {
11509467b48Spatrick if (auto EC = dumpTypeStats())
11609467b48Spatrick return EC;
11709467b48Spatrick P.NewLine();
11809467b48Spatrick }
11909467b48Spatrick
12009467b48Spatrick if (opts::dump::DumpNamedStreams) {
12109467b48Spatrick if (auto EC = dumpNamedStreams())
12209467b48Spatrick return EC;
12309467b48Spatrick P.NewLine();
12409467b48Spatrick }
12509467b48Spatrick
12609467b48Spatrick if (opts::dump::DumpStringTable || opts::dump::DumpStringTableDetails) {
12709467b48Spatrick if (auto EC = dumpStringTable())
12809467b48Spatrick return EC;
12909467b48Spatrick P.NewLine();
13009467b48Spatrick }
13109467b48Spatrick
13209467b48Spatrick if (opts::dump::DumpModules) {
133*d415bd75Srobert ExitOnError Err("Unexpected error processing modules: ");
134*d415bd75Srobert Err(dumpModules());
13509467b48Spatrick }
13609467b48Spatrick
13709467b48Spatrick if (opts::dump::DumpModuleFiles) {
138*d415bd75Srobert ExitOnError Err("Unexpected error processing files: ");
139*d415bd75Srobert Err(dumpModuleFiles());
14009467b48Spatrick }
14109467b48Spatrick
14209467b48Spatrick if (opts::dump::DumpLines) {
143*d415bd75Srobert ExitOnError Err("Unexpected error processing lines: ");
144*d415bd75Srobert Err(dumpLines());
14509467b48Spatrick }
14609467b48Spatrick
14709467b48Spatrick if (opts::dump::DumpInlineeLines) {
148*d415bd75Srobert ExitOnError Err("Unexpected error processing inlinee lines: ");
149*d415bd75Srobert Err(dumpInlineeLines());
15009467b48Spatrick }
15109467b48Spatrick
15209467b48Spatrick if (opts::dump::DumpXmi) {
153*d415bd75Srobert ExitOnError Err("Unexpected error processing cross module imports: ");
154*d415bd75Srobert Err(dumpXmi());
15509467b48Spatrick }
15609467b48Spatrick
15709467b48Spatrick if (opts::dump::DumpXme) {
158*d415bd75Srobert ExitOnError Err("Unexpected error processing cross module exports: ");
159*d415bd75Srobert Err(dumpXme());
16009467b48Spatrick }
16109467b48Spatrick
16209467b48Spatrick if (opts::dump::DumpFpo) {
16309467b48Spatrick if (auto EC = dumpFpo())
16409467b48Spatrick return EC;
16509467b48Spatrick }
16609467b48Spatrick
16709467b48Spatrick if (File.isObj()) {
16809467b48Spatrick if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
16909467b48Spatrick opts::dump::DumpTypeExtras)
17009467b48Spatrick if (auto EC = dumpTypesFromObjectFile())
17109467b48Spatrick return EC;
17209467b48Spatrick } else {
17309467b48Spatrick if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
17409467b48Spatrick opts::dump::DumpTypeExtras) {
17509467b48Spatrick if (auto EC = dumpTpiStream(StreamTPI))
17609467b48Spatrick return EC;
17709467b48Spatrick }
17809467b48Spatrick
17909467b48Spatrick if (opts::dump::DumpIds || !opts::dump::DumpIdIndex.empty() ||
18009467b48Spatrick opts::dump::DumpIdExtras) {
18109467b48Spatrick if (auto EC = dumpTpiStream(StreamIPI))
18209467b48Spatrick return EC;
18309467b48Spatrick }
18409467b48Spatrick }
18509467b48Spatrick
18609467b48Spatrick if (opts::dump::DumpGSIRecords) {
18709467b48Spatrick if (auto EC = dumpGSIRecords())
18809467b48Spatrick return EC;
18909467b48Spatrick }
19009467b48Spatrick
19109467b48Spatrick if (opts::dump::DumpGlobals) {
19209467b48Spatrick if (auto EC = dumpGlobals())
19309467b48Spatrick return EC;
19409467b48Spatrick }
19509467b48Spatrick
19609467b48Spatrick if (opts::dump::DumpPublics) {
19709467b48Spatrick if (auto EC = dumpPublics())
19809467b48Spatrick return EC;
19909467b48Spatrick }
20009467b48Spatrick
20109467b48Spatrick if (opts::dump::DumpSymbols) {
202*d415bd75Srobert ExitOnError Err("Unexpected error processing symbols: ");
203*d415bd75Srobert Err(File.isPdb() ? dumpModuleSymsForPdb() : dumpModuleSymsForObj());
20409467b48Spatrick }
20509467b48Spatrick
20609467b48Spatrick if (opts::dump::DumpTypeRefStats) {
20709467b48Spatrick if (auto EC = dumpTypeRefStats())
20809467b48Spatrick return EC;
20909467b48Spatrick }
21009467b48Spatrick
21109467b48Spatrick if (opts::dump::DumpSectionHeaders) {
21209467b48Spatrick if (auto EC = dumpSectionHeaders())
21309467b48Spatrick return EC;
21409467b48Spatrick }
21509467b48Spatrick
21609467b48Spatrick if (opts::dump::DumpSectionContribs) {
21709467b48Spatrick if (auto EC = dumpSectionContribs())
21809467b48Spatrick return EC;
21909467b48Spatrick }
22009467b48Spatrick
22109467b48Spatrick if (opts::dump::DumpSectionMap) {
22209467b48Spatrick if (auto EC = dumpSectionMap())
22309467b48Spatrick return EC;
22409467b48Spatrick }
22509467b48Spatrick
22609467b48Spatrick P.NewLine();
22709467b48Spatrick
22809467b48Spatrick return Error::success();
22909467b48Spatrick }
23009467b48Spatrick
printHeader(LinePrinter & P,const Twine & S)23109467b48Spatrick static void printHeader(LinePrinter &P, const Twine &S) {
23209467b48Spatrick P.NewLine();
23309467b48Spatrick P.formatLine("{0,=60}", S);
23409467b48Spatrick P.formatLine("{0}", fmt_repeat('=', 60));
23509467b48Spatrick }
23609467b48Spatrick
dumpFileSummary()23709467b48Spatrick Error DumpOutputStyle::dumpFileSummary() {
23809467b48Spatrick printHeader(P, "Summary");
23909467b48Spatrick
24009467b48Spatrick if (File.isObj()) {
24109467b48Spatrick printStreamNotValidForObj();
24209467b48Spatrick return Error::success();
24309467b48Spatrick }
24409467b48Spatrick
24509467b48Spatrick AutoIndent Indent(P);
24609467b48Spatrick ExitOnError Err("Invalid PDB Format: ");
24709467b48Spatrick
24809467b48Spatrick P.formatLine("Block Size: {0}", getPdb().getBlockSize());
24909467b48Spatrick P.formatLine("Number of blocks: {0}", getPdb().getBlockCount());
25009467b48Spatrick P.formatLine("Number of streams: {0}", getPdb().getNumStreams());
25109467b48Spatrick
25209467b48Spatrick auto &PS = Err(getPdb().getPDBInfoStream());
25309467b48Spatrick P.formatLine("Signature: {0}", PS.getSignature());
25409467b48Spatrick P.formatLine("Age: {0}", PS.getAge());
25509467b48Spatrick P.formatLine("GUID: {0}", fmt_guid(PS.getGuid().Guid));
25609467b48Spatrick P.formatLine("Features: {0:x+}", static_cast<uint32_t>(PS.getFeatures()));
25709467b48Spatrick P.formatLine("Has Debug Info: {0}", getPdb().hasPDBDbiStream());
25809467b48Spatrick P.formatLine("Has Types: {0}", getPdb().hasPDBTpiStream());
25909467b48Spatrick P.formatLine("Has IDs: {0}", getPdb().hasPDBIpiStream());
26009467b48Spatrick P.formatLine("Has Globals: {0}", getPdb().hasPDBGlobalsStream());
26109467b48Spatrick P.formatLine("Has Publics: {0}", getPdb().hasPDBPublicsStream());
26209467b48Spatrick if (getPdb().hasPDBDbiStream()) {
263*d415bd75Srobert DbiStream &DBI = Err(getPdb().getPDBDbiStream());
26409467b48Spatrick P.formatLine("Is incrementally linked: {0}", DBI.isIncrementallyLinked());
26509467b48Spatrick P.formatLine("Has conflicting types: {0}", DBI.hasCTypes());
26609467b48Spatrick P.formatLine("Is stripped: {0}", DBI.isStripped());
26709467b48Spatrick }
26809467b48Spatrick
26909467b48Spatrick return Error::success();
27009467b48Spatrick }
27109467b48Spatrick
getSymbolStats(const SymbolGroup & SG,StatCollection & CumulativeStats)27209467b48Spatrick static StatCollection getSymbolStats(const SymbolGroup &SG,
27309467b48Spatrick StatCollection &CumulativeStats) {
27409467b48Spatrick StatCollection Stats;
27509467b48Spatrick if (SG.getFile().isPdb() && SG.hasDebugStream()) {
27609467b48Spatrick // For PDB files, all symbols are packed into one stream.
27709467b48Spatrick for (const auto &S : SG.getPdbModuleStream().symbols(nullptr)) {
27809467b48Spatrick Stats.update(S.kind(), S.length());
27909467b48Spatrick CumulativeStats.update(S.kind(), S.length());
28009467b48Spatrick }
28109467b48Spatrick return Stats;
28209467b48Spatrick }
28309467b48Spatrick
28409467b48Spatrick for (const auto &SS : SG.getDebugSubsections()) {
28509467b48Spatrick // For object files, all symbols are spread across multiple Symbol
28609467b48Spatrick // subsections of a given .debug$S section.
28709467b48Spatrick if (SS.kind() != DebugSubsectionKind::Symbols)
28809467b48Spatrick continue;
28909467b48Spatrick DebugSymbolsSubsectionRef Symbols;
29009467b48Spatrick BinaryStreamReader Reader(SS.getRecordData());
29109467b48Spatrick cantFail(Symbols.initialize(Reader));
29209467b48Spatrick for (const auto &S : Symbols) {
29309467b48Spatrick Stats.update(S.kind(), S.length());
29409467b48Spatrick CumulativeStats.update(S.kind(), S.length());
29509467b48Spatrick }
29609467b48Spatrick }
29709467b48Spatrick return Stats;
29809467b48Spatrick }
29909467b48Spatrick
getChunkStats(const SymbolGroup & SG,StatCollection & CumulativeStats)30009467b48Spatrick static StatCollection getChunkStats(const SymbolGroup &SG,
30109467b48Spatrick StatCollection &CumulativeStats) {
30209467b48Spatrick StatCollection Stats;
30309467b48Spatrick for (const auto &Chunk : SG.getDebugSubsections()) {
30409467b48Spatrick Stats.update(uint32_t(Chunk.kind()), Chunk.getRecordLength());
30509467b48Spatrick CumulativeStats.update(uint32_t(Chunk.kind()), Chunk.getRecordLength());
30609467b48Spatrick }
30709467b48Spatrick return Stats;
30809467b48Spatrick }
30909467b48Spatrick
formatModuleDetailKind(DebugSubsectionKind K)31009467b48Spatrick static inline std::string formatModuleDetailKind(DebugSubsectionKind K) {
31109467b48Spatrick return formatChunkKind(K, false);
31209467b48Spatrick }
31309467b48Spatrick
formatModuleDetailKind(SymbolKind K)31409467b48Spatrick static inline std::string formatModuleDetailKind(SymbolKind K) {
31509467b48Spatrick return formatSymbolKind(K);
31609467b48Spatrick }
31709467b48Spatrick
31809467b48Spatrick // Get the stats sorted by size, descending.
31909467b48Spatrick std::vector<StatCollection::KindAndStat>
getStatsSortedBySize() const32009467b48Spatrick StatCollection::getStatsSortedBySize() const {
32109467b48Spatrick std::vector<KindAndStat> SortedStats(Individual.begin(), Individual.end());
32209467b48Spatrick llvm::stable_sort(SortedStats,
32309467b48Spatrick [](const KindAndStat &LHS, const KindAndStat &RHS) {
32409467b48Spatrick return LHS.second.Size > RHS.second.Size;
32509467b48Spatrick });
32609467b48Spatrick return SortedStats;
32709467b48Spatrick }
32809467b48Spatrick
32909467b48Spatrick template <typename Kind>
printModuleDetailStats(LinePrinter & P,StringRef Label,const StatCollection & Stats)33009467b48Spatrick static void printModuleDetailStats(LinePrinter &P, StringRef Label,
33109467b48Spatrick const StatCollection &Stats) {
33209467b48Spatrick P.NewLine();
33309467b48Spatrick P.formatLine(" {0}", Label);
33409467b48Spatrick AutoIndent Indent(P);
33509467b48Spatrick P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", "Total",
33609467b48Spatrick Stats.Totals.Count, Stats.Totals.Size);
33709467b48Spatrick P.formatLine("{0}", fmt_repeat('-', 74));
33809467b48Spatrick
33909467b48Spatrick for (const auto &K : Stats.getStatsSortedBySize()) {
34009467b48Spatrick std::string KindName = formatModuleDetailKind(Kind(K.first));
34109467b48Spatrick P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", KindName,
34209467b48Spatrick K.second.Count, K.second.Size);
34309467b48Spatrick }
34409467b48Spatrick }
34509467b48Spatrick
dumpStreamSummary()34609467b48Spatrick Error DumpOutputStyle::dumpStreamSummary() {
34709467b48Spatrick printHeader(P, "Streams");
34809467b48Spatrick
34909467b48Spatrick if (File.isObj()) {
35009467b48Spatrick printStreamNotValidForObj();
35109467b48Spatrick return Error::success();
35209467b48Spatrick }
35309467b48Spatrick
35409467b48Spatrick AutoIndent Indent(P);
35509467b48Spatrick
35609467b48Spatrick if (StreamPurposes.empty())
35709467b48Spatrick discoverStreamPurposes(getPdb(), StreamPurposes);
35809467b48Spatrick
35909467b48Spatrick uint32_t StreamCount = getPdb().getNumStreams();
36009467b48Spatrick uint32_t MaxStreamSize = getPdb().getMaxStreamSize();
36109467b48Spatrick
362*d415bd75Srobert for (uint32_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
36309467b48Spatrick P.formatLine(
36409467b48Spatrick "Stream {0} ({1} bytes): [{2}]",
36509467b48Spatrick fmt_align(StreamIdx, AlignStyle::Right, NumDigits(StreamCount)),
36609467b48Spatrick fmt_align(getPdb().getStreamByteSize(StreamIdx), AlignStyle::Right,
36709467b48Spatrick NumDigits(MaxStreamSize)),
36809467b48Spatrick StreamPurposes[StreamIdx].getLongName());
36909467b48Spatrick
37009467b48Spatrick if (opts::dump::DumpStreamBlocks) {
37109467b48Spatrick auto Blocks = getPdb().getStreamBlockList(StreamIdx);
37209467b48Spatrick std::vector<uint32_t> BV(Blocks.begin(), Blocks.end());
37309467b48Spatrick P.formatLine(" {0} Blocks: [{1}]",
37409467b48Spatrick fmt_repeat(' ', NumDigits(StreamCount)),
37509467b48Spatrick make_range(BV.begin(), BV.end()));
37609467b48Spatrick }
37709467b48Spatrick }
37809467b48Spatrick
37909467b48Spatrick return Error::success();
38009467b48Spatrick }
38109467b48Spatrick
38209467b48Spatrick static Expected<std::pair<std::unique_ptr<MappedBlockStream>,
38309467b48Spatrick ArrayRef<llvm::object::coff_section>>>
loadSectionHeaders(PDBFile & File,DbgHeaderType Type)38409467b48Spatrick loadSectionHeaders(PDBFile &File, DbgHeaderType Type) {
38509467b48Spatrick if (!File.hasPDBDbiStream())
38609467b48Spatrick return make_error<StringError>(
38709467b48Spatrick "Section headers require a DBI Stream, which could not be loaded",
38809467b48Spatrick inconvertibleErrorCode());
38909467b48Spatrick
390*d415bd75Srobert DbiStream &Dbi = cantFail(File.getPDBDbiStream());
39109467b48Spatrick uint32_t SI = Dbi.getDebugStreamIndex(Type);
39209467b48Spatrick
39309467b48Spatrick if (SI == kInvalidStreamIndex)
39409467b48Spatrick return make_error<StringError>(
39509467b48Spatrick "PDB does not contain the requested image section header type",
39609467b48Spatrick inconvertibleErrorCode());
39709467b48Spatrick
39809467b48Spatrick auto Stream = File.createIndexedStream(SI);
39909467b48Spatrick if (!Stream)
40009467b48Spatrick return make_error<StringError>("Could not load the required stream data",
40109467b48Spatrick inconvertibleErrorCode());
40209467b48Spatrick
40309467b48Spatrick ArrayRef<object::coff_section> Headers;
40409467b48Spatrick if (Stream->getLength() % sizeof(object::coff_section) != 0)
40509467b48Spatrick return make_error<StringError>(
40609467b48Spatrick "Section header array size is not a multiple of section header size",
40709467b48Spatrick inconvertibleErrorCode());
40809467b48Spatrick
40909467b48Spatrick uint32_t NumHeaders = Stream->getLength() / sizeof(object::coff_section);
41009467b48Spatrick BinaryStreamReader Reader(*Stream);
41109467b48Spatrick cantFail(Reader.readArray(Headers, NumHeaders));
41209467b48Spatrick return std::make_pair(std::move(Stream), Headers);
41309467b48Spatrick }
41409467b48Spatrick
getSectionNames(PDBFile & File)415*d415bd75Srobert static Expected<std::vector<std::string>> getSectionNames(PDBFile &File) {
41609467b48Spatrick auto ExpectedHeaders = loadSectionHeaders(File, DbgHeaderType::SectionHdr);
41709467b48Spatrick if (!ExpectedHeaders)
418*d415bd75Srobert return ExpectedHeaders.takeError();
41909467b48Spatrick
42009467b48Spatrick std::unique_ptr<MappedBlockStream> Stream;
42109467b48Spatrick ArrayRef<object::coff_section> Headers;
42209467b48Spatrick std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
42309467b48Spatrick std::vector<std::string> Names;
42409467b48Spatrick for (const auto &H : Headers)
42509467b48Spatrick Names.push_back(H.Name);
42609467b48Spatrick return Names;
42709467b48Spatrick }
42809467b48Spatrick
dumpSectionContrib(LinePrinter & P,const SectionContrib & SC,ArrayRef<std::string> SectionNames,uint32_t FieldWidth)42909467b48Spatrick static void dumpSectionContrib(LinePrinter &P, const SectionContrib &SC,
43009467b48Spatrick ArrayRef<std::string> SectionNames,
43109467b48Spatrick uint32_t FieldWidth) {
43209467b48Spatrick std::string NameInsert;
43309467b48Spatrick if (SC.ISect > 0 && SC.ISect <= SectionNames.size()) {
43409467b48Spatrick StringRef SectionName = SectionNames[SC.ISect - 1];
43509467b48Spatrick NameInsert = formatv("[{0}]", SectionName).str();
43609467b48Spatrick } else
43709467b48Spatrick NameInsert = "[???]";
43809467b48Spatrick P.formatLine("SC{5} | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
43909467b48Spatrick "crc = {4}",
44009467b48Spatrick formatSegmentOffset(SC.ISect, SC.Off), fmtle(SC.Size),
44109467b48Spatrick fmtle(SC.Imod), fmtle(SC.DataCrc), fmtle(SC.RelocCrc),
44209467b48Spatrick fmt_align(NameInsert, AlignStyle::Left, FieldWidth + 2));
44309467b48Spatrick AutoIndent Indent(P, FieldWidth + 2);
44409467b48Spatrick P.formatLine(" {0}",
44509467b48Spatrick formatSectionCharacteristics(P.getIndentLevel() + 6,
44609467b48Spatrick SC.Characteristics, 3, " | "));
44709467b48Spatrick }
44809467b48Spatrick
dumpSectionContrib(LinePrinter & P,const SectionContrib2 & SC,ArrayRef<std::string> SectionNames,uint32_t FieldWidth)44909467b48Spatrick static void dumpSectionContrib(LinePrinter &P, const SectionContrib2 &SC,
45009467b48Spatrick ArrayRef<std::string> SectionNames,
45109467b48Spatrick uint32_t FieldWidth) {
45209467b48Spatrick P.formatLine("SC2[{6}] | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
45309467b48Spatrick "crc = {4}, coff section = {5}",
45409467b48Spatrick formatSegmentOffset(SC.Base.ISect, SC.Base.Off),
45509467b48Spatrick fmtle(SC.Base.Size), fmtle(SC.Base.Imod), fmtle(SC.Base.DataCrc),
45609467b48Spatrick fmtle(SC.Base.RelocCrc), fmtle(SC.ISectCoff));
45709467b48Spatrick P.formatLine(" {0}",
45809467b48Spatrick formatSectionCharacteristics(P.getIndentLevel() + 6,
45909467b48Spatrick SC.Base.Characteristics, 3, " | "));
46009467b48Spatrick }
46109467b48Spatrick
dumpModules()46209467b48Spatrick Error DumpOutputStyle::dumpModules() {
46309467b48Spatrick printHeader(P, "Modules");
46409467b48Spatrick
46509467b48Spatrick if (File.isObj()) {
46609467b48Spatrick printStreamNotValidForObj();
46709467b48Spatrick return Error::success();
46809467b48Spatrick }
46909467b48Spatrick
47009467b48Spatrick if (!getPdb().hasPDBDbiStream()) {
47109467b48Spatrick printStreamNotPresent("DBI");
47209467b48Spatrick return Error::success();
47309467b48Spatrick }
47409467b48Spatrick
47509467b48Spatrick AutoIndent Indent(P);
47609467b48Spatrick
477*d415bd75Srobert Expected<DbiStream &> StreamOrErr = getPdb().getPDBDbiStream();
478*d415bd75Srobert if (!StreamOrErr)
479*d415bd75Srobert return StreamOrErr.takeError();
480*d415bd75Srobert DbiStream &Stream = *StreamOrErr;
48109467b48Spatrick
48209467b48Spatrick const DbiModuleList &Modules = Stream.modules();
483*d415bd75Srobert return iterateSymbolGroups(
484*d415bd75Srobert File, PrintScope{P, 11},
485*d415bd75Srobert [&](uint32_t Modi, const SymbolGroup &Strings) -> Error {
48609467b48Spatrick auto Desc = Modules.getModuleDescriptor(Modi);
48709467b48Spatrick if (opts::dump::DumpSectionContribs) {
488*d415bd75Srobert auto SectionsOrErr = getSectionNames(getPdb());
489*d415bd75Srobert if (!SectionsOrErr)
490*d415bd75Srobert return SectionsOrErr.takeError();
491*d415bd75Srobert ArrayRef<std::string> Sections = *SectionsOrErr;
49209467b48Spatrick dumpSectionContrib(P, Desc.getSectionContrib(), Sections, 0);
49309467b48Spatrick }
49409467b48Spatrick P.formatLine("Obj: `{0}`: ", Desc.getObjFileName());
49509467b48Spatrick P.formatLine("debug stream: {0}, # files: {1}, has ec info: {2}",
49609467b48Spatrick Desc.getModuleStreamIndex(), Desc.getNumberOfFiles(),
49709467b48Spatrick Desc.hasECInfo());
498*d415bd75Srobert
499*d415bd75Srobert auto PdbPathOrErr = Stream.getECName(Desc.getPdbFilePathNameIndex());
500*d415bd75Srobert if (!PdbPathOrErr)
501*d415bd75Srobert return PdbPathOrErr.takeError();
502*d415bd75Srobert StringRef PdbFilePath = *PdbPathOrErr;
503*d415bd75Srobert
504*d415bd75Srobert auto SrcPathOrErr = Stream.getECName(Desc.getSourceFileNameIndex());
505*d415bd75Srobert if (!SrcPathOrErr)
506*d415bd75Srobert return SrcPathOrErr.takeError();
507*d415bd75Srobert StringRef SrcFilePath = *SrcPathOrErr;
508*d415bd75Srobert
50909467b48Spatrick P.formatLine("pdb file ni: {0} `{1}`, src file ni: {2} `{3}`",
51009467b48Spatrick Desc.getPdbFilePathNameIndex(), PdbFilePath,
51109467b48Spatrick Desc.getSourceFileNameIndex(), SrcFilePath);
51209467b48Spatrick return Error::success();
513*d415bd75Srobert });
51409467b48Spatrick }
51509467b48Spatrick
dumpModuleFiles()51609467b48Spatrick Error DumpOutputStyle::dumpModuleFiles() {
51709467b48Spatrick printHeader(P, "Files");
51809467b48Spatrick
51909467b48Spatrick if (File.isObj()) {
52009467b48Spatrick printStreamNotValidForObj();
52109467b48Spatrick return Error::success();
52209467b48Spatrick }
52309467b48Spatrick
52409467b48Spatrick if (!getPdb().hasPDBDbiStream()) {
52509467b48Spatrick printStreamNotPresent("DBI");
52609467b48Spatrick return Error::success();
52709467b48Spatrick }
52809467b48Spatrick
529*d415bd75Srobert return iterateSymbolGroups(
530*d415bd75Srobert File, PrintScope{P, 11},
531*d415bd75Srobert [this](uint32_t Modi, const SymbolGroup &Strings) -> Error {
532*d415bd75Srobert Expected<DbiStream &> StreamOrErr = getPdb().getPDBDbiStream();
533*d415bd75Srobert if (!StreamOrErr)
534*d415bd75Srobert return StreamOrErr.takeError();
535*d415bd75Srobert DbiStream &Stream = *StreamOrErr;
53609467b48Spatrick
53709467b48Spatrick const DbiModuleList &Modules = Stream.modules();
53809467b48Spatrick for (const auto &F : Modules.source_files(Modi)) {
53909467b48Spatrick Strings.formatFromFileName(P, F);
54009467b48Spatrick }
54109467b48Spatrick return Error::success();
542*d415bd75Srobert });
54309467b48Spatrick }
54409467b48Spatrick
dumpSymbolStats()54509467b48Spatrick Error DumpOutputStyle::dumpSymbolStats() {
54609467b48Spatrick printHeader(P, "Module Stats");
54709467b48Spatrick
54809467b48Spatrick if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
54909467b48Spatrick printStreamNotPresent("DBI");
55009467b48Spatrick return Error::success();
55109467b48Spatrick }
55209467b48Spatrick
55309467b48Spatrick StatCollection SymStats;
55409467b48Spatrick StatCollection ChunkStats;
555*d415bd75Srobert PrintScope Scope(P, 2);
55609467b48Spatrick
557*d415bd75Srobert if (Error Err = iterateSymbolGroups(
558*d415bd75Srobert File, Scope, [&](uint32_t Modi, const SymbolGroup &SG) -> Error {
55909467b48Spatrick StatCollection SS = getSymbolStats(SG, SymStats);
56009467b48Spatrick StatCollection CS = getChunkStats(SG, ChunkStats);
56109467b48Spatrick
562*d415bd75Srobert if (!SG.getFile().isPdb())
563*d415bd75Srobert return Error::success();
564*d415bd75Srobert
56509467b48Spatrick AutoIndent Indent(P);
56609467b48Spatrick auto Modules = cantFail(File.pdb().getPDBDbiStream()).modules();
56709467b48Spatrick uint32_t ModCount = Modules.getModuleCount();
56809467b48Spatrick DbiModuleDescriptor Desc = Modules.getModuleDescriptor(Modi);
56909467b48Spatrick uint32_t StreamIdx = Desc.getModuleStreamIndex();
57009467b48Spatrick
57109467b48Spatrick if (StreamIdx == kInvalidStreamIndex) {
572*d415bd75Srobert P.formatLine(
573*d415bd75Srobert "Mod {0} (debug info not present): [{1}]",
57409467b48Spatrick fmt_align(Modi, AlignStyle::Right, NumDigits(ModCount)),
57509467b48Spatrick Desc.getModuleName());
576*d415bd75Srobert return Error::success();
57709467b48Spatrick }
57809467b48Spatrick P.formatLine("Stream {0}, {1} bytes", StreamIdx,
57909467b48Spatrick getPdb().getStreamByteSize(StreamIdx));
58009467b48Spatrick
58109467b48Spatrick printModuleDetailStats<SymbolKind>(P, "Symbols", SS);
58209467b48Spatrick printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", CS);
583*d415bd75Srobert
584*d415bd75Srobert return Error::success();
585*d415bd75Srobert }))
586*d415bd75Srobert return Err;
58709467b48Spatrick
58809467b48Spatrick if (SymStats.Totals.Count > 0) {
58909467b48Spatrick P.printLine(" Summary |");
59009467b48Spatrick AutoIndent Indent(P, 4);
59109467b48Spatrick printModuleDetailStats<SymbolKind>(P, "Symbols", SymStats);
59209467b48Spatrick printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", ChunkStats);
59309467b48Spatrick }
59409467b48Spatrick
59509467b48Spatrick return Error::success();
59609467b48Spatrick }
59709467b48Spatrick
dumpTypeStats()59809467b48Spatrick Error DumpOutputStyle::dumpTypeStats() {
59909467b48Spatrick printHeader(P, "Type Record Stats");
60009467b48Spatrick
60109467b48Spatrick // Iterate the types, categorize by kind, accumulate size stats.
60209467b48Spatrick StatCollection TypeStats;
603097a140dSpatrick LazyRandomTypeCollection &Types =
604097a140dSpatrick opts::dump::DumpTypeStats ? File.types() : File.ids();
605*d415bd75Srobert for (std::optional<TypeIndex> TI = Types.getFirst(); TI;
606*d415bd75Srobert TI = Types.getNext(*TI)) {
60709467b48Spatrick CVType Type = Types.getType(*TI);
60809467b48Spatrick TypeStats.update(uint32_t(Type.kind()), Type.length());
60909467b48Spatrick }
61009467b48Spatrick
61109467b48Spatrick P.NewLine();
61209467b48Spatrick P.formatLine(" Types");
61309467b48Spatrick AutoIndent Indent(P);
614097a140dSpatrick P.formatLine("{0,16}: {1,7} entries ({2,12:N} bytes, {3,7} avg)", "Total",
61509467b48Spatrick TypeStats.Totals.Count, TypeStats.Totals.Size,
61609467b48Spatrick (double)TypeStats.Totals.Size / TypeStats.Totals.Count);
61709467b48Spatrick P.formatLine("{0}", fmt_repeat('-', 74));
61809467b48Spatrick
61909467b48Spatrick for (const auto &K : TypeStats.getStatsSortedBySize()) {
620097a140dSpatrick P.formatLine("{0,16}: {1,7} entries ({2,12:N} bytes, {3,7} avg)",
62109467b48Spatrick formatTypeLeafKind(TypeLeafKind(K.first)), K.second.Count,
62209467b48Spatrick K.second.Size, (double)K.second.Size / K.second.Count);
62309467b48Spatrick }
62409467b48Spatrick return Error::success();
62509467b48Spatrick }
62609467b48Spatrick
isValidNamespaceIdentifier(StringRef S)62709467b48Spatrick static bool isValidNamespaceIdentifier(StringRef S) {
62809467b48Spatrick if (S.empty())
62909467b48Spatrick return false;
63009467b48Spatrick
63109467b48Spatrick if (std::isdigit(S[0]))
63209467b48Spatrick return false;
63309467b48Spatrick
63409467b48Spatrick return llvm::all_of(S, [](char C) { return std::isalnum(C); });
63509467b48Spatrick }
63609467b48Spatrick
63709467b48Spatrick namespace {
63809467b48Spatrick constexpr uint32_t kNoneUdtKind = 0;
63909467b48Spatrick constexpr uint32_t kSimpleUdtKind = 1;
64009467b48Spatrick constexpr uint32_t kUnknownUdtKind = 2;
64109467b48Spatrick } // namespace
64209467b48Spatrick
getUdtStatLabel(uint32_t Kind)64373471bf0Spatrick static std::string getUdtStatLabel(uint32_t Kind) {
64409467b48Spatrick if (Kind == kNoneUdtKind)
64573471bf0Spatrick return "<none type>";
64609467b48Spatrick
64709467b48Spatrick if (Kind == kSimpleUdtKind)
64873471bf0Spatrick return "<simple type>";
64909467b48Spatrick
65009467b48Spatrick if (Kind == kUnknownUdtKind)
65173471bf0Spatrick return "<unknown type>";
65209467b48Spatrick
65309467b48Spatrick return formatTypeLeafKind(static_cast<TypeLeafKind>(Kind));
65409467b48Spatrick }
65509467b48Spatrick
getLongestTypeLeafName(const StatCollection & Stats)65609467b48Spatrick static uint32_t getLongestTypeLeafName(const StatCollection &Stats) {
65709467b48Spatrick size_t L = 0;
65809467b48Spatrick for (const auto &Stat : Stats.Individual) {
65973471bf0Spatrick std::string Label = getUdtStatLabel(Stat.first);
66009467b48Spatrick L = std::max(L, Label.size());
66109467b48Spatrick }
66209467b48Spatrick return static_cast<uint32_t>(L);
66309467b48Spatrick }
66409467b48Spatrick
dumpUdtStats()66509467b48Spatrick Error DumpOutputStyle::dumpUdtStats() {
66609467b48Spatrick printHeader(P, "S_UDT Record Stats");
66709467b48Spatrick
66809467b48Spatrick if (File.isPdb() && !getPdb().hasPDBGlobalsStream()) {
66909467b48Spatrick printStreamNotPresent("Globals");
67009467b48Spatrick return Error::success();
67109467b48Spatrick }
67209467b48Spatrick
67309467b48Spatrick StatCollection UdtStats;
67409467b48Spatrick StatCollection UdtTargetStats;
67509467b48Spatrick AutoIndent Indent(P, 4);
67609467b48Spatrick
67709467b48Spatrick auto &TpiTypes = File.types();
67809467b48Spatrick
67909467b48Spatrick StringMap<StatCollection::Stat> NamespacedStats;
68009467b48Spatrick
68109467b48Spatrick size_t LongestNamespace = 0;
68209467b48Spatrick auto HandleOneSymbol = [&](const CVSymbol &Sym) {
68309467b48Spatrick if (Sym.kind() != SymbolKind::S_UDT)
68409467b48Spatrick return;
68509467b48Spatrick UdtStats.update(SymbolKind::S_UDT, Sym.length());
68609467b48Spatrick
68709467b48Spatrick UDTSym UDT = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(Sym));
68809467b48Spatrick
68909467b48Spatrick uint32_t Kind = 0;
69009467b48Spatrick uint32_t RecordSize = 0;
69109467b48Spatrick
69209467b48Spatrick if (UDT.Type.isNoneType())
69309467b48Spatrick Kind = kNoneUdtKind;
69409467b48Spatrick else if (UDT.Type.isSimple())
69509467b48Spatrick Kind = kSimpleUdtKind;
696*d415bd75Srobert else if (std::optional<CVType> T = TpiTypes.tryGetType(UDT.Type)) {
69709467b48Spatrick Kind = T->kind();
69809467b48Spatrick RecordSize = T->length();
69909467b48Spatrick } else
70009467b48Spatrick Kind = kUnknownUdtKind;
70109467b48Spatrick
70209467b48Spatrick UdtTargetStats.update(Kind, RecordSize);
70309467b48Spatrick
70409467b48Spatrick size_t Pos = UDT.Name.find("::");
70509467b48Spatrick if (Pos == StringRef::npos)
70609467b48Spatrick return;
70709467b48Spatrick
70809467b48Spatrick StringRef Scope = UDT.Name.take_front(Pos);
70909467b48Spatrick if (Scope.empty() || !isValidNamespaceIdentifier(Scope))
71009467b48Spatrick return;
71109467b48Spatrick
71209467b48Spatrick LongestNamespace = std::max(LongestNamespace, Scope.size());
71309467b48Spatrick NamespacedStats[Scope].update(RecordSize);
71409467b48Spatrick };
71509467b48Spatrick
71609467b48Spatrick P.NewLine();
71709467b48Spatrick
71809467b48Spatrick if (File.isPdb()) {
71909467b48Spatrick auto &SymbolRecords = cantFail(getPdb().getPDBSymbolStream());
72009467b48Spatrick auto ExpGlobals = getPdb().getPDBGlobalsStream();
72109467b48Spatrick if (!ExpGlobals)
72209467b48Spatrick return ExpGlobals.takeError();
72309467b48Spatrick
72409467b48Spatrick for (uint32_t PubSymOff : ExpGlobals->getGlobalsTable()) {
72509467b48Spatrick CVSymbol Sym = SymbolRecords.readRecord(PubSymOff);
72609467b48Spatrick HandleOneSymbol(Sym);
72709467b48Spatrick }
72809467b48Spatrick } else {
72909467b48Spatrick for (const auto &Sec : File.symbol_groups()) {
73009467b48Spatrick for (const auto &SS : Sec.getDebugSubsections()) {
73109467b48Spatrick if (SS.kind() != DebugSubsectionKind::Symbols)
73209467b48Spatrick continue;
73309467b48Spatrick
73409467b48Spatrick DebugSymbolsSubsectionRef Symbols;
73509467b48Spatrick BinaryStreamReader Reader(SS.getRecordData());
73609467b48Spatrick cantFail(Symbols.initialize(Reader));
73709467b48Spatrick for (const auto &S : Symbols)
73809467b48Spatrick HandleOneSymbol(S);
73909467b48Spatrick }
74009467b48Spatrick }
74109467b48Spatrick }
74209467b48Spatrick
74309467b48Spatrick LongestNamespace += StringRef(" namespace ''").size();
74409467b48Spatrick size_t LongestTypeLeafKind = getLongestTypeLeafName(UdtTargetStats);
74509467b48Spatrick size_t FieldWidth = std::max(LongestNamespace, LongestTypeLeafKind);
74609467b48Spatrick
74709467b48Spatrick // Compute the max number of digits for count and size fields, including comma
74809467b48Spatrick // separators.
74909467b48Spatrick StringRef CountHeader("Count");
75009467b48Spatrick StringRef SizeHeader("Size");
75109467b48Spatrick size_t CD = NumDigits(UdtStats.Totals.Count);
75209467b48Spatrick CD += (CD - 1) / 3;
75309467b48Spatrick CD = std::max(CD, CountHeader.size());
75409467b48Spatrick
75509467b48Spatrick size_t SD = NumDigits(UdtStats.Totals.Size);
75609467b48Spatrick SD += (SD - 1) / 3;
75709467b48Spatrick SD = std::max(SD, SizeHeader.size());
75809467b48Spatrick
75909467b48Spatrick uint32_t TableWidth = FieldWidth + 3 + CD + 2 + SD + 1;
76009467b48Spatrick
76109467b48Spatrick P.formatLine("{0} | {1} {2}",
76209467b48Spatrick fmt_align("Record Kind", AlignStyle::Right, FieldWidth),
76309467b48Spatrick fmt_align(CountHeader, AlignStyle::Right, CD),
76409467b48Spatrick fmt_align(SizeHeader, AlignStyle::Right, SD));
76509467b48Spatrick
76609467b48Spatrick P.formatLine("{0}", fmt_repeat('-', TableWidth));
76709467b48Spatrick for (const auto &Stat : UdtTargetStats.getStatsSortedBySize()) {
76873471bf0Spatrick std::string Label = getUdtStatLabel(Stat.first);
76909467b48Spatrick P.formatLine("{0} | {1:N} {2:N}",
77009467b48Spatrick fmt_align(Label, AlignStyle::Right, FieldWidth),
77109467b48Spatrick fmt_align(Stat.second.Count, AlignStyle::Right, CD),
77209467b48Spatrick fmt_align(Stat.second.Size, AlignStyle::Right, SD));
77309467b48Spatrick }
77409467b48Spatrick P.formatLine("{0}", fmt_repeat('-', TableWidth));
77509467b48Spatrick P.formatLine("{0} | {1:N} {2:N}",
77609467b48Spatrick fmt_align("Total (S_UDT)", AlignStyle::Right, FieldWidth),
77709467b48Spatrick fmt_align(UdtStats.Totals.Count, AlignStyle::Right, CD),
77809467b48Spatrick fmt_align(UdtStats.Totals.Size, AlignStyle::Right, SD));
77909467b48Spatrick P.formatLine("{0}", fmt_repeat('-', TableWidth));
78009467b48Spatrick struct StrAndStat {
78109467b48Spatrick StringRef Key;
78209467b48Spatrick StatCollection::Stat Stat;
78309467b48Spatrick };
78409467b48Spatrick
78509467b48Spatrick // Print namespace stats in descending order of size.
78609467b48Spatrick std::vector<StrAndStat> NamespacedStatsSorted;
78709467b48Spatrick for (const auto &Stat : NamespacedStats)
78809467b48Spatrick NamespacedStatsSorted.push_back({Stat.getKey(), Stat.second});
78909467b48Spatrick llvm::stable_sort(NamespacedStatsSorted,
79009467b48Spatrick [](const StrAndStat &L, const StrAndStat &R) {
79109467b48Spatrick return L.Stat.Size > R.Stat.Size;
79209467b48Spatrick });
79309467b48Spatrick for (const auto &Stat : NamespacedStatsSorted) {
794097a140dSpatrick std::string Label = std::string(formatv("namespace '{0}'", Stat.Key));
79509467b48Spatrick P.formatLine("{0} | {1:N} {2:N}",
79609467b48Spatrick fmt_align(Label, AlignStyle::Right, FieldWidth),
79709467b48Spatrick fmt_align(Stat.Stat.Count, AlignStyle::Right, CD),
79809467b48Spatrick fmt_align(Stat.Stat.Size, AlignStyle::Right, SD));
79909467b48Spatrick }
80009467b48Spatrick return Error::success();
80109467b48Spatrick }
80209467b48Spatrick
typesetLinesAndColumns(LinePrinter & P,uint32_t Start,const LineColumnEntry & E)80309467b48Spatrick static void typesetLinesAndColumns(LinePrinter &P, uint32_t Start,
80409467b48Spatrick const LineColumnEntry &E) {
80509467b48Spatrick const uint32_t kMaxCharsPerLineNumber = 4; // 4 digit line number
80609467b48Spatrick uint32_t MinColumnWidth = kMaxCharsPerLineNumber + 5;
80709467b48Spatrick
80809467b48Spatrick // Let's try to keep it under 100 characters
80909467b48Spatrick constexpr uint32_t kMaxRowLength = 100;
81009467b48Spatrick // At least 3 spaces between columns.
81109467b48Spatrick uint32_t ColumnsPerRow = kMaxRowLength / (MinColumnWidth + 3);
81209467b48Spatrick uint32_t ItemsLeft = E.LineNumbers.size();
81309467b48Spatrick auto LineIter = E.LineNumbers.begin();
81409467b48Spatrick while (ItemsLeft != 0) {
81509467b48Spatrick uint32_t RowColumns = std::min(ItemsLeft, ColumnsPerRow);
81609467b48Spatrick for (uint32_t I = 0; I < RowColumns; ++I) {
81709467b48Spatrick LineInfo Line(LineIter->Flags);
81809467b48Spatrick std::string LineStr;
81909467b48Spatrick if (Line.isAlwaysStepInto())
82009467b48Spatrick LineStr = "ASI";
82109467b48Spatrick else if (Line.isNeverStepInto())
82209467b48Spatrick LineStr = "NSI";
82309467b48Spatrick else
82409467b48Spatrick LineStr = utostr(Line.getStartLine());
82509467b48Spatrick char Statement = Line.isStatement() ? ' ' : '!';
82609467b48Spatrick P.format("{0} {1:X-} {2} ",
82709467b48Spatrick fmt_align(LineStr, AlignStyle::Right, kMaxCharsPerLineNumber),
82809467b48Spatrick fmt_align(Start + LineIter->Offset, AlignStyle::Right, 8, '0'),
82909467b48Spatrick Statement);
83009467b48Spatrick ++LineIter;
83109467b48Spatrick --ItemsLeft;
83209467b48Spatrick }
83309467b48Spatrick P.NewLine();
83409467b48Spatrick }
83509467b48Spatrick }
83609467b48Spatrick
dumpLines()83709467b48Spatrick Error DumpOutputStyle::dumpLines() {
83809467b48Spatrick printHeader(P, "Lines");
83909467b48Spatrick
84009467b48Spatrick if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
84109467b48Spatrick printStreamNotPresent("DBI");
84209467b48Spatrick return Error::success();
84309467b48Spatrick }
84409467b48Spatrick
84509467b48Spatrick uint32_t LastModi = UINT32_MAX;
84609467b48Spatrick uint32_t LastNameIndex = UINT32_MAX;
847*d415bd75Srobert return iterateModuleSubsections<DebugLinesSubsectionRef>(
84809467b48Spatrick File, PrintScope{P, 4},
849*d415bd75Srobert [this, &LastModi,
850*d415bd75Srobert &LastNameIndex](uint32_t Modi, const SymbolGroup &Strings,
851*d415bd75Srobert DebugLinesSubsectionRef &Lines) -> Error {
85209467b48Spatrick uint16_t Segment = Lines.header()->RelocSegment;
85309467b48Spatrick uint32_t Begin = Lines.header()->RelocOffset;
85409467b48Spatrick uint32_t End = Begin + Lines.header()->CodeSize;
85509467b48Spatrick for (const auto &Block : Lines) {
85609467b48Spatrick if (LastModi != Modi || LastNameIndex != Block.NameIndex) {
85709467b48Spatrick LastModi = Modi;
85809467b48Spatrick LastNameIndex = Block.NameIndex;
85909467b48Spatrick Strings.formatFromChecksumsOffset(P, Block.NameIndex);
86009467b48Spatrick }
86109467b48Spatrick
86209467b48Spatrick AutoIndent Indent(P, 2);
86309467b48Spatrick P.formatLine("{0:X-4}:{1:X-8}-{2:X-8}, ", Segment, Begin, End);
86409467b48Spatrick uint32_t Count = Block.LineNumbers.size();
86509467b48Spatrick if (Lines.hasColumnInfo())
86609467b48Spatrick P.format("line/column/addr entries = {0}", Count);
86709467b48Spatrick else
86809467b48Spatrick P.format("line/addr entries = {0}", Count);
86909467b48Spatrick
87009467b48Spatrick P.NewLine();
87109467b48Spatrick typesetLinesAndColumns(P, Begin, Block);
87209467b48Spatrick }
87309467b48Spatrick return Error::success();
874*d415bd75Srobert });
87509467b48Spatrick }
87609467b48Spatrick
dumpInlineeLines()87709467b48Spatrick Error DumpOutputStyle::dumpInlineeLines() {
87809467b48Spatrick printHeader(P, "Inlinee Lines");
87909467b48Spatrick
88009467b48Spatrick if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
88109467b48Spatrick printStreamNotPresent("DBI");
88209467b48Spatrick return Error::success();
88309467b48Spatrick }
88409467b48Spatrick
885*d415bd75Srobert return iterateModuleSubsections<DebugInlineeLinesSubsectionRef>(
88609467b48Spatrick File, PrintScope{P, 2},
88709467b48Spatrick [this](uint32_t Modi, const SymbolGroup &Strings,
888*d415bd75Srobert DebugInlineeLinesSubsectionRef &Lines) -> Error {
88909467b48Spatrick P.formatLine("{0,+8} | {1,+5} | {2}", "Inlinee", "Line", "Source File");
89009467b48Spatrick for (const auto &Entry : Lines) {
89109467b48Spatrick P.formatLine("{0,+8} | {1,+5} | ", Entry.Header->Inlinee,
89209467b48Spatrick fmtle(Entry.Header->SourceLineNum));
89309467b48Spatrick Strings.formatFromChecksumsOffset(P, Entry.Header->FileID, true);
89409467b48Spatrick for (const auto &ExtraFileID : Entry.ExtraFiles) {
89509467b48Spatrick P.formatLine(" ");
89609467b48Spatrick Strings.formatFromChecksumsOffset(P, ExtraFileID, true);
89709467b48Spatrick }
89809467b48Spatrick }
89909467b48Spatrick P.NewLine();
90009467b48Spatrick return Error::success();
901*d415bd75Srobert });
90209467b48Spatrick }
90309467b48Spatrick
dumpXmi()90409467b48Spatrick Error DumpOutputStyle::dumpXmi() {
90509467b48Spatrick printHeader(P, "Cross Module Imports");
90609467b48Spatrick
90709467b48Spatrick if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
90809467b48Spatrick printStreamNotPresent("DBI");
90909467b48Spatrick return Error::success();
91009467b48Spatrick }
91109467b48Spatrick
912*d415bd75Srobert return iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
91309467b48Spatrick File, PrintScope{P, 2},
91409467b48Spatrick [this](uint32_t Modi, const SymbolGroup &Strings,
915*d415bd75Srobert DebugCrossModuleImportsSubsectionRef &Imports) -> Error {
91609467b48Spatrick P.formatLine("{0,=32} | {1}", "Imported Module", "Type IDs");
91709467b48Spatrick
91809467b48Spatrick for (const auto &Xmi : Imports) {
91909467b48Spatrick auto ExpectedModule =
92009467b48Spatrick Strings.getNameFromStringTable(Xmi.Header->ModuleNameOffset);
92109467b48Spatrick StringRef Module;
92209467b48Spatrick SmallString<32> ModuleStorage;
92309467b48Spatrick if (!ExpectedModule) {
92409467b48Spatrick Module = "(unknown module)";
92509467b48Spatrick consumeError(ExpectedModule.takeError());
92609467b48Spatrick } else
92709467b48Spatrick Module = *ExpectedModule;
92809467b48Spatrick if (Module.size() > 32) {
92909467b48Spatrick ModuleStorage = "...";
93009467b48Spatrick ModuleStorage += Module.take_back(32 - 3);
93109467b48Spatrick Module = ModuleStorage;
93209467b48Spatrick }
93309467b48Spatrick std::vector<std::string> TIs;
93409467b48Spatrick for (const auto I : Xmi.Imports)
935097a140dSpatrick TIs.push_back(std::string(formatv("{0,+10:X+}", fmtle(I))));
93609467b48Spatrick std::string Result =
93709467b48Spatrick typesetItemList(TIs, P.getIndentLevel() + 35, 12, " ");
93809467b48Spatrick P.formatLine("{0,+32} | {1}", Module, Result);
93909467b48Spatrick }
94009467b48Spatrick return Error::success();
941*d415bd75Srobert });
94209467b48Spatrick }
94309467b48Spatrick
dumpXme()94409467b48Spatrick Error DumpOutputStyle::dumpXme() {
94509467b48Spatrick printHeader(P, "Cross Module Exports");
94609467b48Spatrick
94709467b48Spatrick if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
94809467b48Spatrick printStreamNotPresent("DBI");
94909467b48Spatrick return Error::success();
95009467b48Spatrick }
95109467b48Spatrick
952*d415bd75Srobert return iterateModuleSubsections<DebugCrossModuleExportsSubsectionRef>(
95309467b48Spatrick File, PrintScope{P, 2},
95409467b48Spatrick [this](uint32_t Modi, const SymbolGroup &Strings,
955*d415bd75Srobert DebugCrossModuleExportsSubsectionRef &Exports) -> Error {
95609467b48Spatrick P.formatLine("{0,-10} | {1}", "Local ID", "Global ID");
95709467b48Spatrick for (const auto &Export : Exports) {
95809467b48Spatrick P.formatLine("{0,+10:X+} | {1}", TypeIndex(Export.Local),
95909467b48Spatrick TypeIndex(Export.Global));
96009467b48Spatrick }
96109467b48Spatrick return Error::success();
962*d415bd75Srobert });
96309467b48Spatrick }
96409467b48Spatrick
formatFrameType(object::frame_type FT)96509467b48Spatrick std::string formatFrameType(object::frame_type FT) {
96609467b48Spatrick switch (FT) {
96709467b48Spatrick case object::frame_type::Fpo:
96809467b48Spatrick return "FPO";
96909467b48Spatrick case object::frame_type::NonFpo:
97009467b48Spatrick return "Non-FPO";
97109467b48Spatrick case object::frame_type::Trap:
97209467b48Spatrick return "Trap";
97309467b48Spatrick case object::frame_type::Tss:
97409467b48Spatrick return "TSS";
97509467b48Spatrick }
97609467b48Spatrick return "<unknown>";
97709467b48Spatrick }
97809467b48Spatrick
dumpOldFpo(PDBFile & File)97909467b48Spatrick Error DumpOutputStyle::dumpOldFpo(PDBFile &File) {
98009467b48Spatrick printHeader(P, "Old FPO Data");
98109467b48Spatrick
98209467b48Spatrick ExitOnError Err("Error dumping old fpo data:");
983*d415bd75Srobert DbiStream &Dbi = Err(File.getPDBDbiStream());
98409467b48Spatrick
98509467b48Spatrick if (!Dbi.hasOldFpoRecords()) {
98609467b48Spatrick printStreamNotPresent("FPO");
98709467b48Spatrick return Error::success();
98809467b48Spatrick }
98909467b48Spatrick
99009467b48Spatrick const FixedStreamArray<object::FpoData>& Records = Dbi.getOldFpoRecords();
99109467b48Spatrick
99209467b48Spatrick P.printLine(" RVA | Code | Locals | Params | Prolog | Saved Regs | Use "
99309467b48Spatrick "BP | Has SEH | Frame Type");
99409467b48Spatrick
99509467b48Spatrick for (const object::FpoData &FD : Records) {
99609467b48Spatrick P.formatLine("{0:X-8} | {1,4} | {2,6} | {3,6} | {4,6} | {5,10} | {6,6} | "
99709467b48Spatrick "{7,7} | {8,9}",
99809467b48Spatrick uint32_t(FD.Offset), uint32_t(FD.Size), uint32_t(FD.NumLocals),
99909467b48Spatrick uint32_t(FD.NumParams), FD.getPrologSize(),
100009467b48Spatrick FD.getNumSavedRegs(), FD.useBP(), FD.hasSEH(),
100109467b48Spatrick formatFrameType(FD.getFP()));
100209467b48Spatrick }
100309467b48Spatrick return Error::success();
100409467b48Spatrick }
100509467b48Spatrick
dumpNewFpo(PDBFile & File)100609467b48Spatrick Error DumpOutputStyle::dumpNewFpo(PDBFile &File) {
100709467b48Spatrick printHeader(P, "New FPO Data");
100809467b48Spatrick
100909467b48Spatrick ExitOnError Err("Error dumping new fpo data:");
1010*d415bd75Srobert DbiStream &Dbi = Err(File.getPDBDbiStream());
101109467b48Spatrick
101209467b48Spatrick if (!Dbi.hasNewFpoRecords()) {
101309467b48Spatrick printStreamNotPresent("New FPO");
101409467b48Spatrick return Error::success();
101509467b48Spatrick }
101609467b48Spatrick
101709467b48Spatrick const DebugFrameDataSubsectionRef& FDS = Dbi.getNewFpoRecords();
101809467b48Spatrick
101909467b48Spatrick P.printLine(" RVA | Code | Locals | Params | Stack | Prolog | Saved Regs "
102009467b48Spatrick "| Has SEH | Has C++EH | Start | Program");
102109467b48Spatrick for (const FrameData &FD : FDS) {
102209467b48Spatrick bool IsFuncStart = FD.Flags & FrameData::IsFunctionStart;
102309467b48Spatrick bool HasEH = FD.Flags & FrameData::HasEH;
102409467b48Spatrick bool HasSEH = FD.Flags & FrameData::HasSEH;
102509467b48Spatrick
102609467b48Spatrick auto &StringTable = Err(File.getStringTable());
102709467b48Spatrick
102809467b48Spatrick auto Program = Err(StringTable.getStringForID(FD.FrameFunc));
102909467b48Spatrick P.formatLine("{0:X-8} | {1,4} | {2,6} | {3,6} | {4,5} | {5,6} | {6,10} | "
103009467b48Spatrick "{7,7} | {8,9} | {9,5} | {10}",
103109467b48Spatrick uint32_t(FD.RvaStart), uint32_t(FD.CodeSize),
103209467b48Spatrick uint32_t(FD.LocalSize), uint32_t(FD.ParamsSize),
103309467b48Spatrick uint32_t(FD.MaxStackSize), uint16_t(FD.PrologSize),
103409467b48Spatrick uint16_t(FD.SavedRegsSize), HasSEH, HasEH, IsFuncStart,
103509467b48Spatrick Program);
103609467b48Spatrick }
103709467b48Spatrick return Error::success();
103809467b48Spatrick }
103909467b48Spatrick
dumpFpo()104009467b48Spatrick Error DumpOutputStyle::dumpFpo() {
104109467b48Spatrick if (!File.isPdb()) {
104209467b48Spatrick printStreamNotValidForObj();
104309467b48Spatrick return Error::success();
104409467b48Spatrick }
104509467b48Spatrick
104609467b48Spatrick PDBFile &File = getPdb();
104709467b48Spatrick if (!File.hasPDBDbiStream()) {
104809467b48Spatrick printStreamNotPresent("DBI");
104909467b48Spatrick return Error::success();
105009467b48Spatrick }
105109467b48Spatrick
105209467b48Spatrick if (auto EC = dumpOldFpo(File))
105309467b48Spatrick return EC;
105409467b48Spatrick if (auto EC = dumpNewFpo(File))
105509467b48Spatrick return EC;
105609467b48Spatrick return Error::success();
105709467b48Spatrick }
105809467b48Spatrick
dumpStringTableFromPdb()105909467b48Spatrick Error DumpOutputStyle::dumpStringTableFromPdb() {
106009467b48Spatrick AutoIndent Indent(P);
106109467b48Spatrick auto IS = getPdb().getStringTable();
106209467b48Spatrick if (!IS) {
106309467b48Spatrick P.formatLine("Not present in file");
106409467b48Spatrick consumeError(IS.takeError());
106509467b48Spatrick return Error::success();
106609467b48Spatrick }
106709467b48Spatrick
106809467b48Spatrick if (opts::dump::DumpStringTable) {
106909467b48Spatrick if (IS->name_ids().empty())
107009467b48Spatrick P.formatLine("Empty");
107109467b48Spatrick else {
107209467b48Spatrick auto MaxID =
107309467b48Spatrick std::max_element(IS->name_ids().begin(), IS->name_ids().end());
107409467b48Spatrick uint32_t Digits = NumDigits(*MaxID);
107509467b48Spatrick
107609467b48Spatrick P.formatLine("{0} | {1}", fmt_align("ID", AlignStyle::Right, Digits),
107709467b48Spatrick "String");
107809467b48Spatrick
107909467b48Spatrick std::vector<uint32_t> SortedIDs(IS->name_ids().begin(),
108009467b48Spatrick IS->name_ids().end());
108109467b48Spatrick llvm::sort(SortedIDs);
108209467b48Spatrick for (uint32_t I : SortedIDs) {
108309467b48Spatrick auto ES = IS->getStringForID(I);
108409467b48Spatrick llvm::SmallString<32> Str;
108509467b48Spatrick if (!ES) {
108609467b48Spatrick consumeError(ES.takeError());
108709467b48Spatrick Str = "Error reading string";
108809467b48Spatrick } else if (!ES->empty()) {
108909467b48Spatrick Str.append("'");
109009467b48Spatrick Str.append(*ES);
109109467b48Spatrick Str.append("'");
109209467b48Spatrick }
109309467b48Spatrick
109409467b48Spatrick if (!Str.empty())
109509467b48Spatrick P.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Digits),
109609467b48Spatrick Str);
109709467b48Spatrick }
109809467b48Spatrick }
109909467b48Spatrick }
110009467b48Spatrick
110109467b48Spatrick if (opts::dump::DumpStringTableDetails) {
110209467b48Spatrick P.NewLine();
110309467b48Spatrick {
110409467b48Spatrick P.printLine("String Table Header:");
110509467b48Spatrick AutoIndent Indent(P);
110609467b48Spatrick P.formatLine("Signature: {0}", IS->getSignature());
110709467b48Spatrick P.formatLine("Hash Version: {0}", IS->getHashVersion());
110809467b48Spatrick P.formatLine("Name Buffer Size: {0}", IS->getByteSize());
110909467b48Spatrick P.NewLine();
111009467b48Spatrick }
111109467b48Spatrick
111209467b48Spatrick BinaryStreamRef NameBuffer = IS->getStringTable().getBuffer();
111309467b48Spatrick ArrayRef<uint8_t> Contents;
111409467b48Spatrick cantFail(NameBuffer.readBytes(0, NameBuffer.getLength(), Contents));
111509467b48Spatrick P.formatBinary("Name Buffer", Contents, 0);
111609467b48Spatrick P.NewLine();
111709467b48Spatrick {
111809467b48Spatrick P.printLine("Hash Table:");
111909467b48Spatrick AutoIndent Indent(P);
112009467b48Spatrick P.formatLine("Bucket Count: {0}", IS->name_ids().size());
112109467b48Spatrick for (const auto &Entry : enumerate(IS->name_ids()))
112209467b48Spatrick P.formatLine("Bucket[{0}] : {1}", Entry.index(),
112309467b48Spatrick uint32_t(Entry.value()));
112409467b48Spatrick P.formatLine("Name Count: {0}", IS->getNameCount());
112509467b48Spatrick }
112609467b48Spatrick }
112709467b48Spatrick return Error::success();
112809467b48Spatrick }
112909467b48Spatrick
dumpStringTableFromObj()113009467b48Spatrick Error DumpOutputStyle::dumpStringTableFromObj() {
1131*d415bd75Srobert return iterateModuleSubsections<DebugStringTableSubsectionRef>(
113209467b48Spatrick File, PrintScope{P, 4},
113309467b48Spatrick [&](uint32_t Modi, const SymbolGroup &Strings,
1134*d415bd75Srobert DebugStringTableSubsectionRef &Strings2) -> Error {
113509467b48Spatrick BinaryStreamRef StringTableBuffer = Strings2.getBuffer();
113609467b48Spatrick BinaryStreamReader Reader(StringTableBuffer);
113709467b48Spatrick while (Reader.bytesRemaining() > 0) {
113809467b48Spatrick StringRef Str;
113909467b48Spatrick uint32_t Offset = Reader.getOffset();
114009467b48Spatrick cantFail(Reader.readCString(Str));
114109467b48Spatrick if (Str.empty())
114209467b48Spatrick continue;
114309467b48Spatrick
114409467b48Spatrick P.formatLine("{0} | {1}", fmt_align(Offset, AlignStyle::Right, 4),
114509467b48Spatrick Str);
114609467b48Spatrick }
114709467b48Spatrick return Error::success();
1148*d415bd75Srobert });
114909467b48Spatrick }
115009467b48Spatrick
dumpNamedStreams()115109467b48Spatrick Error DumpOutputStyle::dumpNamedStreams() {
115209467b48Spatrick printHeader(P, "Named Streams");
115309467b48Spatrick
115409467b48Spatrick if (File.isObj()) {
115509467b48Spatrick printStreamNotValidForObj();
115609467b48Spatrick return Error::success();
115709467b48Spatrick }
115809467b48Spatrick
115909467b48Spatrick AutoIndent Indent(P);
116009467b48Spatrick ExitOnError Err("Invalid PDB File: ");
116109467b48Spatrick
116209467b48Spatrick auto &IS = Err(File.pdb().getPDBInfoStream());
116309467b48Spatrick const NamedStreamMap &NS = IS.getNamedStreams();
116409467b48Spatrick for (const auto &Entry : NS.entries()) {
116509467b48Spatrick P.printLine(Entry.getKey());
116609467b48Spatrick AutoIndent Indent2(P, 2);
116709467b48Spatrick P.formatLine("Index: {0}", Entry.getValue());
116809467b48Spatrick P.formatLine("Size in bytes: {0}",
116909467b48Spatrick File.pdb().getStreamByteSize(Entry.getValue()));
117009467b48Spatrick }
117109467b48Spatrick
117209467b48Spatrick return Error::success();
117309467b48Spatrick }
117409467b48Spatrick
dumpStringTable()117509467b48Spatrick Error DumpOutputStyle::dumpStringTable() {
117609467b48Spatrick printHeader(P, "String Table");
117709467b48Spatrick
117809467b48Spatrick if (File.isPdb())
117909467b48Spatrick return dumpStringTableFromPdb();
118009467b48Spatrick
118109467b48Spatrick return dumpStringTableFromObj();
118209467b48Spatrick }
118309467b48Spatrick
buildDepSet(LazyRandomTypeCollection & Types,ArrayRef<TypeIndex> Indices,std::map<TypeIndex,CVType> & DepSet)118409467b48Spatrick static void buildDepSet(LazyRandomTypeCollection &Types,
118509467b48Spatrick ArrayRef<TypeIndex> Indices,
118609467b48Spatrick std::map<TypeIndex, CVType> &DepSet) {
118709467b48Spatrick SmallVector<TypeIndex, 4> DepList;
118809467b48Spatrick for (const auto &I : Indices) {
118909467b48Spatrick TypeIndex TI(I);
119009467b48Spatrick if (DepSet.find(TI) != DepSet.end() || TI.isSimple() || TI.isNoneType())
119109467b48Spatrick continue;
119209467b48Spatrick
119309467b48Spatrick CVType Type = Types.getType(TI);
119409467b48Spatrick DepSet[TI] = Type;
119509467b48Spatrick codeview::discoverTypeIndices(Type, DepList);
119609467b48Spatrick buildDepSet(Types, DepList, DepSet);
119709467b48Spatrick }
119809467b48Spatrick }
119909467b48Spatrick
120009467b48Spatrick static void
dumpFullTypeStream(LinePrinter & Printer,LazyRandomTypeCollection & Types,TypeReferenceTracker * RefTracker,uint32_t NumTypeRecords,uint32_t NumHashBuckets,FixedStreamArray<support::ulittle32_t> HashValues,TpiStream * Stream,bool Bytes,bool Extras)120109467b48Spatrick dumpFullTypeStream(LinePrinter &Printer, LazyRandomTypeCollection &Types,
120209467b48Spatrick TypeReferenceTracker *RefTracker, uint32_t NumTypeRecords,
120309467b48Spatrick uint32_t NumHashBuckets,
120409467b48Spatrick FixedStreamArray<support::ulittle32_t> HashValues,
120509467b48Spatrick TpiStream *Stream, bool Bytes, bool Extras) {
120609467b48Spatrick
120709467b48Spatrick Printer.formatLine("Showing {0:N} records", NumTypeRecords);
120809467b48Spatrick uint32_t Width = NumDigits(TypeIndex::FirstNonSimpleIndex + NumTypeRecords);
120909467b48Spatrick
121009467b48Spatrick MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types, RefTracker,
121109467b48Spatrick NumHashBuckets, HashValues, Stream);
121209467b48Spatrick
121309467b48Spatrick if (auto EC = codeview::visitTypeStream(Types, V)) {
121409467b48Spatrick Printer.formatLine("An error occurred dumping type records: {0}",
121509467b48Spatrick toString(std::move(EC)));
121609467b48Spatrick }
121709467b48Spatrick }
121809467b48Spatrick
dumpPartialTypeStream(LinePrinter & Printer,LazyRandomTypeCollection & Types,TypeReferenceTracker * RefTracker,TpiStream & Stream,ArrayRef<TypeIndex> TiList,bool Bytes,bool Extras,bool Deps)121909467b48Spatrick static void dumpPartialTypeStream(LinePrinter &Printer,
122009467b48Spatrick LazyRandomTypeCollection &Types,
122109467b48Spatrick TypeReferenceTracker *RefTracker,
122209467b48Spatrick TpiStream &Stream, ArrayRef<TypeIndex> TiList,
122309467b48Spatrick bool Bytes, bool Extras, bool Deps) {
122409467b48Spatrick uint32_t Width =
122509467b48Spatrick NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
122609467b48Spatrick
122709467b48Spatrick MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types, RefTracker,
122809467b48Spatrick Stream.getNumHashBuckets(), Stream.getHashValues(),
122909467b48Spatrick &Stream);
123009467b48Spatrick
123109467b48Spatrick if (opts::dump::DumpTypeDependents) {
123209467b48Spatrick // If we need to dump all dependents, then iterate each index and find
123309467b48Spatrick // all dependents, adding them to a map ordered by TypeIndex.
123409467b48Spatrick std::map<TypeIndex, CVType> DepSet;
123509467b48Spatrick buildDepSet(Types, TiList, DepSet);
123609467b48Spatrick
123709467b48Spatrick Printer.formatLine(
123809467b48Spatrick "Showing {0:N} records and their dependents ({1:N} records total)",
123909467b48Spatrick TiList.size(), DepSet.size());
124009467b48Spatrick
124109467b48Spatrick for (auto &Dep : DepSet) {
124209467b48Spatrick if (auto EC = codeview::visitTypeRecord(Dep.second, Dep.first, V))
124309467b48Spatrick Printer.formatLine("An error occurred dumping type record {0}: {1}",
124409467b48Spatrick Dep.first, toString(std::move(EC)));
124509467b48Spatrick }
124609467b48Spatrick } else {
124709467b48Spatrick Printer.formatLine("Showing {0:N} records.", TiList.size());
124809467b48Spatrick
124909467b48Spatrick for (const auto &I : TiList) {
125009467b48Spatrick TypeIndex TI(I);
1251*d415bd75Srobert if (TI.isSimple()) {
1252*d415bd75Srobert Printer.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Width),
1253*d415bd75Srobert Types.getTypeName(TI));
1254*d415bd75Srobert } else if (std::optional<CVType> Type = Types.tryGetType(TI)) {
1255*d415bd75Srobert if (auto EC = codeview::visitTypeRecord(*Type, TI, V))
1256*d415bd75Srobert Printer.formatLine("An error occurred dumping type record {0}: {1}",
1257*d415bd75Srobert TI, toString(std::move(EC)));
1258*d415bd75Srobert } else {
1259*d415bd75Srobert Printer.formatLine("Type {0} doesn't exist in TPI stream", TI);
1260*d415bd75Srobert }
126109467b48Spatrick }
126209467b48Spatrick }
126309467b48Spatrick }
126409467b48Spatrick
dumpTypesFromObjectFile()126509467b48Spatrick Error DumpOutputStyle::dumpTypesFromObjectFile() {
126609467b48Spatrick LazyRandomTypeCollection Types(100);
126709467b48Spatrick
126809467b48Spatrick for (const auto &S : getObj().sections()) {
126909467b48Spatrick Expected<StringRef> NameOrErr = S.getName();
127009467b48Spatrick if (!NameOrErr)
127109467b48Spatrick return NameOrErr.takeError();
127209467b48Spatrick StringRef SectionName = *NameOrErr;
127309467b48Spatrick
127409467b48Spatrick // .debug$T is a standard CodeView type section, while .debug$P is the same
127509467b48Spatrick // format but used for MSVC precompiled header object files.
127609467b48Spatrick if (SectionName == ".debug$T")
127709467b48Spatrick printHeader(P, "Types (.debug$T)");
127809467b48Spatrick else if (SectionName == ".debug$P")
127909467b48Spatrick printHeader(P, "Precompiled Types (.debug$P)");
128009467b48Spatrick else
128109467b48Spatrick continue;
128209467b48Spatrick
128309467b48Spatrick Expected<StringRef> ContentsOrErr = S.getContents();
128409467b48Spatrick if (!ContentsOrErr)
128509467b48Spatrick return ContentsOrErr.takeError();
128609467b48Spatrick
128709467b48Spatrick uint32_t Magic;
128809467b48Spatrick BinaryStreamReader Reader(*ContentsOrErr, llvm::support::little);
128909467b48Spatrick if (auto EC = Reader.readInteger(Magic))
129009467b48Spatrick return EC;
129109467b48Spatrick if (Magic != COFF::DEBUG_SECTION_MAGIC)
129209467b48Spatrick return make_error<StringError>("Invalid CodeView debug section.",
129309467b48Spatrick inconvertibleErrorCode());
129409467b48Spatrick
129509467b48Spatrick Types.reset(Reader, 100);
129609467b48Spatrick
129709467b48Spatrick if (opts::dump::DumpTypes) {
129809467b48Spatrick dumpFullTypeStream(P, Types, RefTracker.get(), 0, 0, {}, nullptr,
129909467b48Spatrick opts::dump::DumpTypeData, false);
130009467b48Spatrick } else if (opts::dump::DumpTypeExtras) {
130109467b48Spatrick auto LocalHashes = LocallyHashedType::hashTypeCollection(Types);
130209467b48Spatrick auto GlobalHashes = GloballyHashedType::hashTypeCollection(Types);
130309467b48Spatrick assert(LocalHashes.size() == GlobalHashes.size());
130409467b48Spatrick
130509467b48Spatrick P.formatLine("Local / Global hashes:");
130609467b48Spatrick TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
130709467b48Spatrick for (auto H : zip(LocalHashes, GlobalHashes)) {
130809467b48Spatrick AutoIndent Indent2(P);
130909467b48Spatrick LocallyHashedType &L = std::get<0>(H);
131009467b48Spatrick GloballyHashedType &G = std::get<1>(H);
131109467b48Spatrick
131209467b48Spatrick P.formatLine("TI: {0}, LocalHash: {1:X}, GlobalHash: {2}", TI, L, G);
131309467b48Spatrick
131409467b48Spatrick ++TI;
131509467b48Spatrick }
131609467b48Spatrick P.NewLine();
131709467b48Spatrick }
131809467b48Spatrick }
131909467b48Spatrick
132009467b48Spatrick return Error::success();
132109467b48Spatrick }
132209467b48Spatrick
dumpTpiStream(uint32_t StreamIdx)132309467b48Spatrick Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
132409467b48Spatrick assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
132509467b48Spatrick
132609467b48Spatrick if (StreamIdx == StreamTPI) {
132709467b48Spatrick printHeader(P, "Types (TPI Stream)");
132809467b48Spatrick } else if (StreamIdx == StreamIPI) {
132909467b48Spatrick printHeader(P, "Types (IPI Stream)");
133009467b48Spatrick }
133109467b48Spatrick
133209467b48Spatrick assert(!File.isObj());
133309467b48Spatrick
133409467b48Spatrick bool Present = false;
133509467b48Spatrick bool DumpTypes = false;
133609467b48Spatrick bool DumpBytes = false;
133709467b48Spatrick bool DumpExtras = false;
133809467b48Spatrick std::vector<uint32_t> Indices;
133909467b48Spatrick if (StreamIdx == StreamTPI) {
134009467b48Spatrick Present = getPdb().hasPDBTpiStream();
134109467b48Spatrick DumpTypes = opts::dump::DumpTypes;
134209467b48Spatrick DumpBytes = opts::dump::DumpTypeData;
134309467b48Spatrick DumpExtras = opts::dump::DumpTypeExtras;
134409467b48Spatrick Indices.assign(opts::dump::DumpTypeIndex.begin(),
134509467b48Spatrick opts::dump::DumpTypeIndex.end());
134609467b48Spatrick } else if (StreamIdx == StreamIPI) {
134709467b48Spatrick Present = getPdb().hasPDBIpiStream();
134809467b48Spatrick DumpTypes = opts::dump::DumpIds;
134909467b48Spatrick DumpBytes = opts::dump::DumpIdData;
135009467b48Spatrick DumpExtras = opts::dump::DumpIdExtras;
135109467b48Spatrick Indices.assign(opts::dump::DumpIdIndex.begin(),
135209467b48Spatrick opts::dump::DumpIdIndex.end());
135309467b48Spatrick }
135409467b48Spatrick
135509467b48Spatrick if (!Present) {
135609467b48Spatrick printStreamNotPresent(StreamIdx == StreamTPI ? "TPI" : "IPI");
135709467b48Spatrick return Error::success();
135809467b48Spatrick }
135909467b48Spatrick
136009467b48Spatrick AutoIndent Indent(P);
136109467b48Spatrick ExitOnError Err("Unexpected error processing types: ");
136209467b48Spatrick
136309467b48Spatrick auto &Stream = Err((StreamIdx == StreamTPI) ? getPdb().getPDBTpiStream()
136409467b48Spatrick : getPdb().getPDBIpiStream());
136509467b48Spatrick
136609467b48Spatrick auto &Types = (StreamIdx == StreamTPI) ? File.types() : File.ids();
136709467b48Spatrick
136809467b48Spatrick // Only emit notes about referenced/unreferenced for types.
136909467b48Spatrick TypeReferenceTracker *MaybeTracker =
137009467b48Spatrick (StreamIdx == StreamTPI) ? RefTracker.get() : nullptr;
137109467b48Spatrick
137209467b48Spatrick // Enable resolving forward decls.
137309467b48Spatrick Stream.buildHashMap();
137409467b48Spatrick
137509467b48Spatrick if (DumpTypes || !Indices.empty()) {
137609467b48Spatrick if (Indices.empty())
137709467b48Spatrick dumpFullTypeStream(P, Types, MaybeTracker, Stream.getNumTypeRecords(),
137809467b48Spatrick Stream.getNumHashBuckets(), Stream.getHashValues(),
137909467b48Spatrick &Stream, DumpBytes, DumpExtras);
138009467b48Spatrick else {
138109467b48Spatrick std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
138209467b48Spatrick dumpPartialTypeStream(P, Types, MaybeTracker, Stream, TiList, DumpBytes,
138309467b48Spatrick DumpExtras, opts::dump::DumpTypeDependents);
138409467b48Spatrick }
138509467b48Spatrick }
138609467b48Spatrick
138709467b48Spatrick if (DumpExtras) {
138809467b48Spatrick P.NewLine();
138909467b48Spatrick
139009467b48Spatrick P.formatLine("Header Version: {0}",
139109467b48Spatrick static_cast<uint32_t>(Stream.getTpiVersion()));
139209467b48Spatrick P.formatLine("Hash Stream Index: {0}", Stream.getTypeHashStreamIndex());
139309467b48Spatrick P.formatLine("Aux Hash Stream Index: {0}",
139409467b48Spatrick Stream.getTypeHashStreamAuxIndex());
139509467b48Spatrick P.formatLine("Hash Key Size: {0}", Stream.getHashKeySize());
139609467b48Spatrick P.formatLine("Num Hash Buckets: {0}", Stream.getNumHashBuckets());
139709467b48Spatrick
139809467b48Spatrick auto IndexOffsets = Stream.getTypeIndexOffsets();
139909467b48Spatrick P.formatLine("Type Index Offsets:");
140009467b48Spatrick for (const auto &IO : IndexOffsets) {
140109467b48Spatrick AutoIndent Indent2(P);
140209467b48Spatrick P.formatLine("TI: {0}, Offset: {1}", IO.Type, fmtle(IO.Offset));
140309467b48Spatrick }
140409467b48Spatrick
140509467b48Spatrick if (getPdb().hasPDBStringTable()) {
140609467b48Spatrick P.NewLine();
140709467b48Spatrick P.formatLine("Hash Adjusters:");
140809467b48Spatrick auto &Adjusters = Stream.getHashAdjusters();
140909467b48Spatrick auto &Strings = Err(getPdb().getStringTable());
141009467b48Spatrick for (const auto &A : Adjusters) {
141109467b48Spatrick AutoIndent Indent2(P);
141209467b48Spatrick auto ExpectedStr = Strings.getStringForID(A.first);
141309467b48Spatrick TypeIndex TI(A.second);
141409467b48Spatrick if (ExpectedStr)
141509467b48Spatrick P.formatLine("`{0}` -> {1}", *ExpectedStr, TI);
141609467b48Spatrick else {
141709467b48Spatrick P.formatLine("unknown str id ({0}) -> {1}", A.first, TI);
141809467b48Spatrick consumeError(ExpectedStr.takeError());
141909467b48Spatrick }
142009467b48Spatrick }
142109467b48Spatrick }
142209467b48Spatrick }
142309467b48Spatrick return Error::success();
142409467b48Spatrick }
142509467b48Spatrick
dumpModuleSymsForObj()142609467b48Spatrick Error DumpOutputStyle::dumpModuleSymsForObj() {
142709467b48Spatrick printHeader(P, "Symbols");
142809467b48Spatrick
142909467b48Spatrick AutoIndent Indent(P);
143009467b48Spatrick
143109467b48Spatrick auto &Types = File.types();
143209467b48Spatrick
143309467b48Spatrick SymbolVisitorCallbackPipeline Pipeline;
143409467b48Spatrick SymbolDeserializer Deserializer(nullptr, CodeViewContainer::ObjectFile);
143509467b48Spatrick MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Types, Types);
143609467b48Spatrick
143709467b48Spatrick Pipeline.addCallbackToPipeline(Deserializer);
143809467b48Spatrick Pipeline.addCallbackToPipeline(Dumper);
143909467b48Spatrick CVSymbolVisitor Visitor(Pipeline);
144009467b48Spatrick
1441*d415bd75Srobert return iterateModuleSubsections<DebugSymbolsSubsectionRef>(
144209467b48Spatrick File, PrintScope{P, 2},
144309467b48Spatrick [&](uint32_t Modi, const SymbolGroup &Strings,
1444*d415bd75Srobert DebugSymbolsSubsectionRef &Symbols) -> Error {
144509467b48Spatrick Dumper.setSymbolGroup(&Strings);
144609467b48Spatrick for (auto Symbol : Symbols) {
144709467b48Spatrick if (auto EC = Visitor.visitSymbolRecord(Symbol)) {
1448*d415bd75Srobert return EC;
144909467b48Spatrick }
145009467b48Spatrick }
145109467b48Spatrick return Error::success();
1452*d415bd75Srobert });
145309467b48Spatrick }
145409467b48Spatrick
dumpModuleSymsForPdb()145509467b48Spatrick Error DumpOutputStyle::dumpModuleSymsForPdb() {
145609467b48Spatrick printHeader(P, "Symbols");
145709467b48Spatrick
145809467b48Spatrick if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
145909467b48Spatrick printStreamNotPresent("DBI");
146009467b48Spatrick return Error::success();
146109467b48Spatrick }
146209467b48Spatrick
146309467b48Spatrick AutoIndent Indent(P);
146409467b48Spatrick
146509467b48Spatrick auto &Ids = File.ids();
146609467b48Spatrick auto &Types = File.types();
146709467b48Spatrick
1468*d415bd75Srobert return iterateSymbolGroups(
1469*d415bd75Srobert File, PrintScope{P, 2},
1470*d415bd75Srobert [&](uint32_t I, const SymbolGroup &Strings) -> Error {
147109467b48Spatrick auto ExpectedModS = getModuleDebugStream(File.pdb(), I);
147209467b48Spatrick if (!ExpectedModS) {
147309467b48Spatrick P.formatLine("Error loading module stream {0}. {1}", I,
147409467b48Spatrick toString(ExpectedModS.takeError()));
1475*d415bd75Srobert return Error::success();
147609467b48Spatrick }
147709467b48Spatrick
147809467b48Spatrick ModuleDebugStreamRef &ModS = *ExpectedModS;
147909467b48Spatrick
148009467b48Spatrick SymbolVisitorCallbackPipeline Pipeline;
148109467b48Spatrick SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
148209467b48Spatrick MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Strings,
148309467b48Spatrick Ids, Types);
148409467b48Spatrick
148509467b48Spatrick Pipeline.addCallbackToPipeline(Deserializer);
148609467b48Spatrick Pipeline.addCallbackToPipeline(Dumper);
148709467b48Spatrick CVSymbolVisitor Visitor(Pipeline);
148809467b48Spatrick auto SS = ModS.getSymbolsSubstream();
1489*d415bd75Srobert if (opts::Filters.SymbolOffset) {
1490*d415bd75Srobert CVSymbolVisitor::FilterOptions Filter;
1491*d415bd75Srobert Filter.SymbolOffset = opts::Filters.SymbolOffset;
1492*d415bd75Srobert Filter.ParentRecursiveDepth = opts::Filters.ParentRecurseDepth;
1493*d415bd75Srobert Filter.ChildRecursiveDepth = opts::Filters.ChildrenRecurseDepth;
1494*d415bd75Srobert if (auto EC = Visitor.visitSymbolStreamFiltered(ModS.getSymbolArray(),
1495*d415bd75Srobert Filter)) {
149609467b48Spatrick P.formatLine("Error while processing symbol records. {0}",
149709467b48Spatrick toString(std::move(EC)));
1498*d415bd75Srobert return EC;
149909467b48Spatrick }
1500*d415bd75Srobert } else if (auto EC = Visitor.visitSymbolStream(ModS.getSymbolArray(),
1501*d415bd75Srobert SS.Offset)) {
1502*d415bd75Srobert P.formatLine("Error while processing symbol records. {0}",
1503*d415bd75Srobert toString(std::move(EC)));
1504*d415bd75Srobert return EC;
1505*d415bd75Srobert }
150609467b48Spatrick return Error::success();
1507*d415bd75Srobert });
150809467b48Spatrick }
150909467b48Spatrick
dumpTypeRefStats()151009467b48Spatrick Error DumpOutputStyle::dumpTypeRefStats() {
151109467b48Spatrick printHeader(P, "Type Reference Statistics");
151209467b48Spatrick AutoIndent Indent(P);
151309467b48Spatrick
151409467b48Spatrick // Sum the byte size of all type records, and the size and count of all
151509467b48Spatrick // referenced records.
151609467b48Spatrick size_t TotalRecs = File.types().size();
151709467b48Spatrick size_t RefRecs = 0;
151809467b48Spatrick size_t TotalBytes = 0;
151909467b48Spatrick size_t RefBytes = 0;
152009467b48Spatrick auto &Types = File.types();
1521*d415bd75Srobert for (std::optional<TypeIndex> TI = Types.getFirst(); TI;
1522*d415bd75Srobert TI = Types.getNext(*TI)) {
152309467b48Spatrick CVType Type = File.types().getType(*TI);
152409467b48Spatrick TotalBytes += Type.length();
152509467b48Spatrick if (RefTracker->isTypeReferenced(*TI)) {
152609467b48Spatrick ++RefRecs;
152709467b48Spatrick RefBytes += Type.length();
152809467b48Spatrick }
152909467b48Spatrick }
153009467b48Spatrick
153109467b48Spatrick P.formatLine("Records referenced: {0:N} / {1:N} {2:P}", RefRecs, TotalRecs,
153209467b48Spatrick (double)RefRecs / TotalRecs);
153309467b48Spatrick P.formatLine("Bytes referenced: {0:N} / {1:N} {2:P}", RefBytes, TotalBytes,
153409467b48Spatrick (double)RefBytes / TotalBytes);
153509467b48Spatrick
153609467b48Spatrick return Error::success();
153709467b48Spatrick }
153809467b48Spatrick
dumpGSIRecords()153909467b48Spatrick Error DumpOutputStyle::dumpGSIRecords() {
154009467b48Spatrick printHeader(P, "GSI Records");
154109467b48Spatrick
154209467b48Spatrick if (File.isObj()) {
154309467b48Spatrick printStreamNotValidForObj();
154409467b48Spatrick return Error::success();
154509467b48Spatrick }
154609467b48Spatrick
154709467b48Spatrick if (!getPdb().hasPDBSymbolStream()) {
154809467b48Spatrick printStreamNotPresent("GSI Common Symbol");
154909467b48Spatrick return Error::success();
155009467b48Spatrick }
155109467b48Spatrick
155209467b48Spatrick AutoIndent Indent(P);
155309467b48Spatrick
155409467b48Spatrick auto &Records = cantFail(getPdb().getPDBSymbolStream());
155509467b48Spatrick auto &Types = File.types();
155609467b48Spatrick auto &Ids = File.ids();
155709467b48Spatrick
155809467b48Spatrick P.printLine("Records");
155909467b48Spatrick SymbolVisitorCallbackPipeline Pipeline;
156009467b48Spatrick SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
156109467b48Spatrick MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
156209467b48Spatrick
156309467b48Spatrick Pipeline.addCallbackToPipeline(Deserializer);
156409467b48Spatrick Pipeline.addCallbackToPipeline(Dumper);
156509467b48Spatrick CVSymbolVisitor Visitor(Pipeline);
156609467b48Spatrick
156709467b48Spatrick BinaryStreamRef SymStream = Records.getSymbolArray().getUnderlyingStream();
156809467b48Spatrick if (auto E = Visitor.visitSymbolStream(Records.getSymbolArray(), 0))
156909467b48Spatrick return E;
157009467b48Spatrick return Error::success();
157109467b48Spatrick }
157209467b48Spatrick
dumpGlobals()157309467b48Spatrick Error DumpOutputStyle::dumpGlobals() {
157409467b48Spatrick printHeader(P, "Global Symbols");
157509467b48Spatrick
157609467b48Spatrick if (File.isObj()) {
157709467b48Spatrick printStreamNotValidForObj();
157809467b48Spatrick return Error::success();
157909467b48Spatrick }
158009467b48Spatrick
158109467b48Spatrick if (!getPdb().hasPDBGlobalsStream()) {
158209467b48Spatrick printStreamNotPresent("Globals");
158309467b48Spatrick return Error::success();
158409467b48Spatrick }
158509467b48Spatrick
158609467b48Spatrick AutoIndent Indent(P);
158709467b48Spatrick ExitOnError Err("Error dumping globals stream: ");
158809467b48Spatrick auto &Globals = Err(getPdb().getPDBGlobalsStream());
158909467b48Spatrick
159009467b48Spatrick if (opts::dump::DumpGlobalNames.empty()) {
159109467b48Spatrick const GSIHashTable &Table = Globals.getGlobalsTable();
159209467b48Spatrick Err(dumpSymbolsFromGSI(Table, opts::dump::DumpGlobalExtras));
159309467b48Spatrick } else {
159409467b48Spatrick SymbolStream &SymRecords = cantFail(getPdb().getPDBSymbolStream());
159509467b48Spatrick auto &Types = File.types();
159609467b48Spatrick auto &Ids = File.ids();
159709467b48Spatrick
159809467b48Spatrick SymbolVisitorCallbackPipeline Pipeline;
159909467b48Spatrick SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
160009467b48Spatrick MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
160109467b48Spatrick
160209467b48Spatrick Pipeline.addCallbackToPipeline(Deserializer);
160309467b48Spatrick Pipeline.addCallbackToPipeline(Dumper);
160409467b48Spatrick CVSymbolVisitor Visitor(Pipeline);
160509467b48Spatrick
160609467b48Spatrick using ResultEntryType = std::pair<uint32_t, CVSymbol>;
160709467b48Spatrick for (StringRef Name : opts::dump::DumpGlobalNames) {
160809467b48Spatrick AutoIndent Indent(P);
160909467b48Spatrick P.formatLine("Global Name `{0}`", Name);
161009467b48Spatrick std::vector<ResultEntryType> Results =
161109467b48Spatrick Globals.findRecordsByName(Name, SymRecords);
161209467b48Spatrick if (Results.empty()) {
161309467b48Spatrick AutoIndent Indent(P);
161409467b48Spatrick P.printLine("(no matching records found)");
161509467b48Spatrick continue;
161609467b48Spatrick }
161709467b48Spatrick
161809467b48Spatrick for (ResultEntryType Result : Results) {
161909467b48Spatrick if (auto E = Visitor.visitSymbolRecord(Result.second, Result.first))
162009467b48Spatrick return E;
162109467b48Spatrick }
162209467b48Spatrick }
162309467b48Spatrick }
162409467b48Spatrick return Error::success();
162509467b48Spatrick }
162609467b48Spatrick
dumpPublics()162709467b48Spatrick Error DumpOutputStyle::dumpPublics() {
162809467b48Spatrick printHeader(P, "Public Symbols");
162909467b48Spatrick
163009467b48Spatrick if (File.isObj()) {
163109467b48Spatrick printStreamNotValidForObj();
163209467b48Spatrick return Error::success();
163309467b48Spatrick }
163409467b48Spatrick
163509467b48Spatrick if (!getPdb().hasPDBPublicsStream()) {
163609467b48Spatrick printStreamNotPresent("Publics");
163709467b48Spatrick return Error::success();
163809467b48Spatrick }
163909467b48Spatrick
164009467b48Spatrick AutoIndent Indent(P);
164109467b48Spatrick ExitOnError Err("Error dumping publics stream: ");
164209467b48Spatrick auto &Publics = Err(getPdb().getPDBPublicsStream());
164309467b48Spatrick
164409467b48Spatrick const GSIHashTable &PublicsTable = Publics.getPublicsTable();
164509467b48Spatrick if (opts::dump::DumpPublicExtras) {
164609467b48Spatrick P.printLine("Publics Header");
164709467b48Spatrick AutoIndent Indent(P);
164809467b48Spatrick P.formatLine("sym hash = {0}, thunk table addr = {1}", Publics.getSymHash(),
164909467b48Spatrick formatSegmentOffset(Publics.getThunkTableSection(),
165009467b48Spatrick Publics.getThunkTableOffset()));
165109467b48Spatrick }
165209467b48Spatrick Err(dumpSymbolsFromGSI(PublicsTable, opts::dump::DumpPublicExtras));
165309467b48Spatrick
165409467b48Spatrick // Skip the rest if we aren't dumping extras.
165509467b48Spatrick if (!opts::dump::DumpPublicExtras)
165609467b48Spatrick return Error::success();
165709467b48Spatrick
165809467b48Spatrick P.formatLine("Address Map");
165909467b48Spatrick {
166009467b48Spatrick // These are offsets into the publics stream sorted by secidx:secrel.
166109467b48Spatrick AutoIndent Indent2(P);
166209467b48Spatrick for (uint32_t Addr : Publics.getAddressMap())
166309467b48Spatrick P.formatLine("off = {0}", Addr);
166409467b48Spatrick }
166509467b48Spatrick
166609467b48Spatrick // The thunk map is optional debug info used for ILT thunks.
166709467b48Spatrick if (!Publics.getThunkMap().empty()) {
166809467b48Spatrick P.formatLine("Thunk Map");
166909467b48Spatrick AutoIndent Indent2(P);
167009467b48Spatrick for (uint32_t Addr : Publics.getThunkMap())
167109467b48Spatrick P.formatLine("{0:x8}", Addr);
167209467b48Spatrick }
167309467b48Spatrick
167409467b48Spatrick // The section offsets table appears to be empty when incremental linking
167509467b48Spatrick // isn't in use.
167609467b48Spatrick if (!Publics.getSectionOffsets().empty()) {
167709467b48Spatrick P.formatLine("Section Offsets");
167809467b48Spatrick AutoIndent Indent2(P);
167909467b48Spatrick for (const SectionOffset &SO : Publics.getSectionOffsets())
168009467b48Spatrick P.formatLine("{0:x4}:{1:x8}", uint16_t(SO.Isect), uint32_t(SO.Off));
168109467b48Spatrick }
168209467b48Spatrick
168309467b48Spatrick return Error::success();
168409467b48Spatrick }
168509467b48Spatrick
dumpSymbolsFromGSI(const GSIHashTable & Table,bool HashExtras)168609467b48Spatrick Error DumpOutputStyle::dumpSymbolsFromGSI(const GSIHashTable &Table,
168709467b48Spatrick bool HashExtras) {
168809467b48Spatrick auto ExpectedSyms = getPdb().getPDBSymbolStream();
168909467b48Spatrick if (!ExpectedSyms)
169009467b48Spatrick return ExpectedSyms.takeError();
169109467b48Spatrick auto &Types = File.types();
169209467b48Spatrick auto &Ids = File.ids();
169309467b48Spatrick
169409467b48Spatrick if (HashExtras) {
169509467b48Spatrick P.printLine("GSI Header");
169609467b48Spatrick AutoIndent Indent(P);
169709467b48Spatrick P.formatLine("sig = {0:X}, hdr = {1:X}, hr size = {2}, num buckets = {3}",
169809467b48Spatrick Table.getVerSignature(), Table.getVerHeader(),
169909467b48Spatrick Table.getHashRecordSize(), Table.getNumBuckets());
170009467b48Spatrick }
170109467b48Spatrick
170209467b48Spatrick {
170309467b48Spatrick P.printLine("Records");
170409467b48Spatrick SymbolVisitorCallbackPipeline Pipeline;
170509467b48Spatrick SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
170609467b48Spatrick MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
170709467b48Spatrick
170809467b48Spatrick Pipeline.addCallbackToPipeline(Deserializer);
170909467b48Spatrick Pipeline.addCallbackToPipeline(Dumper);
171009467b48Spatrick CVSymbolVisitor Visitor(Pipeline);
171109467b48Spatrick
171209467b48Spatrick
171309467b48Spatrick BinaryStreamRef SymStream =
171409467b48Spatrick ExpectedSyms->getSymbolArray().getUnderlyingStream();
171509467b48Spatrick for (uint32_t PubSymOff : Table) {
171609467b48Spatrick Expected<CVSymbol> Sym = readSymbolFromStream(SymStream, PubSymOff);
171709467b48Spatrick if (!Sym)
171809467b48Spatrick return Sym.takeError();
171909467b48Spatrick if (auto E = Visitor.visitSymbolRecord(*Sym, PubSymOff))
172009467b48Spatrick return E;
172109467b48Spatrick }
172209467b48Spatrick }
172309467b48Spatrick
172409467b48Spatrick // Return early if we aren't dumping public hash table and address map info.
172509467b48Spatrick if (HashExtras) {
172609467b48Spatrick P.formatLine("Hash Entries");
172709467b48Spatrick {
172809467b48Spatrick AutoIndent Indent2(P);
172909467b48Spatrick for (const PSHashRecord &HR : Table.HashRecords)
173009467b48Spatrick P.formatLine("off = {0}, refcnt = {1}", uint32_t(HR.Off),
173109467b48Spatrick uint32_t(HR.CRef));
173209467b48Spatrick }
173309467b48Spatrick
173409467b48Spatrick P.formatLine("Hash Buckets");
173509467b48Spatrick {
173609467b48Spatrick AutoIndent Indent2(P);
173709467b48Spatrick for (uint32_t Hash : Table.HashBuckets)
173809467b48Spatrick P.formatLine("{0:x8}", Hash);
173909467b48Spatrick }
174009467b48Spatrick }
174109467b48Spatrick
174209467b48Spatrick return Error::success();
174309467b48Spatrick }
174409467b48Spatrick
formatSegMapDescriptorFlag(uint32_t IndentLevel,OMFSegDescFlags Flags)174509467b48Spatrick static std::string formatSegMapDescriptorFlag(uint32_t IndentLevel,
174609467b48Spatrick OMFSegDescFlags Flags) {
174709467b48Spatrick std::vector<std::string> Opts;
174809467b48Spatrick if (Flags == OMFSegDescFlags::None)
174909467b48Spatrick return "none";
175009467b48Spatrick
175109467b48Spatrick PUSH_FLAG(OMFSegDescFlags, Read, Flags, "read");
175209467b48Spatrick PUSH_FLAG(OMFSegDescFlags, Write, Flags, "write");
175309467b48Spatrick PUSH_FLAG(OMFSegDescFlags, Execute, Flags, "execute");
175409467b48Spatrick PUSH_FLAG(OMFSegDescFlags, AddressIs32Bit, Flags, "32 bit addr");
175509467b48Spatrick PUSH_FLAG(OMFSegDescFlags, IsSelector, Flags, "selector");
175609467b48Spatrick PUSH_FLAG(OMFSegDescFlags, IsAbsoluteAddress, Flags, "absolute addr");
175709467b48Spatrick PUSH_FLAG(OMFSegDescFlags, IsGroup, Flags, "group");
175809467b48Spatrick return typesetItemList(Opts, IndentLevel, 4, " | ");
175909467b48Spatrick }
176009467b48Spatrick
dumpSectionHeaders()176109467b48Spatrick Error DumpOutputStyle::dumpSectionHeaders() {
176209467b48Spatrick dumpSectionHeaders("Section Headers", DbgHeaderType::SectionHdr);
176309467b48Spatrick dumpSectionHeaders("Original Section Headers", DbgHeaderType::SectionHdrOrig);
176409467b48Spatrick return Error::success();
176509467b48Spatrick }
176609467b48Spatrick
dumpSectionHeaders(StringRef Label,DbgHeaderType Type)176709467b48Spatrick void DumpOutputStyle::dumpSectionHeaders(StringRef Label, DbgHeaderType Type) {
176809467b48Spatrick printHeader(P, Label);
176909467b48Spatrick
177009467b48Spatrick if (File.isObj()) {
177109467b48Spatrick printStreamNotValidForObj();
177209467b48Spatrick return;
177309467b48Spatrick }
177409467b48Spatrick
177509467b48Spatrick if (!getPdb().hasPDBDbiStream()) {
177609467b48Spatrick printStreamNotPresent("DBI");
177709467b48Spatrick return;
177809467b48Spatrick }
177909467b48Spatrick
178009467b48Spatrick AutoIndent Indent(P);
178109467b48Spatrick ExitOnError Err("Error dumping section headers: ");
178209467b48Spatrick std::unique_ptr<MappedBlockStream> Stream;
178309467b48Spatrick ArrayRef<object::coff_section> Headers;
178409467b48Spatrick auto ExpectedHeaders = loadSectionHeaders(getPdb(), Type);
178509467b48Spatrick if (!ExpectedHeaders) {
178609467b48Spatrick P.printLine(toString(ExpectedHeaders.takeError()));
178709467b48Spatrick return;
178809467b48Spatrick }
178909467b48Spatrick std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
179009467b48Spatrick
179109467b48Spatrick uint32_t I = 1;
179209467b48Spatrick for (const auto &Header : Headers) {
179309467b48Spatrick P.NewLine();
179409467b48Spatrick P.formatLine("SECTION HEADER #{0}", I);
179509467b48Spatrick P.formatLine("{0,8} name", Header.Name);
179609467b48Spatrick P.formatLine("{0,8:X-} virtual size", uint32_t(Header.VirtualSize));
179709467b48Spatrick P.formatLine("{0,8:X-} virtual address", uint32_t(Header.VirtualAddress));
179809467b48Spatrick P.formatLine("{0,8:X-} size of raw data", uint32_t(Header.SizeOfRawData));
179909467b48Spatrick P.formatLine("{0,8:X-} file pointer to raw data",
180009467b48Spatrick uint32_t(Header.PointerToRawData));
180109467b48Spatrick P.formatLine("{0,8:X-} file pointer to relocation table",
180209467b48Spatrick uint32_t(Header.PointerToRelocations));
180309467b48Spatrick P.formatLine("{0,8:X-} file pointer to line numbers",
180409467b48Spatrick uint32_t(Header.PointerToLinenumbers));
180509467b48Spatrick P.formatLine("{0,8:X-} number of relocations",
180609467b48Spatrick uint32_t(Header.NumberOfRelocations));
180709467b48Spatrick P.formatLine("{0,8:X-} number of line numbers",
180809467b48Spatrick uint32_t(Header.NumberOfLinenumbers));
180909467b48Spatrick P.formatLine("{0,8:X-} flags", uint32_t(Header.Characteristics));
181009467b48Spatrick AutoIndent IndentMore(P, 9);
181109467b48Spatrick P.formatLine("{0}", formatSectionCharacteristics(
181209467b48Spatrick P.getIndentLevel(), Header.Characteristics, 1, ""));
181309467b48Spatrick ++I;
181409467b48Spatrick }
181509467b48Spatrick }
181609467b48Spatrick
dumpSectionContribs()181709467b48Spatrick Error DumpOutputStyle::dumpSectionContribs() {
181809467b48Spatrick printHeader(P, "Section Contributions");
181909467b48Spatrick
182009467b48Spatrick if (File.isObj()) {
182109467b48Spatrick printStreamNotValidForObj();
182209467b48Spatrick return Error::success();
182309467b48Spatrick }
182409467b48Spatrick
182509467b48Spatrick if (!getPdb().hasPDBDbiStream()) {
182609467b48Spatrick printStreamNotPresent("DBI");
182709467b48Spatrick return Error::success();
182809467b48Spatrick }
182909467b48Spatrick
183009467b48Spatrick AutoIndent Indent(P);
183109467b48Spatrick ExitOnError Err("Error dumping section contributions: ");
183209467b48Spatrick
1833*d415bd75Srobert DbiStream &Dbi = Err(getPdb().getPDBDbiStream());
183409467b48Spatrick
183509467b48Spatrick class Visitor : public ISectionContribVisitor {
183609467b48Spatrick public:
183709467b48Spatrick Visitor(LinePrinter &P, ArrayRef<std::string> Names) : P(P), Names(Names) {
183809467b48Spatrick auto Max = std::max_element(
183909467b48Spatrick Names.begin(), Names.end(),
184009467b48Spatrick [](StringRef S1, StringRef S2) { return S1.size() < S2.size(); });
184109467b48Spatrick MaxNameLen = (Max == Names.end() ? 0 : Max->size());
184209467b48Spatrick }
184309467b48Spatrick void visit(const SectionContrib &SC) override {
184409467b48Spatrick dumpSectionContrib(P, SC, Names, MaxNameLen);
184509467b48Spatrick }
184609467b48Spatrick void visit(const SectionContrib2 &SC) override {
184709467b48Spatrick dumpSectionContrib(P, SC, Names, MaxNameLen);
184809467b48Spatrick }
184909467b48Spatrick
185009467b48Spatrick private:
185109467b48Spatrick LinePrinter &P;
185209467b48Spatrick uint32_t MaxNameLen;
185309467b48Spatrick ArrayRef<std::string> Names;
185409467b48Spatrick };
185509467b48Spatrick
1856*d415bd75Srobert auto NamesOrErr = getSectionNames(getPdb());
1857*d415bd75Srobert if (!NamesOrErr)
1858*d415bd75Srobert return NamesOrErr.takeError();
1859*d415bd75Srobert ArrayRef<std::string> Names = *NamesOrErr;
1860*d415bd75Srobert Visitor V(P, Names);
186109467b48Spatrick Dbi.visitSectionContributions(V);
186209467b48Spatrick return Error::success();
186309467b48Spatrick }
186409467b48Spatrick
dumpSectionMap()186509467b48Spatrick Error DumpOutputStyle::dumpSectionMap() {
186609467b48Spatrick printHeader(P, "Section Map");
186709467b48Spatrick
186809467b48Spatrick if (File.isObj()) {
186909467b48Spatrick printStreamNotValidForObj();
187009467b48Spatrick return Error::success();
187109467b48Spatrick }
187209467b48Spatrick
187309467b48Spatrick if (!getPdb().hasPDBDbiStream()) {
187409467b48Spatrick printStreamNotPresent("DBI");
187509467b48Spatrick return Error::success();
187609467b48Spatrick }
187709467b48Spatrick
187809467b48Spatrick AutoIndent Indent(P);
187909467b48Spatrick ExitOnError Err("Error dumping section map: ");
188009467b48Spatrick
1881*d415bd75Srobert DbiStream &Dbi = Err(getPdb().getPDBDbiStream());
188209467b48Spatrick
188309467b48Spatrick uint32_t I = 0;
188409467b48Spatrick for (auto &M : Dbi.getSectionMap()) {
188509467b48Spatrick P.formatLine(
188609467b48Spatrick "Section {0:4} | ovl = {1}, group = {2}, frame = {3}, name = {4}", I,
188709467b48Spatrick fmtle(M.Ovl), fmtle(M.Group), fmtle(M.Frame), fmtle(M.SecName));
188809467b48Spatrick P.formatLine(" class = {0}, offset = {1}, size = {2}",
188909467b48Spatrick fmtle(M.ClassName), fmtle(M.Offset), fmtle(M.SecByteLength));
189009467b48Spatrick P.formatLine(" flags = {0}",
189109467b48Spatrick formatSegMapDescriptorFlag(
189209467b48Spatrick P.getIndentLevel() + 13,
189309467b48Spatrick static_cast<OMFSegDescFlags>(uint16_t(M.Flags))));
189409467b48Spatrick ++I;
189509467b48Spatrick }
189609467b48Spatrick return Error::success();
189709467b48Spatrick }
1898