tools/llvm-pdbutil/DumpOutputStyle.cpp

   1 //===- DumpOutputStyle.cpp ------------------------------------ *- C++ --*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "DumpOutputStyle.h"
  10
  11 #include "FormatUtil.h"
  12 #include "InputFile.h"
  13 #include "MinimalSymbolDumper.h"
  14 #include "MinimalTypeDumper.h"
  15 #include "StreamUtil.h"
  16 #include "TypeReferenceTracker.h"
  17 #include "llvm-pdbutil.h"
  18
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
  21 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
  22 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
  23 #include "llvm/DebugInfo/CodeView/DebugCrossExSubsection.h"
  24 #include "llvm/DebugInfo/CodeView/DebugCrossImpSubsection.h"
  25 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
  26 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
  27 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
  28 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
  29 #include "llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h"
  30 #include "llvm/DebugInfo/CodeView/Formatters.h"
  31 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  32 #include "llvm/DebugInfo/CodeView/Line.h"
  33 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
  34 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
  35 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
  36 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
  37 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
  38 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
  39 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
  40 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  41 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
  42 #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
  43 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
  44 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
  45 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  46 #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
  47 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  48 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
  49 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
  50 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  51 #include "llvm/Object/COFF.h"
  52 #include "llvm/Support/BinaryStreamReader.h"
  53 #include "llvm/Support/FormatAdapters.h"
  54 #include "llvm/Support/FormatVariadic.h"
  55
  56 #include <cctype>
  57
  58 using namespace llvm;
  59 using namespace llvm::codeview;
  60 using namespace llvm::msf;
  61 using namespace llvm::pdb;
  62
  63 DumpOutputStyle::DumpOutputStyle(InputFile &File)
  64     : File(File), P(2, false, outs()) {
  65   if (opts::dump::DumpTypeRefStats)
  66     RefTracker.reset(new TypeReferenceTracker(File));
  67 }
  68
  69 DumpOutputStyle::~DumpOutputStyle() {}
  70
  71 PDBFile &DumpOutputStyle::getPdb() { return File.pdb(); }
  72 object::COFFObjectFile &DumpOutputStyle::getObj() { return File.obj(); }
  73
  74 void DumpOutputStyle::printStreamNotValidForObj() {
  75   AutoIndent Indent(P, 4);
  76   P.formatLine("Dumping this stream is not valid for object files");
  77 }
  78
  79 void DumpOutputStyle::printStreamNotPresent(StringRef StreamName) {
  80   AutoIndent Indent(P, 4);
  81   P.formatLine("{0} stream not present", StreamName);
  82 }
  83
  84 Error DumpOutputStyle::dump() {
  85   // Walk symbols & globals if we are supposed to mark types referenced.
  86   if (opts::dump::DumpTypeRefStats)
  87     RefTracker->mark();
  88
  89   if (opts::dump::DumpSummary) {
  90     if (auto EC = dumpFileSummary())
  91       return EC;
  92     P.NewLine();
  93   }
  94
  95   if (opts::dump::DumpStreams) {
  96     if (auto EC = dumpStreamSummary())
  97       return EC;
  98     P.NewLine();
  99   }
 100
 101   if (opts::dump::DumpSymbolStats) {
 102     if (auto EC = dumpSymbolStats())
 103       return EC;
 104     P.NewLine();
 105   }
 106
 107   if (opts::dump::DumpUdtStats) {
 108     if (auto EC = dumpUdtStats())
 109       return EC;
 110     P.NewLine();
 111   }
 112
 113   if (opts::dump::DumpTypeStats) {
 114     if (auto EC = dumpTypeStats())
 115       return EC;
 116     P.NewLine();
 117   }
 118
 119   if (opts::dump::DumpNamedStreams) {
 120     if (auto EC = dumpNamedStreams())
 121       return EC;
 122     P.NewLine();
 123   }
 124
 125   if (opts::dump::DumpStringTable || opts::dump::DumpStringTableDetails) {
 126     if (auto EC = dumpStringTable())
 127       return EC;
 128     P.NewLine();
 129   }
 130
 131   if (opts::dump::DumpModules) {
 132     if (auto EC = dumpModules())
 133       return EC;
 134   }
 135
 136   if (opts::dump::DumpModuleFiles) {
 137     if (auto EC = dumpModuleFiles())
 138       return EC;
 139   }
 140
 141   if (opts::dump::DumpLines) {
 142     if (auto EC = dumpLines())
 143       return EC;
 144   }
 145
 146   if (opts::dump::DumpInlineeLines) {
 147     if (auto EC = dumpInlineeLines())
 148       return EC;
 149   }
 150
 151   if (opts::dump::DumpXmi) {
 152     if (auto EC = dumpXmi())
 153       return EC;
 154   }
 155
 156   if (opts::dump::DumpXme) {
 157     if (auto EC = dumpXme())
 158       return EC;
 159   }
 160
 161   if (opts::dump::DumpFpo) {
 162     if (auto EC = dumpFpo())
 163       return EC;
 164   }
 165
 166   if (File.isObj()) {
 167     if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
 168         opts::dump::DumpTypeExtras)
 169       if (auto EC = dumpTypesFromObjectFile())
 170         return EC;
 171   } else {
 172     if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
 173         opts::dump::DumpTypeExtras) {
 174       if (auto EC = dumpTpiStream(StreamTPI))
 175         return EC;
 176     }
 177
 178     if (opts::dump::DumpIds || !opts::dump::DumpIdIndex.empty() ||
 179         opts::dump::DumpIdExtras) {
 180       if (auto EC = dumpTpiStream(StreamIPI))
 181         return EC;
 182     }
 183   }
 184
 185   if (opts::dump::DumpGSIRecords) {
 186     if (auto EC = dumpGSIRecords())
 187       return EC;
 188   }
 189
 190   if (opts::dump::DumpGlobals) {
 191     if (auto EC = dumpGlobals())
 192       return EC;
 193   }
 194
 195   if (opts::dump::DumpPublics) {
 196     if (auto EC = dumpPublics())
 197       return EC;
 198   }
 199
 200   if (opts::dump::DumpSymbols) {
 201     auto EC = File.isPdb() ? dumpModuleSymsForPdb() : dumpModuleSymsForObj();
 202     if (EC)
 203       return EC;
 204   }
 205
 206   if (opts::dump::DumpTypeRefStats) {
 207     if (auto EC = dumpTypeRefStats())
 208       return EC;
 209   }
 210
 211   if (opts::dump::DumpSectionHeaders) {
 212     if (auto EC = dumpSectionHeaders())
 213       return EC;
 214   }
 215
 216   if (opts::dump::DumpSectionContribs) {
 217     if (auto EC = dumpSectionContribs())
 218       return EC;
 219   }
 220
 221   if (opts::dump::DumpSectionMap) {
 222     if (auto EC = dumpSectionMap())
 223       return EC;
 224   }
 225
 226   P.NewLine();
 227
 228   return Error::success();
 229 }
 230
 231 static void printHeader(LinePrinter &P, const Twine &S) {
 232   P.NewLine();
 233   P.formatLine("{0,=60}", S);
 234   P.formatLine("{0}", fmt_repeat('=', 60));
 235 }
 236
 237 Error DumpOutputStyle::dumpFileSummary() {
 238   printHeader(P, "Summary");
 239
 240   if (File.isObj()) {
 241     printStreamNotValidForObj();
 242     return Error::success();
 243   }
 244
 245   AutoIndent Indent(P);
 246   ExitOnError Err("Invalid PDB Format: ");
 247
 248   P.formatLine("Block Size: {0}", getPdb().getBlockSize());
 249   P.formatLine("Number of blocks: {0}", getPdb().getBlockCount());
 250   P.formatLine("Number of streams: {0}", getPdb().getNumStreams());
 251
 252   auto &PS = Err(getPdb().getPDBInfoStream());
 253   P.formatLine("Signature: {0}", PS.getSignature());
 254   P.formatLine("Age: {0}", PS.getAge());
 255   P.formatLine("GUID: {0}", fmt_guid(PS.getGuid().Guid));
 256   P.formatLine("Features: {0:x+}", static_cast<uint32_t>(PS.getFeatures()));
 257   P.formatLine("Has Debug Info: {0}", getPdb().hasPDBDbiStream());
 258   P.formatLine("Has Types: {0}", getPdb().hasPDBTpiStream());
 259   P.formatLine("Has IDs: {0}", getPdb().hasPDBIpiStream());
 260   P.formatLine("Has Globals: {0}", getPdb().hasPDBGlobalsStream());
 261   P.formatLine("Has Publics: {0}", getPdb().hasPDBPublicsStream());
 262   if (getPdb().hasPDBDbiStream()) {
 263     auto &DBI = Err(getPdb().getPDBDbiStream());
 264     P.formatLine("Is incrementally linked: {0}", DBI.isIncrementallyLinked());
 265     P.formatLine("Has conflicting types: {0}", DBI.hasCTypes());
 266     P.formatLine("Is stripped: {0}", DBI.isStripped());
 267   }
 268
 269   return Error::success();
 270 }
 271
 272 static StatCollection getSymbolStats(const SymbolGroup &SG,
 273                                      StatCollection &CumulativeStats) {
 274   StatCollection Stats;
 275   if (SG.getFile().isPdb() && SG.hasDebugStream()) {
 276     // For PDB files, all symbols are packed into one stream.
 277     for (const auto &S : SG.getPdbModuleStream().symbols(nullptr)) {
 278       Stats.update(S.kind(), S.length());
 279       CumulativeStats.update(S.kind(), S.length());
 280     }
 281     return Stats;
 282   }
 283
 284   for (const auto &SS : SG.getDebugSubsections()) {
 285     // For object files, all symbols are spread across multiple Symbol
 286     // subsections of a given .debug$S section.
 287     if (SS.kind() != DebugSubsectionKind::Symbols)
 288       continue;
 289     DebugSymbolsSubsectionRef Symbols;
 290     BinaryStreamReader Reader(SS.getRecordData());
 291     cantFail(Symbols.initialize(Reader));
 292     for (const auto &S : Symbols) {
 293       Stats.update(S.kind(), S.length());
 294       CumulativeStats.update(S.kind(), S.length());
 295     }
 296   }
 297   return Stats;
 298 }
 299
 300 static StatCollection getChunkStats(const SymbolGroup &SG,
 301                                     StatCollection &CumulativeStats) {
 302   StatCollection Stats;
 303   for (const auto &Chunk : SG.getDebugSubsections()) {
 304     Stats.update(uint32_t(Chunk.kind()), Chunk.getRecordLength());
 305     CumulativeStats.update(uint32_t(Chunk.kind()), Chunk.getRecordLength());
 306   }
 307   return Stats;
 308 }
 309
 310 static inline std::string formatModuleDetailKind(DebugSubsectionKind K) {
 311   return formatChunkKind(K, false);
 312 }
 313
 314 static inline std::string formatModuleDetailKind(SymbolKind K) {
 315   return formatSymbolKind(K);
 316 }
 317
 318 // Get the stats sorted by size, descending.
 319 std::vector<StatCollection::KindAndStat>
 320 StatCollection::getStatsSortedBySize() const {
 321   std::vector<KindAndStat> SortedStats(Individual.begin(), Individual.end());
 322   llvm::stable_sort(SortedStats,
 323                     [](const KindAndStat &LHS, const KindAndStat &RHS) {
 324                       return LHS.second.Size > RHS.second.Size;
 325                     });
 326   return SortedStats;
 327 }
 328
 329 template <typename Kind>
 330 static void printModuleDetailStats(LinePrinter &P, StringRef Label,
 331                                    const StatCollection &Stats) {
 332   P.NewLine();
 333   P.formatLine("  {0}", Label);
 334   AutoIndent Indent(P);
 335   P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", "Total",
 336                Stats.Totals.Count, Stats.Totals.Size);
 337   P.formatLine("{0}", fmt_repeat('-', 74));
 338
 339   for (const auto &K : Stats.getStatsSortedBySize()) {
 340     std::string KindName = formatModuleDetailKind(Kind(K.first));
 341     P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", KindName,
 342                  K.second.Count, K.second.Size);
 343   }
 344 }
 345
 346 static bool isMyCode(const SymbolGroup &Group) {
 347   if (Group.getFile().isObj())
 348     return true;
 349
 350   StringRef Name = Group.name();
 351   if (Name.startswith("Import:"))
 352     return false;
 353   if (Name.endswith_lower(".dll"))
 354     return false;
 355   if (Name.equals_lower("* linker *"))
 356     return false;
 357   if (Name.startswith_lower("f:\\binaries\\Intermediate\\vctools"))
 358     return false;
 359   if (Name.startswith_lower("f:\\dd\\vctools\\crt"))
 360     return false;
 361   return true;
 362 }
 363
 364 static bool shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group) {
 365   if (opts::dump::JustMyCode && !isMyCode(Group))
 366     return false;
 367
 368   // If the arg was not specified on the command line, always dump all modules.
 369   if (opts::dump::DumpModi.getNumOccurrences() == 0)
 370     return true;
 371
 372   // Otherwise, only dump if this is the same module specified.
 373   return (opts::dump::DumpModi == Idx);
 374 }
 375
 376 Error DumpOutputStyle::dumpStreamSummary() {
 377   printHeader(P, "Streams");
 378
 379   if (File.isObj()) {
 380     printStreamNotValidForObj();
 381     return Error::success();
 382   }
 383
 384   AutoIndent Indent(P);
 385
 386   if (StreamPurposes.empty())
 387     discoverStreamPurposes(getPdb(), StreamPurposes);
 388
 389   uint32_t StreamCount = getPdb().getNumStreams();
 390   uint32_t MaxStreamSize = getPdb().getMaxStreamSize();
 391
 392   for (uint16_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
 393     P.formatLine(
 394         "Stream {0} ({1} bytes): [{2}]",
 395         fmt_align(StreamIdx, AlignStyle::Right, NumDigits(StreamCount)),
 396         fmt_align(getPdb().getStreamByteSize(StreamIdx), AlignStyle::Right,
 397                   NumDigits(MaxStreamSize)),
 398         StreamPurposes[StreamIdx].getLongName());
 399
 400     if (opts::dump::DumpStreamBlocks) {
 401       auto Blocks = getPdb().getStreamBlockList(StreamIdx);
 402       std::vector<uint32_t> BV(Blocks.begin(), Blocks.end());
 403       P.formatLine("       {0}  Blocks: [{1}]",
 404                    fmt_repeat(' ', NumDigits(StreamCount)),
 405                    make_range(BV.begin(), BV.end()));
 406     }
 407   }
 408
 409   return Error::success();
 410 }
 411
 412 static Expected<ModuleDebugStreamRef> getModuleDebugStream(PDBFile &File,
 413                                                            uint32_t Index) {
 414   ExitOnError Err("Unexpected error: ");
 415
 416   auto &Dbi = Err(File.getPDBDbiStream());
 417   const auto &Modules = Dbi.modules();
 418   auto Modi = Modules.getModuleDescriptor(Index);
 419
 420   uint16_t ModiStream = Modi.getModuleStreamIndex();
 421   if (ModiStream == kInvalidStreamIndex)
 422     return make_error<RawError>(raw_error_code::no_stream,
 423                                 "Module stream not present");
 424
 425   auto ModStreamData = File.createIndexedStream(ModiStream);
 426
 427   ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
 428   if (auto EC = ModS.reload())
 429     return make_error<RawError>(raw_error_code::corrupt_file,
 430                                 "Invalid module stream");
 431
 432   return std::move(ModS);
 433 }
 434
 435 template <typename CallbackT>
 436 static void
 437 iterateOneModule(InputFile &File, const Optional<PrintScope> &HeaderScope,
 438                  const SymbolGroup &SG, uint32_t Modi, CallbackT Callback) {
 439   if (HeaderScope) {
 440     HeaderScope->P.formatLine(
 441         "Mod {0:4} | `{1}`: ",
 442         fmt_align(Modi, AlignStyle::Right, HeaderScope->LabelWidth), SG.name());
 443   }
 444
 445   AutoIndent Indent(HeaderScope);
 446   Callback(Modi, SG);
 447 }
 448
 449 template <typename CallbackT>
 450 static void iterateSymbolGroups(InputFile &Input,
 451                                 const Optional<PrintScope> &HeaderScope,
 452                                 CallbackT Callback) {
 453   AutoIndent Indent(HeaderScope);
 454
 455   ExitOnError Err("Unexpected error processing modules: ");
 456
 457   if (opts::dump::DumpModi.getNumOccurrences() > 0) {
 458     assert(opts::dump::DumpModi.getNumOccurrences() == 1);
 459     uint32_t Modi = opts::dump::DumpModi;
 460     SymbolGroup SG(&Input, Modi);
 461     iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(Modi)), SG,
 462                      Modi, Callback);
 463     return;
 464   }
 465
 466   uint32_t I = 0;
 467
 468   for (const auto &SG : Input.symbol_groups()) {
 469     if (shouldDumpSymbolGroup(I, SG))
 470       iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(I)), SG, I,
 471                        Callback);
 472
 473     ++I;
 474   }
 475 }
 476
 477 template <typename SubsectionT>
 478 static void iterateModuleSubsections(
 479     InputFile &File, const Optional<PrintScope> &HeaderScope,
 480     llvm::function_ref<void(uint32_t, const SymbolGroup &, SubsectionT &)>
 481         Callback) {
 482
 483   iterateSymbolGroups(File, HeaderScope,
 484                       [&](uint32_t Modi, const SymbolGroup &SG) {
 485                         for (const auto &SS : SG.getDebugSubsections()) {
 486                           SubsectionT Subsection;
 487
 488                           if (SS.kind() != Subsection.kind())
 489                             continue;
 490
 491                           BinaryStreamReader Reader(SS.getRecordData());
 492                           if (auto EC = Subsection.initialize(Reader))
 493                             continue;
 494                           Callback(Modi, SG, Subsection);
 495                         }
 496                       });
 497 }
 498
 499 static Expected<std::pair<std::unique_ptr<MappedBlockStream>,
 500                           ArrayRef<llvm::object::coff_section>>>
 501 loadSectionHeaders(PDBFile &File, DbgHeaderType Type) {
 502   if (!File.hasPDBDbiStream())
 503     return make_error<StringError>(
 504         "Section headers require a DBI Stream, which could not be loaded",
 505         inconvertibleErrorCode());
 506
 507   auto &Dbi = cantFail(File.getPDBDbiStream());
 508   uint32_t SI = Dbi.getDebugStreamIndex(Type);
 509
 510   if (SI == kInvalidStreamIndex)
 511     return make_error<StringError>(
 512         "PDB does not contain the requested image section header type",
 513         inconvertibleErrorCode());
 514
 515   auto Stream = File.createIndexedStream(SI);
 516   if (!Stream)
 517     return make_error<StringError>("Could not load the required stream data",
 518                                    inconvertibleErrorCode());
 519
 520   ArrayRef<object::coff_section> Headers;
 521   if (Stream->getLength() % sizeof(object::coff_section) != 0)
 522     return make_error<StringError>(
 523         "Section header array size is not a multiple of section header size",
 524         inconvertibleErrorCode());
 525
 526   uint32_t NumHeaders = Stream->getLength() / sizeof(object::coff_section);
 527   BinaryStreamReader Reader(*Stream);
 528   cantFail(Reader.readArray(Headers, NumHeaders));
 529   return std::make_pair(std::move(Stream), Headers);
 530 }
 531
 532 static std::vector<std::string> getSectionNames(PDBFile &File) {
 533   auto ExpectedHeaders = loadSectionHeaders(File, DbgHeaderType::SectionHdr);
 534   if (!ExpectedHeaders)
 535     return {};
 536
 537   std::unique_ptr<MappedBlockStream> Stream;
 538   ArrayRef<object::coff_section> Headers;
 539   std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
 540   std::vector<std::string> Names;
 541   for (const auto &H : Headers)
 542     Names.push_back(H.Name);
 543   return Names;
 544 }
 545
 546 static void dumpSectionContrib(LinePrinter &P, const SectionContrib &SC,
 547                                ArrayRef<std::string> SectionNames,
 548                                uint32_t FieldWidth) {
 549   std::string NameInsert;
 550   if (SC.ISect > 0 && SC.ISect <= SectionNames.size()) {
 551     StringRef SectionName = SectionNames[SC.ISect - 1];
 552     NameInsert = formatv("[{0}]", SectionName).str();
 553   } else
 554     NameInsert = "[???]";
 555   P.formatLine("SC{5}  | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
 556                "crc = {4}",
 557                formatSegmentOffset(SC.ISect, SC.Off), fmtle(SC.Size),
 558                fmtle(SC.Imod), fmtle(SC.DataCrc), fmtle(SC.RelocCrc),
 559                fmt_align(NameInsert, AlignStyle::Left, FieldWidth + 2));
 560   AutoIndent Indent(P, FieldWidth + 2);
 561   P.formatLine("      {0}",
 562                formatSectionCharacteristics(P.getIndentLevel() + 6,
 563                                             SC.Characteristics, 3, " | "));
 564 }
 565
 566 static void dumpSectionContrib(LinePrinter &P, const SectionContrib2 &SC,
 567                                ArrayRef<std::string> SectionNames,
 568                                uint32_t FieldWidth) {
 569   P.formatLine("SC2[{6}] | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
 570                "crc = {4}, coff section = {5}",
 571                formatSegmentOffset(SC.Base.ISect, SC.Base.Off),
 572                fmtle(SC.Base.Size), fmtle(SC.Base.Imod), fmtle(SC.Base.DataCrc),
 573                fmtle(SC.Base.RelocCrc), fmtle(SC.ISectCoff));
 574   P.formatLine("      {0}",
 575                formatSectionCharacteristics(P.getIndentLevel() + 6,
 576                                             SC.Base.Characteristics, 3, " | "));
 577 }
 578
 579 Error DumpOutputStyle::dumpModules() {
 580   printHeader(P, "Modules");
 581
 582   if (File.isObj()) {
 583     printStreamNotValidForObj();
 584     return Error::success();
 585   }
 586
 587   if (!getPdb().hasPDBDbiStream()) {
 588     printStreamNotPresent("DBI");
 589     return Error::success();
 590   }
 591
 592   AutoIndent Indent(P);
 593   ExitOnError Err("Unexpected error processing modules: ");
 594
 595   auto &Stream = Err(getPdb().getPDBDbiStream());
 596
 597   const DbiModuleList &Modules = Stream.modules();
 598   iterateSymbolGroups(
 599       File, PrintScope{P, 11}, [&](uint32_t Modi, const SymbolGroup &Strings) {
 600         auto Desc = Modules.getModuleDescriptor(Modi);
 601         if (opts::dump::DumpSectionContribs) {
 602           std::vector<std::string> Sections = getSectionNames(getPdb());
 603           dumpSectionContrib(P, Desc.getSectionContrib(), Sections, 0);
 604         }
 605         P.formatLine("Obj: `{0}`: ", Desc.getObjFileName());
 606         P.formatLine("debug stream: {0}, # files: {1}, has ec info: {2}",
 607                      Desc.getModuleStreamIndex(), Desc.getNumberOfFiles(),
 608                      Desc.hasECInfo());
 609         StringRef PdbFilePath =
 610             Err(Stream.getECName(Desc.getPdbFilePathNameIndex()));
 611         StringRef SrcFilePath =
 612             Err(Stream.getECName(Desc.getSourceFileNameIndex()));
 613         P.formatLine("pdb file ni: {0} `{1}`, src file ni: {2} `{3}`",
 614                      Desc.getPdbFilePathNameIndex(), PdbFilePath,
 615                      Desc.getSourceFileNameIndex(), SrcFilePath);
 616       });
 617   return Error::success();
 618 }
 619
 620 Error DumpOutputStyle::dumpModuleFiles() {
 621   printHeader(P, "Files");
 622
 623   if (File.isObj()) {
 624     printStreamNotValidForObj();
 625     return Error::success();
 626   }
 627
 628   if (!getPdb().hasPDBDbiStream()) {
 629     printStreamNotPresent("DBI");
 630     return Error::success();
 631   }
 632
 633   ExitOnError Err("Unexpected error processing modules: ");
 634
 635   iterateSymbolGroups(File, PrintScope{P, 11},
 636                       [this, &Err](uint32_t Modi, const SymbolGroup &Strings) {
 637                         auto &Stream = Err(getPdb().getPDBDbiStream());
 638
 639                         const DbiModuleList &Modules = Stream.modules();
 640                         for (const auto &F : Modules.source_files(Modi)) {
 641                           Strings.formatFromFileName(P, F);
 642                         }
 643                       });
 644   return Error::success();
 645 }
 646
 647 Error DumpOutputStyle::dumpSymbolStats() {
 648   printHeader(P, "Module Stats");
 649
 650   if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
 651     printStreamNotPresent("DBI");
 652     return Error::success();
 653   }
 654
 655   ExitOnError Err("Unexpected error processing modules: ");
 656
 657   StatCollection SymStats;
 658   StatCollection ChunkStats;
 659
 660   Optional<PrintScope> Scope;
 661   if (File.isPdb())
 662     Scope.emplace(P, 2);
 663
 664   iterateSymbolGroups(File, Scope, [&](uint32_t Modi, const SymbolGroup &SG) {
 665     StatCollection SS = getSymbolStats(SG, SymStats);
 666     StatCollection CS = getChunkStats(SG, ChunkStats);
 667
 668     if (SG.getFile().isPdb()) {
 669       AutoIndent Indent(P);
 670       auto Modules = cantFail(File.pdb().getPDBDbiStream()).modules();
 671       uint32_t ModCount = Modules.getModuleCount();
 672       DbiModuleDescriptor Desc = Modules.getModuleDescriptor(Modi);
 673       uint32_t StreamIdx = Desc.getModuleStreamIndex();
 674
 675       if (StreamIdx == kInvalidStreamIndex) {
 676         P.formatLine("Mod {0} (debug info not present): [{1}]",
 677                      fmt_align(Modi, AlignStyle::Right, NumDigits(ModCount)),
 678                      Desc.getModuleName());
 679         return;
 680       }
 681       P.formatLine("Stream {0}, {1} bytes", StreamIdx,
 682                    getPdb().getStreamByteSize(StreamIdx));
 683
 684       printModuleDetailStats<SymbolKind>(P, "Symbols", SS);
 685       printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", CS);
 686     }
 687   });
 688
 689   if (SymStats.Totals.Count > 0) {
 690     P.printLine("  Summary |");
 691     AutoIndent Indent(P, 4);
 692     printModuleDetailStats<SymbolKind>(P, "Symbols", SymStats);
 693     printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", ChunkStats);
 694   }
 695
 696   return Error::success();
 697 }
 698
 699 Error DumpOutputStyle::dumpTypeStats() {
 700   printHeader(P, "Type Record Stats");
 701
 702   // Iterate the types, categorize by kind, accumulate size stats.
 703   StatCollection TypeStats;
 704   LazyRandomTypeCollection &Types = File.types();
 705   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
 706     CVType Type = Types.getType(*TI);
 707     TypeStats.update(uint32_t(Type.kind()), Type.length());
 708   }
 709
 710   P.NewLine();
 711   P.formatLine("  Types");
 712   AutoIndent Indent(P);
 713   P.formatLine("{0,14}: {1,7} entries ({2,12:N} bytes, {3,7} avg)", "Total",
 714                TypeStats.Totals.Count, TypeStats.Totals.Size,
 715                (double)TypeStats.Totals.Size / TypeStats.Totals.Count);
 716   P.formatLine("{0}", fmt_repeat('-', 74));
 717
 718   for (const auto &K : TypeStats.getStatsSortedBySize()) {
 719     P.formatLine("{0,14}: {1,7} entries ({2,12:N} bytes, {3,7} avg)",
 720                  formatTypeLeafKind(TypeLeafKind(K.first)), K.second.Count,
 721                  K.second.Size, (double)K.second.Size / K.second.Count);
 722   }
 723
 724
 725   return Error::success();
 726 }
 727
 728 static bool isValidNamespaceIdentifier(StringRef S) {
 729   if (S.empty())
 730     return false;
 731
 732   if (std::isdigit(S[0]))
 733     return false;
 734
 735   return llvm::all_of(S, [](char C) { return std::isalnum(C); });
 736 }
 737
 738 namespace {
 739 constexpr uint32_t kNoneUdtKind = 0;
 740 constexpr uint32_t kSimpleUdtKind = 1;
 741 constexpr uint32_t kUnknownUdtKind = 2;
 742 const StringRef NoneLabel("<none type>");
 743 const StringRef SimpleLabel("<simple type>");
 744 const StringRef UnknownLabel("<unknown type>");
 745
 746 } // namespace
 747
 748 static StringRef getUdtStatLabel(uint32_t Kind) {
 749   if (Kind == kNoneUdtKind)
 750     return NoneLabel;
 751
 752   if (Kind == kSimpleUdtKind)
 753     return SimpleLabel;
 754
 755   if (Kind == kUnknownUdtKind)
 756     return UnknownLabel;
 757
 758   return formatTypeLeafKind(static_cast<TypeLeafKind>(Kind));
 759 }
 760
 761 static uint32_t getLongestTypeLeafName(const StatCollection &Stats) {
 762   size_t L = 0;
 763   for (const auto &Stat : Stats.Individual) {
 764     StringRef Label = getUdtStatLabel(Stat.first);
 765     L = std::max(L, Label.size());
 766   }
 767   return static_cast<uint32_t>(L);
 768 }
 769
 770 Error DumpOutputStyle::dumpUdtStats() {
 771   printHeader(P, "S_UDT Record Stats");
 772
 773   if (File.isPdb() && !getPdb().hasPDBGlobalsStream()) {
 774     printStreamNotPresent("Globals");
 775     return Error::success();
 776   }
 777
 778   StatCollection UdtStats;
 779   StatCollection UdtTargetStats;
 780   AutoIndent Indent(P, 4);
 781
 782   auto &TpiTypes = File.types();
 783
 784   StringMap<StatCollection::Stat> NamespacedStats;
 785
 786   size_t LongestNamespace = 0;
 787   auto HandleOneSymbol = [&](const CVSymbol &Sym) {
 788     if (Sym.kind() != SymbolKind::S_UDT)
 789       return;
 790     UdtStats.update(SymbolKind::S_UDT, Sym.length());
 791
 792     UDTSym UDT = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(Sym));
 793
 794     uint32_t Kind = 0;
 795     uint32_t RecordSize = 0;
 796
 797     if (UDT.Type.isNoneType())
 798       Kind = kNoneUdtKind;
 799     else if (UDT.Type.isSimple())
 800       Kind = kSimpleUdtKind;
 801     else if (Optional<CVType> T = TpiTypes.tryGetType(UDT.Type)) {
 802       Kind = T->kind();
 803       RecordSize = T->length();
 804     } else
 805       Kind = kUnknownUdtKind;
 806
 807     UdtTargetStats.update(Kind, RecordSize);
 808
 809     size_t Pos = UDT.Name.find("::");
 810     if (Pos == StringRef::npos)
 811       return;
 812
 813     StringRef Scope = UDT.Name.take_front(Pos);
 814     if (Scope.empty() || !isValidNamespaceIdentifier(Scope))
 815       return;
 816
 817     LongestNamespace = std::max(LongestNamespace, Scope.size());
 818     NamespacedStats[Scope].update(RecordSize);
 819   };
 820
 821   P.NewLine();
 822
 823   if (File.isPdb()) {
 824     auto &SymbolRecords = cantFail(getPdb().getPDBSymbolStream());
 825     auto ExpGlobals = getPdb().getPDBGlobalsStream();
 826     if (!ExpGlobals)
 827       return ExpGlobals.takeError();
 828
 829     for (uint32_t PubSymOff : ExpGlobals->getGlobalsTable()) {
 830       CVSymbol Sym = SymbolRecords.readRecord(PubSymOff);
 831       HandleOneSymbol(Sym);
 832     }
 833   } else {
 834     for (const auto &Sec : File.symbol_groups()) {
 835       for (const auto &SS : Sec.getDebugSubsections()) {
 836         if (SS.kind() != DebugSubsectionKind::Symbols)
 837           continue;
 838
 839         DebugSymbolsSubsectionRef Symbols;
 840         BinaryStreamReader Reader(SS.getRecordData());
 841         cantFail(Symbols.initialize(Reader));
 842         for (const auto &S : Symbols)
 843           HandleOneSymbol(S);
 844       }
 845     }
 846   }
 847
 848   LongestNamespace += StringRef(" namespace ''").size();
 849   size_t LongestTypeLeafKind = getLongestTypeLeafName(UdtTargetStats);
 850   size_t FieldWidth = std::max(LongestNamespace, LongestTypeLeafKind);
 851
 852   // Compute the max number of digits for count and size fields, including comma
 853   // separators.
 854   StringRef CountHeader("Count");
 855   StringRef SizeHeader("Size");
 856   size_t CD = NumDigits(UdtStats.Totals.Count);
 857   CD += (CD - 1) / 3;
 858   CD = std::max(CD, CountHeader.size());
 859
 860   size_t SD = NumDigits(UdtStats.Totals.Size);
 861   SD += (SD - 1) / 3;
 862   SD = std::max(SD, SizeHeader.size());
 863
 864   uint32_t TableWidth = FieldWidth + 3 + CD + 2 + SD + 1;
 865
 866   P.formatLine("{0} | {1}  {2}",
 867                fmt_align("Record Kind", AlignStyle::Right, FieldWidth),
 868                fmt_align(CountHeader, AlignStyle::Right, CD),
 869                fmt_align(SizeHeader, AlignStyle::Right, SD));
 870
 871   P.formatLine("{0}", fmt_repeat('-', TableWidth));
 872   for (const auto &Stat : UdtTargetStats.getStatsSortedBySize()) {
 873     StringRef Label = getUdtStatLabel(Stat.first);
 874     P.formatLine("{0} | {1:N}  {2:N}",
 875                  fmt_align(Label, AlignStyle::Right, FieldWidth),
 876                  fmt_align(Stat.second.Count, AlignStyle::Right, CD),
 877                  fmt_align(Stat.second.Size, AlignStyle::Right, SD));
 878   }
 879   P.formatLine("{0}", fmt_repeat('-', TableWidth));
 880   P.formatLine("{0} | {1:N}  {2:N}",
 881                fmt_align("Total (S_UDT)", AlignStyle::Right, FieldWidth),
 882                fmt_align(UdtStats.Totals.Count, AlignStyle::Right, CD),
 883                fmt_align(UdtStats.Totals.Size, AlignStyle::Right, SD));
 884   P.formatLine("{0}", fmt_repeat('-', TableWidth));
 885   struct StrAndStat {
 886     StringRef Key;
 887     StatCollection::Stat Stat;
 888   };
 889
 890   // Print namespace stats in descending order of size.
 891   std::vector<StrAndStat> NamespacedStatsSorted;
 892   for (const auto &Stat : NamespacedStats)
 893     NamespacedStatsSorted.push_back({Stat.getKey(), Stat.second});
 894   llvm::stable_sort(NamespacedStatsSorted,
 895                     [](const StrAndStat &L, const StrAndStat &R) {
 896                       return L.Stat.Size > R.Stat.Size;
 897                     });
 898   for (const auto &Stat : NamespacedStatsSorted) {
 899     std::string Label = formatv("namespace '{0}'", Stat.Key);
 900     P.formatLine("{0} | {1:N}  {2:N}",
 901                  fmt_align(Label, AlignStyle::Right, FieldWidth),
 902                  fmt_align(Stat.Stat.Count, AlignStyle::Right, CD),
 903                  fmt_align(Stat.Stat.Size, AlignStyle::Right, SD));
 904   }
 905   return Error::success();
 906 }
 907
 908 static void typesetLinesAndColumns(LinePrinter &P, uint32_t Start,
 909                                    const LineColumnEntry &E) {
 910   const uint32_t kMaxCharsPerLineNumber = 4; // 4 digit line number
 911   uint32_t MinColumnWidth = kMaxCharsPerLineNumber + 5;
 912
 913   // Let's try to keep it under 100 characters
 914   constexpr uint32_t kMaxRowLength = 100;
 915   // At least 3 spaces between columns.
 916   uint32_t ColumnsPerRow = kMaxRowLength / (MinColumnWidth + 3);
 917   uint32_t ItemsLeft = E.LineNumbers.size();
 918   auto LineIter = E.LineNumbers.begin();
 919   while (ItemsLeft != 0) {
 920     uint32_t RowColumns = std::min(ItemsLeft, ColumnsPerRow);
 921     for (uint32_t I = 0; I < RowColumns; ++I) {
 922       LineInfo Line(LineIter->Flags);
 923       std::string LineStr;
 924       if (Line.isAlwaysStepInto())
 925         LineStr = "ASI";
 926       else if (Line.isNeverStepInto())
 927         LineStr = "NSI";
 928       else
 929         LineStr = utostr(Line.getStartLine());
 930       char Statement = Line.isStatement() ? ' ' : '!';
 931       P.format("{0} {1:X-} {2} ",
 932                fmt_align(LineStr, AlignStyle::Right, kMaxCharsPerLineNumber),
 933                fmt_align(Start + LineIter->Offset, AlignStyle::Right, 8, '0'),
 934                Statement);
 935       ++LineIter;
 936       --ItemsLeft;
 937     }
 938     P.NewLine();
 939   }
 940 }
 941
 942 Error DumpOutputStyle::dumpLines() {
 943   printHeader(P, "Lines");
 944
 945   if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
 946     printStreamNotPresent("DBI");
 947     return Error::success();
 948   }
 949
 950   uint32_t LastModi = UINT32_MAX;
 951   uint32_t LastNameIndex = UINT32_MAX;
 952   iterateModuleSubsections<DebugLinesSubsectionRef>(
 953       File, PrintScope{P, 4},
 954       [this, &LastModi, &LastNameIndex](uint32_t Modi,
 955                                         const SymbolGroup &Strings,
 956                                         DebugLinesSubsectionRef &Lines) {
 957         uint16_t Segment = Lines.header()->RelocSegment;
 958         uint32_t Begin = Lines.header()->RelocOffset;
 959         uint32_t End = Begin + Lines.header()->CodeSize;
 960         for (const auto &Block : Lines) {
 961           if (LastModi != Modi || LastNameIndex != Block.NameIndex) {
 962             LastModi = Modi;
 963             LastNameIndex = Block.NameIndex;
 964             Strings.formatFromChecksumsOffset(P, Block.NameIndex);
 965           }
 966
 967           AutoIndent Indent(P, 2);
 968           P.formatLine("{0:X-4}:{1:X-8}-{2:X-8}, ", Segment, Begin, End);
 969           uint32_t Count = Block.LineNumbers.size();
 970           if (Lines.hasColumnInfo())
 971             P.format("line/column/addr entries = {0}", Count);
 972           else
 973             P.format("line/addr entries = {0}", Count);
 974
 975           P.NewLine();
 976           typesetLinesAndColumns(P, Begin, Block);
 977         }
 978       });
 979
 980   return Error::success();
 981 }
 982
 983 Error DumpOutputStyle::dumpInlineeLines() {
 984   printHeader(P, "Inlinee Lines");
 985
 986   if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
 987     printStreamNotPresent("DBI");
 988     return Error::success();
 989   }
 990
 991   iterateModuleSubsections<DebugInlineeLinesSubsectionRef>(
 992       File, PrintScope{P, 2},
 993       [this](uint32_t Modi, const SymbolGroup &Strings,
 994              DebugInlineeLinesSubsectionRef &Lines) {
 995         P.formatLine("{0,+8} | {1,+5} | {2}", "Inlinee", "Line", "Source File");
 996         for (const auto &Entry : Lines) {
 997           P.formatLine("{0,+8} | {1,+5} | ", Entry.Header->Inlinee,
 998                        fmtle(Entry.Header->SourceLineNum));
 999           Strings.formatFromChecksumsOffset(P, Entry.Header->FileID, true);
1000           for (const auto &ExtraFileID : Entry.ExtraFiles) {
1001             P.formatLine("                   ");
1002             Strings.formatFromChecksumsOffset(P, ExtraFileID, true);
1003           }
1004         }
1005         P.NewLine();
1006       });
1007
1008   return Error::success();
1009 }
1010
1011 Error DumpOutputStyle::dumpXmi() {
1012   printHeader(P, "Cross Module Imports");
1013
1014   if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
1015     printStreamNotPresent("DBI");
1016     return Error::success();
1017   }
1018
1019   iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
1020       File, PrintScope{P, 2},
1021       [this](uint32_t Modi, const SymbolGroup &Strings,
1022              DebugCrossModuleImportsSubsectionRef &Imports) {
1023         P.formatLine("{0,=32} | {1}", "Imported Module", "Type IDs");
1024
1025         for (const auto &Xmi : Imports) {
1026           auto ExpectedModule =
1027               Strings.getNameFromStringTable(Xmi.Header->ModuleNameOffset);
1028           StringRef Module;
1029           SmallString<32> ModuleStorage;
1030           if (!ExpectedModule) {
1031             Module = "(unknown module)";
1032             consumeError(ExpectedModule.takeError());
1033           } else
1034             Module = *ExpectedModule;
1035           if (Module.size() > 32) {
1036             ModuleStorage = "...";
1037             ModuleStorage += Module.take_back(32 - 3);
1038             Module = ModuleStorage;
1039           }
1040           std::vector<std::string> TIs;
1041           for (const auto I : Xmi.Imports)
1042             TIs.push_back(formatv("{0,+10:X+}", fmtle(I)));
1043           std::string Result =
1044               typesetItemList(TIs, P.getIndentLevel() + 35, 12, " ");
1045           P.formatLine("{0,+32} | {1}", Module, Result);
1046         }
1047       });
1048
1049   return Error::success();
1050 }
1051
1052 Error DumpOutputStyle::dumpXme() {
1053   printHeader(P, "Cross Module Exports");
1054
1055   if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
1056     printStreamNotPresent("DBI");
1057     return Error::success();
1058   }
1059
1060   iterateModuleSubsections<DebugCrossModuleExportsSubsectionRef>(
1061       File, PrintScope{P, 2},
1062       [this](uint32_t Modi, const SymbolGroup &Strings,
1063              DebugCrossModuleExportsSubsectionRef &Exports) {
1064         P.formatLine("{0,-10} | {1}", "Local ID", "Global ID");
1065         for (const auto &Export : Exports) {
1066           P.formatLine("{0,+10:X+} | {1}", TypeIndex(Export.Local),
1067                        TypeIndex(Export.Global));
1068         }
1069       });
1070
1071   return Error::success();
1072 }
1073
1074 std::string formatFrameType(object::frame_type FT) {
1075   switch (FT) {
1076   case object::frame_type::Fpo:
1077     return "FPO";
1078   case object::frame_type::NonFpo:
1079     return "Non-FPO";
1080   case object::frame_type::Trap:
1081     return "Trap";
1082   case object::frame_type::Tss:
1083     return "TSS";
1084   }
1085   return "<unknown>";
1086 }
1087
1088 Error DumpOutputStyle::dumpOldFpo(PDBFile &File) {
1089   printHeader(P, "Old FPO Data");
1090
1091   ExitOnError Err("Error dumping old fpo data:");
1092   auto &Dbi = Err(File.getPDBDbiStream());
1093
1094   if (!Dbi.hasOldFpoRecords()) {
1095     printStreamNotPresent("FPO");
1096     return Error::success();
1097   }
1098
1099   const FixedStreamArray<object::FpoData>& Records = Dbi.getOldFpoRecords();
1100
1101   P.printLine("  RVA    | Code | Locals | Params | Prolog | Saved Regs | Use "
1102               "BP | Has SEH | Frame Type");
1103
1104   for (const object::FpoData &FD : Records) {
1105     P.formatLine("{0:X-8} | {1,4} | {2,6} | {3,6} | {4,6} | {5,10} | {6,6} | "
1106                  "{7,7} | {8,9}",
1107                  uint32_t(FD.Offset), uint32_t(FD.Size), uint32_t(FD.NumLocals),
1108                  uint32_t(FD.NumParams), FD.getPrologSize(),
1109                  FD.getNumSavedRegs(), FD.useBP(), FD.hasSEH(),
1110                  formatFrameType(FD.getFP()));
1111   }
1112   return Error::success();
1113 }
1114
1115 Error DumpOutputStyle::dumpNewFpo(PDBFile &File) {
1116   printHeader(P, "New FPO Data");
1117
1118   ExitOnError Err("Error dumping new fpo data:");
1119   auto &Dbi = Err(File.getPDBDbiStream());
1120
1121   if (!Dbi.hasNewFpoRecords()) {
1122     printStreamNotPresent("New FPO");
1123     return Error::success();
1124   }
1125
1126   const DebugFrameDataSubsectionRef& FDS = Dbi.getNewFpoRecords();
1127
1128   P.printLine("  RVA    | Code | Locals | Params | Stack | Prolog | Saved Regs "
1129               "| Has SEH | Has C++EH | Start | Program");
1130   for (const FrameData &FD : FDS) {
1131     bool IsFuncStart = FD.Flags & FrameData::IsFunctionStart;
1132     bool HasEH = FD.Flags & FrameData::HasEH;
1133     bool HasSEH = FD.Flags & FrameData::HasSEH;
1134
1135     auto &StringTable = Err(File.getStringTable());
1136
1137     auto Program = Err(StringTable.getStringForID(FD.FrameFunc));
1138     P.formatLine("{0:X-8} | {1,4} | {2,6} | {3,6} | {4,5} | {5,6} | {6,10} | "
1139                  "{7,7} | {8,9} | {9,5} | {10}",
1140                  uint32_t(FD.RvaStart), uint32_t(FD.CodeSize),
1141                  uint32_t(FD.LocalSize), uint32_t(FD.ParamsSize),
1142                  uint32_t(FD.MaxStackSize), uint16_t(FD.PrologSize),
1143                  uint16_t(FD.SavedRegsSize), HasSEH, HasEH, IsFuncStart,
1144                  Program);
1145   }
1146   return Error::success();
1147 }
1148
1149 Error DumpOutputStyle::dumpFpo() {
1150   if (!File.isPdb()) {
1151     printStreamNotValidForObj();
1152     return Error::success();
1153   }
1154
1155   PDBFile &File = getPdb();
1156   if (!File.hasPDBDbiStream()) {
1157     printStreamNotPresent("DBI");
1158     return Error::success();
1159   }
1160
1161   if (auto EC = dumpOldFpo(File))
1162     return EC;
1163   if (auto EC = dumpNewFpo(File))
1164     return EC;
1165   return Error::success();
1166 }
1167
1168 Error DumpOutputStyle::dumpStringTableFromPdb() {
1169   AutoIndent Indent(P);
1170   auto IS = getPdb().getStringTable();
1171   if (!IS) {
1172     P.formatLine("Not present in file");
1173     consumeError(IS.takeError());
1174     return Error::success();
1175   }
1176
1177   if (opts::dump::DumpStringTable) {
1178     if (IS->name_ids().empty())
1179       P.formatLine("Empty");
1180     else {
1181       auto MaxID =
1182           std::max_element(IS->name_ids().begin(), IS->name_ids().end());
1183       uint32_t Digits = NumDigits(*MaxID);
1184
1185       P.formatLine("{0} | {1}", fmt_align("ID", AlignStyle::Right, Digits),
1186                    "String");
1187
1188       std::vector<uint32_t> SortedIDs(IS->name_ids().begin(),
1189                                       IS->name_ids().end());
1190       llvm::sort(SortedIDs);
1191       for (uint32_t I : SortedIDs) {
1192         auto ES = IS->getStringForID(I);
1193         llvm::SmallString<32> Str;
1194         if (!ES) {
1195           consumeError(ES.takeError());
1196           Str = "Error reading string";
1197         } else if (!ES->empty()) {
1198           Str.append("'");
1199           Str.append(*ES);
1200           Str.append("'");
1201         }
1202
1203         if (!Str.empty())
1204           P.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Digits),
1205                        Str);
1206       }
1207     }
1208   }
1209
1210   if (opts::dump::DumpStringTableDetails) {
1211     P.NewLine();
1212     {
1213       P.printLine("String Table Header:");
1214       AutoIndent Indent(P);
1215       P.formatLine("Signature: {0}", IS->getSignature());
1216       P.formatLine("Hash Version: {0}", IS->getHashVersion());
1217       P.formatLine("Name Buffer Size: {0}", IS->getByteSize());
1218       P.NewLine();
1219     }
1220
1221     BinaryStreamRef NameBuffer = IS->getStringTable().getBuffer();
1222     ArrayRef<uint8_t> Contents;
1223     cantFail(NameBuffer.readBytes(0, NameBuffer.getLength(), Contents));
1224     P.formatBinary("Name Buffer", Contents, 0);
1225     P.NewLine();
1226     {
1227       P.printLine("Hash Table:");
1228       AutoIndent Indent(P);
1229       P.formatLine("Bucket Count: {0}", IS->name_ids().size());
1230       for (const auto &Entry : enumerate(IS->name_ids()))
1231         P.formatLine("Bucket[{0}] : {1}", Entry.index(),
1232                      uint32_t(Entry.value()));
1233       P.formatLine("Name Count: {0}", IS->getNameCount());
1234     }
1235   }
1236   return Error::success();
1237 }
1238
1239 Error DumpOutputStyle::dumpStringTableFromObj() {
1240   iterateModuleSubsections<DebugStringTableSubsectionRef>(
1241       File, PrintScope{P, 4},
1242       [&](uint32_t Modi, const SymbolGroup &Strings,
1243           DebugStringTableSubsectionRef &Strings2) {
1244         BinaryStreamRef StringTableBuffer = Strings2.getBuffer();
1245         BinaryStreamReader Reader(StringTableBuffer);
1246         while (Reader.bytesRemaining() > 0) {
1247           StringRef Str;
1248           uint32_t Offset = Reader.getOffset();
1249           cantFail(Reader.readCString(Str));
1250           if (Str.empty())
1251             continue;
1252
1253           P.formatLine("{0} | {1}", fmt_align(Offset, AlignStyle::Right, 4),
1254                        Str);
1255         }
1256       });
1257   return Error::success();
1258 }
1259
1260 Error DumpOutputStyle::dumpNamedStreams() {
1261   printHeader(P, "Named Streams");
1262
1263   if (File.isObj()) {
1264     printStreamNotValidForObj();
1265     return Error::success();
1266   }
1267
1268   AutoIndent Indent(P);
1269   ExitOnError Err("Invalid PDB File: ");
1270
1271   auto &IS = Err(File.pdb().getPDBInfoStream());
1272   const NamedStreamMap &NS = IS.getNamedStreams();
1273   for (const auto &Entry : NS.entries()) {
1274     P.printLine(Entry.getKey());
1275     AutoIndent Indent2(P, 2);
1276     P.formatLine("Index: {0}", Entry.getValue());
1277     P.formatLine("Size in bytes: {0}",
1278                  File.pdb().getStreamByteSize(Entry.getValue()));
1279   }
1280
1281   return Error::success();
1282 }
1283
1284 Error DumpOutputStyle::dumpStringTable() {
1285   printHeader(P, "String Table");
1286
1287   if (File.isPdb())
1288     return dumpStringTableFromPdb();
1289
1290   return dumpStringTableFromObj();
1291 }
1292
1293 static void buildDepSet(LazyRandomTypeCollection &Types,
1294                         ArrayRef<TypeIndex> Indices,
1295                         std::map<TypeIndex, CVType> &DepSet) {
1296   SmallVector<TypeIndex, 4> DepList;
1297   for (const auto &I : Indices) {
1298     TypeIndex TI(I);
1299     if (DepSet.find(TI) != DepSet.end() || TI.isSimple() || TI.isNoneType())
1300       continue;
1301
1302     CVType Type = Types.getType(TI);
1303     DepSet[TI] = Type;
1304     codeview::discoverTypeIndices(Type, DepList);
1305     buildDepSet(Types, DepList, DepSet);
1306   }
1307 }
1308
1309 static void
1310 dumpFullTypeStream(LinePrinter &Printer, LazyRandomTypeCollection &Types,
1311                    TypeReferenceTracker *RefTracker, uint32_t NumTypeRecords,
1312                    uint32_t NumHashBuckets,
1313                    FixedStreamArray<support::ulittle32_t> HashValues,
1314                    TpiStream *Stream, bool Bytes, bool Extras) {
1315
1316   Printer.formatLine("Showing {0:N} records", NumTypeRecords);
1317   uint32_t Width = NumDigits(TypeIndex::FirstNonSimpleIndex + NumTypeRecords);
1318
1319   MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types, RefTracker,
1320                            NumHashBuckets, HashValues, Stream);
1321
1322   if (auto EC = codeview::visitTypeStream(Types, V)) {
1323     Printer.formatLine("An error occurred dumping type records: {0}",
1324                        toString(std::move(EC)));
1325   }
1326 }
1327
1328 static void dumpPartialTypeStream(LinePrinter &Printer,
1329                                   LazyRandomTypeCollection &Types,
1330                                   TypeReferenceTracker *RefTracker,
1331                                   TpiStream &Stream, ArrayRef<TypeIndex> TiList,
1332                                   bool Bytes, bool Extras, bool Deps) {
1333   uint32_t Width =
1334       NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
1335
1336   MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types, RefTracker,
1337                            Stream.getNumHashBuckets(), Stream.getHashValues(),
1338                            &Stream);
1339
1340   if (opts::dump::DumpTypeDependents) {
1341     // If we need to dump all dependents, then iterate each index and find
1342     // all dependents, adding them to a map ordered by TypeIndex.
1343     std::map<TypeIndex, CVType> DepSet;
1344     buildDepSet(Types, TiList, DepSet);
1345
1346     Printer.formatLine(
1347         "Showing {0:N} records and their dependents ({1:N} records total)",
1348         TiList.size(), DepSet.size());
1349
1350     for (auto &Dep : DepSet) {
1351       if (auto EC = codeview::visitTypeRecord(Dep.second, Dep.first, V))
1352         Printer.formatLine("An error occurred dumping type record {0}: {1}",
1353                            Dep.first, toString(std::move(EC)));
1354     }
1355   } else {
1356     Printer.formatLine("Showing {0:N} records.", TiList.size());
1357
1358     for (const auto &I : TiList) {
1359       TypeIndex TI(I);
1360       CVType Type = Types.getType(TI);
1361       if (auto EC = codeview::visitTypeRecord(Type, TI, V))
1362         Printer.formatLine("An error occurred dumping type record {0}: {1}", TI,
1363                            toString(std::move(EC)));
1364     }
1365   }
1366 }
1367
1368 Error DumpOutputStyle::dumpTypesFromObjectFile() {
1369   LazyRandomTypeCollection Types(100);
1370
1371   for (const auto &S : getObj().sections()) {
1372     Expected<StringRef> NameOrErr = S.getName();
1373     if (!NameOrErr)
1374       return NameOrErr.takeError();
1375     StringRef SectionName = *NameOrErr;
1376
1377     // .debug$T is a standard CodeView type section, while .debug$P is the same
1378     // format but used for MSVC precompiled header object files.
1379     if (SectionName == ".debug$T")
1380       printHeader(P, "Types (.debug$T)");
1381     else if (SectionName == ".debug$P")
1382       printHeader(P, "Precompiled Types (.debug$P)");
1383     else
1384       continue;
1385
1386     Expected<StringRef> ContentsOrErr = S.getContents();
1387     if (!ContentsOrErr)
1388       return ContentsOrErr.takeError();
1389
1390     uint32_t Magic;
1391     BinaryStreamReader Reader(*ContentsOrErr, llvm::support::little);
1392     if (auto EC = Reader.readInteger(Magic))
1393       return EC;
1394     if (Magic != COFF::DEBUG_SECTION_MAGIC)
1395       return make_error<StringError>("Invalid CodeView debug section.",
1396                                      inconvertibleErrorCode());
1397
1398     Types.reset(Reader, 100);
1399
1400     if (opts::dump::DumpTypes) {
1401       dumpFullTypeStream(P, Types, RefTracker.get(), 0, 0, {}, nullptr,
1402                          opts::dump::DumpTypeData, false);
1403     } else if (opts::dump::DumpTypeExtras) {
1404       auto LocalHashes = LocallyHashedType::hashTypeCollection(Types);
1405       auto GlobalHashes = GloballyHashedType::hashTypeCollection(Types);
1406       assert(LocalHashes.size() == GlobalHashes.size());
1407
1408       P.formatLine("Local / Global hashes:");
1409       TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
1410       for (const auto &H : zip(LocalHashes, GlobalHashes)) {
1411         AutoIndent Indent2(P);
1412         LocallyHashedType &L = std::get<0>(H);
1413         GloballyHashedType &G = std::get<1>(H);
1414
1415         P.formatLine("TI: {0}, LocalHash: {1:X}, GlobalHash: {2}", TI, L, G);
1416
1417         ++TI;
1418       }
1419       P.NewLine();
1420     }
1421   }
1422
1423   return Error::success();
1424 }
1425
1426 Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
1427   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
1428
1429   if (StreamIdx == StreamTPI) {
1430     printHeader(P, "Types (TPI Stream)");
1431   } else if (StreamIdx == StreamIPI) {
1432     printHeader(P, "Types (IPI Stream)");
1433   }
1434
1435   assert(!File.isObj());
1436
1437   bool Present = false;
1438   bool DumpTypes = false;
1439   bool DumpBytes = false;
1440   bool DumpExtras = false;
1441   std::vector<uint32_t> Indices;
1442   if (StreamIdx == StreamTPI) {
1443     Present = getPdb().hasPDBTpiStream();
1444     DumpTypes = opts::dump::DumpTypes;
1445     DumpBytes = opts::dump::DumpTypeData;
1446     DumpExtras = opts::dump::DumpTypeExtras;
1447     Indices.assign(opts::dump::DumpTypeIndex.begin(),
1448                    opts::dump::DumpTypeIndex.end());
1449   } else if (StreamIdx == StreamIPI) {
1450     Present = getPdb().hasPDBIpiStream();
1451     DumpTypes = opts::dump::DumpIds;
1452     DumpBytes = opts::dump::DumpIdData;
1453     DumpExtras = opts::dump::DumpIdExtras;
1454     Indices.assign(opts::dump::DumpIdIndex.begin(),
1455                    opts::dump::DumpIdIndex.end());
1456   }
1457
1458   if (!Present) {
1459     printStreamNotPresent(StreamIdx == StreamTPI ? "TPI" : "IPI");
1460     return Error::success();
1461   }
1462
1463   AutoIndent Indent(P);
1464   ExitOnError Err("Unexpected error processing types: ");
1465
1466   auto &Stream = Err((StreamIdx == StreamTPI) ? getPdb().getPDBTpiStream()
1467                                               : getPdb().getPDBIpiStream());
1468
1469   auto &Types = (StreamIdx == StreamTPI) ? File.types() : File.ids();
1470
1471   // Only emit notes about referenced/unreferenced for types.
1472   TypeReferenceTracker *MaybeTracker =
1473       (StreamIdx == StreamTPI) ? RefTracker.get() : nullptr;
1474
1475   // Enable resolving forward decls.
1476   Stream.buildHashMap();
1477
1478   if (DumpTypes || !Indices.empty()) {
1479     if (Indices.empty())
1480       dumpFullTypeStream(P, Types, MaybeTracker, Stream.getNumTypeRecords(),
1481                          Stream.getNumHashBuckets(), Stream.getHashValues(),
1482                          &Stream, DumpBytes, DumpExtras);
1483     else {
1484       std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
1485       dumpPartialTypeStream(P, Types, MaybeTracker, Stream, TiList, DumpBytes,
1486                             DumpExtras, opts::dump::DumpTypeDependents);
1487     }
1488   }
1489
1490   if (DumpExtras) {
1491     P.NewLine();
1492
1493     P.formatLine("Header Version: {0}",
1494                  static_cast<uint32_t>(Stream.getTpiVersion()));
1495     P.formatLine("Hash Stream Index: {0}", Stream.getTypeHashStreamIndex());
1496     P.formatLine("Aux Hash Stream Index: {0}",
1497                  Stream.getTypeHashStreamAuxIndex());
1498     P.formatLine("Hash Key Size: {0}", Stream.getHashKeySize());
1499     P.formatLine("Num Hash Buckets: {0}", Stream.getNumHashBuckets());
1500
1501     auto IndexOffsets = Stream.getTypeIndexOffsets();
1502     P.formatLine("Type Index Offsets:");
1503     for (const auto &IO : IndexOffsets) {
1504       AutoIndent Indent2(P);
1505       P.formatLine("TI: {0}, Offset: {1}", IO.Type, fmtle(IO.Offset));
1506     }
1507
1508     if (getPdb().hasPDBStringTable()) {
1509       P.NewLine();
1510       P.formatLine("Hash Adjusters:");
1511       auto &Adjusters = Stream.getHashAdjusters();
1512       auto &Strings = Err(getPdb().getStringTable());
1513       for (const auto &A : Adjusters) {
1514         AutoIndent Indent2(P);
1515         auto ExpectedStr = Strings.getStringForID(A.first);
1516         TypeIndex TI(A.second);
1517         if (ExpectedStr)
1518           P.formatLine("`{0}` -> {1}", *ExpectedStr, TI);
1519         else {
1520           P.formatLine("unknown str id ({0}) -> {1}", A.first, TI);
1521           consumeError(ExpectedStr.takeError());
1522         }
1523       }
1524     }
1525   }
1526   return Error::success();
1527 }
1528
1529 Error DumpOutputStyle::dumpModuleSymsForObj() {
1530   printHeader(P, "Symbols");
1531
1532   AutoIndent Indent(P);
1533
1534   ExitOnError Err("Unexpected error processing symbols: ");
1535
1536   auto &Types = File.types();
1537
1538   SymbolVisitorCallbackPipeline Pipeline;
1539   SymbolDeserializer Deserializer(nullptr, CodeViewContainer::ObjectFile);
1540   MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Types, Types);
1541
1542   Pipeline.addCallbackToPipeline(Deserializer);
1543   Pipeline.addCallbackToPipeline(Dumper);
1544   CVSymbolVisitor Visitor(Pipeline);
1545
1546   std::unique_ptr<llvm::Error> SymbolError;
1547
1548   iterateModuleSubsections<DebugSymbolsSubsectionRef>(
1549       File, PrintScope{P, 2},
1550       [&](uint32_t Modi, const SymbolGroup &Strings,
1551           DebugSymbolsSubsectionRef &Symbols) {
1552         Dumper.setSymbolGroup(&Strings);
1553         for (auto Symbol : Symbols) {
1554           if (auto EC = Visitor.visitSymbolRecord(Symbol)) {
1555             SymbolError = std::make_unique<Error>(std::move(EC));
1556             return;
1557           }
1558         }
1559       });
1560
1561   if (SymbolError)
1562     return std::move(*SymbolError);
1563
1564   return Error::success();
1565 }
1566
1567 Error DumpOutputStyle::dumpModuleSymsForPdb() {
1568   printHeader(P, "Symbols");
1569
1570   if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
1571     printStreamNotPresent("DBI");
1572     return Error::success();
1573   }
1574
1575   AutoIndent Indent(P);
1576   ExitOnError Err("Unexpected error processing symbols: ");
1577
1578   auto &Ids = File.ids();
1579   auto &Types = File.types();
1580
1581   iterateSymbolGroups(
1582       File, PrintScope{P, 2}, [&](uint32_t I, const SymbolGroup &Strings) {
1583         auto ExpectedModS = getModuleDebugStream(File.pdb(), I);
1584         if (!ExpectedModS) {
1585           P.formatLine("Error loading module stream {0}.  {1}", I,
1586                        toString(ExpectedModS.takeError()));
1587           return;
1588         }
1589
1590         ModuleDebugStreamRef &ModS = *ExpectedModS;
1591
1592         SymbolVisitorCallbackPipeline Pipeline;
1593         SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
1594         MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Strings,
1595                                    Ids, Types);
1596
1597         Pipeline.addCallbackToPipeline(Deserializer);
1598         Pipeline.addCallbackToPipeline(Dumper);
1599         CVSymbolVisitor Visitor(Pipeline);
1600         auto SS = ModS.getSymbolsSubstream();
1601         if (auto EC =
1602                 Visitor.visitSymbolStream(ModS.getSymbolArray(), SS.Offset)) {
1603           P.formatLine("Error while processing symbol records.  {0}",
1604                        toString(std::move(EC)));
1605           return;
1606         }
1607       });
1608   return Error::success();
1609 }
1610
1611 Error DumpOutputStyle::dumpTypeRefStats() {
1612   printHeader(P, "Type Reference Statistics");
1613   AutoIndent Indent(P);
1614
1615   // Sum the byte size of all type records, and the size and count of all
1616   // referenced records.
1617   size_t TotalRecs = File.types().size();
1618   size_t RefRecs = 0;
1619   size_t TotalBytes = 0;
1620   size_t RefBytes = 0;
1621   auto &Types = File.types();
1622   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
1623     CVType Type = File.types().getType(*TI);
1624     TotalBytes += Type.length();
1625     if (RefTracker->isTypeReferenced(*TI)) {
1626       ++RefRecs;
1627       RefBytes += Type.length();
1628     }
1629   }
1630
1631   P.formatLine("Records referenced: {0:N} / {1:N} {2:P}", RefRecs, TotalRecs,
1632                (double)RefRecs / TotalRecs);
1633   P.formatLine("Bytes referenced: {0:N} / {1:N} {2:P}", RefBytes, TotalBytes,
1634                (double)RefBytes / TotalBytes);
1635
1636   return Error::success();
1637 }
1638
1639 Error DumpOutputStyle::dumpGSIRecords() {
1640   printHeader(P, "GSI Records");
1641
1642   if (File.isObj()) {
1643     printStreamNotValidForObj();
1644     return Error::success();
1645   }
1646
1647   if (!getPdb().hasPDBSymbolStream()) {
1648     printStreamNotPresent("GSI Common Symbol");
1649     return Error::success();
1650   }
1651
1652   AutoIndent Indent(P);
1653
1654   auto &Records = cantFail(getPdb().getPDBSymbolStream());
1655   auto &Types = File.types();
1656   auto &Ids = File.ids();
1657
1658   P.printLine("Records");
1659   SymbolVisitorCallbackPipeline Pipeline;
1660   SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
1661   MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
1662
1663   Pipeline.addCallbackToPipeline(Deserializer);
1664   Pipeline.addCallbackToPipeline(Dumper);
1665   CVSymbolVisitor Visitor(Pipeline);
1666
1667   BinaryStreamRef SymStream = Records.getSymbolArray().getUnderlyingStream();
1668   if (auto E = Visitor.visitSymbolStream(Records.getSymbolArray(), 0))
1669     return E;
1670   return Error::success();
1671 }
1672
1673 Error DumpOutputStyle::dumpGlobals() {
1674   printHeader(P, "Global Symbols");
1675
1676   if (File.isObj()) {
1677     printStreamNotValidForObj();
1678     return Error::success();
1679   }
1680
1681   if (!getPdb().hasPDBGlobalsStream()) {
1682     printStreamNotPresent("Globals");
1683     return Error::success();
1684   }
1685
1686   AutoIndent Indent(P);
1687   ExitOnError Err("Error dumping globals stream: ");
1688   auto &Globals = Err(getPdb().getPDBGlobalsStream());
1689
1690   if (opts::dump::DumpGlobalNames.empty()) {
1691     const GSIHashTable &Table = Globals.getGlobalsTable();
1692     Err(dumpSymbolsFromGSI(Table, opts::dump::DumpGlobalExtras));
1693   } else {
1694     SymbolStream &SymRecords = cantFail(getPdb().getPDBSymbolStream());
1695     auto &Types = File.types();
1696     auto &Ids = File.ids();
1697
1698     SymbolVisitorCallbackPipeline Pipeline;
1699     SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
1700     MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
1701
1702     Pipeline.addCallbackToPipeline(Deserializer);
1703     Pipeline.addCallbackToPipeline(Dumper);
1704     CVSymbolVisitor Visitor(Pipeline);
1705
1706     using ResultEntryType = std::pair<uint32_t, CVSymbol>;
1707     for (StringRef Name : opts::dump::DumpGlobalNames) {
1708       AutoIndent Indent(P);
1709       P.formatLine("Global Name `{0}`", Name);
1710       std::vector<ResultEntryType> Results =
1711           Globals.findRecordsByName(Name, SymRecords);
1712       if (Results.empty()) {
1713         AutoIndent Indent(P);
1714         P.printLine("(no matching records found)");
1715         continue;
1716       }
1717
1718       for (ResultEntryType Result : Results) {
1719         if (auto E = Visitor.visitSymbolRecord(Result.second, Result.first))
1720           return E;
1721       }
1722     }
1723   }
1724   return Error::success();
1725 }
1726
1727 Error DumpOutputStyle::dumpPublics() {
1728   printHeader(P, "Public Symbols");
1729
1730   if (File.isObj()) {
1731     printStreamNotValidForObj();
1732     return Error::success();
1733   }
1734
1735   if (!getPdb().hasPDBPublicsStream()) {
1736     printStreamNotPresent("Publics");
1737     return Error::success();
1738   }
1739
1740   AutoIndent Indent(P);
1741   ExitOnError Err("Error dumping publics stream: ");
1742   auto &Publics = Err(getPdb().getPDBPublicsStream());
1743
1744   const GSIHashTable &PublicsTable = Publics.getPublicsTable();
1745   if (opts::dump::DumpPublicExtras) {
1746     P.printLine("Publics Header");
1747     AutoIndent Indent(P);
1748     P.formatLine("sym hash = {0}, thunk table addr = {1}", Publics.getSymHash(),
1749                  formatSegmentOffset(Publics.getThunkTableSection(),
1750                                      Publics.getThunkTableOffset()));
1751   }
1752   Err(dumpSymbolsFromGSI(PublicsTable, opts::dump::DumpPublicExtras));
1753
1754   // Skip the rest if we aren't dumping extras.
1755   if (!opts::dump::DumpPublicExtras)
1756     return Error::success();
1757
1758   P.formatLine("Address Map");
1759   {
1760     // These are offsets into the publics stream sorted by secidx:secrel.
1761     AutoIndent Indent2(P);
1762     for (uint32_t Addr : Publics.getAddressMap())
1763       P.formatLine("off = {0}", Addr);
1764   }
1765
1766   // The thunk map is optional debug info used for ILT thunks.
1767   if (!Publics.getThunkMap().empty()) {
1768     P.formatLine("Thunk Map");
1769     AutoIndent Indent2(P);
1770     for (uint32_t Addr : Publics.getThunkMap())
1771       P.formatLine("{0:x8}", Addr);
1772   }
1773
1774   // The section offsets table appears to be empty when incremental linking
1775   // isn't in use.
1776   if (!Publics.getSectionOffsets().empty()) {
1777     P.formatLine("Section Offsets");
1778     AutoIndent Indent2(P);
1779     for (const SectionOffset &SO : Publics.getSectionOffsets())
1780       P.formatLine("{0:x4}:{1:x8}", uint16_t(SO.Isect), uint32_t(SO.Off));
1781   }
1782
1783   return Error::success();
1784 }
1785
1786 Error DumpOutputStyle::dumpSymbolsFromGSI(const GSIHashTable &Table,
1787                                           bool HashExtras) {
1788   auto ExpectedSyms = getPdb().getPDBSymbolStream();
1789   if (!ExpectedSyms)
1790     return ExpectedSyms.takeError();
1791   auto &Types = File.types();
1792   auto &Ids = File.ids();
1793
1794   if (HashExtras) {
1795     P.printLine("GSI Header");
1796     AutoIndent Indent(P);
1797     P.formatLine("sig = {0:X}, hdr = {1:X}, hr size = {2}, num buckets = {3}",
1798                  Table.getVerSignature(), Table.getVerHeader(),
1799                  Table.getHashRecordSize(), Table.getNumBuckets());
1800   }
1801
1802   {
1803     P.printLine("Records");
1804     SymbolVisitorCallbackPipeline Pipeline;
1805     SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
1806     MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
1807
1808     Pipeline.addCallbackToPipeline(Deserializer);
1809     Pipeline.addCallbackToPipeline(Dumper);
1810     CVSymbolVisitor Visitor(Pipeline);
1811
1812
1813     BinaryStreamRef SymStream =
1814         ExpectedSyms->getSymbolArray().getUnderlyingStream();
1815     for (uint32_t PubSymOff : Table) {
1816       Expected<CVSymbol> Sym = readSymbolFromStream(SymStream, PubSymOff);
1817       if (!Sym)
1818         return Sym.takeError();
1819       if (auto E = Visitor.visitSymbolRecord(*Sym, PubSymOff))
1820         return E;
1821     }
1822   }
1823
1824   // Return early if we aren't dumping public hash table and address map info.
1825   if (HashExtras) {
1826     P.formatLine("Hash Entries");
1827     {
1828       AutoIndent Indent2(P);
1829       for (const PSHashRecord &HR : Table.HashRecords)
1830         P.formatLine("off = {0}, refcnt = {1}", uint32_t(HR.Off),
1831           uint32_t(HR.CRef));
1832     }
1833
1834     P.formatLine("Hash Buckets");
1835     {
1836       AutoIndent Indent2(P);
1837       for (uint32_t Hash : Table.HashBuckets)
1838         P.formatLine("{0:x8}", Hash);
1839     }
1840   }
1841
1842   return Error::success();
1843 }
1844
1845 static std::string formatSegMapDescriptorFlag(uint32_t IndentLevel,
1846                                               OMFSegDescFlags Flags) {
1847   std::vector<std::string> Opts;
1848   if (Flags == OMFSegDescFlags::None)
1849     return "none";
1850
1851   PUSH_FLAG(OMFSegDescFlags, Read, Flags, "read");
1852   PUSH_FLAG(OMFSegDescFlags, Write, Flags, "write");
1853   PUSH_FLAG(OMFSegDescFlags, Execute, Flags, "execute");
1854   PUSH_FLAG(OMFSegDescFlags, AddressIs32Bit, Flags, "32 bit addr");
1855   PUSH_FLAG(OMFSegDescFlags, IsSelector, Flags, "selector");
1856   PUSH_FLAG(OMFSegDescFlags, IsAbsoluteAddress, Flags, "absolute addr");
1857   PUSH_FLAG(OMFSegDescFlags, IsGroup, Flags, "group");
1858   return typesetItemList(Opts, IndentLevel, 4, " | ");
1859 }
1860
1861 Error DumpOutputStyle::dumpSectionHeaders() {
1862   dumpSectionHeaders("Section Headers", DbgHeaderType::SectionHdr);
1863   dumpSectionHeaders("Original Section Headers", DbgHeaderType::SectionHdrOrig);
1864   return Error::success();
1865 }
1866
1867 void DumpOutputStyle::dumpSectionHeaders(StringRef Label, DbgHeaderType Type) {
1868   printHeader(P, Label);
1869
1870   if (File.isObj()) {
1871     printStreamNotValidForObj();
1872     return;
1873   }
1874
1875   if (!getPdb().hasPDBDbiStream()) {
1876     printStreamNotPresent("DBI");
1877     return;
1878   }
1879
1880   AutoIndent Indent(P);
1881   ExitOnError Err("Error dumping section headers: ");
1882   std::unique_ptr<MappedBlockStream> Stream;
1883   ArrayRef<object::coff_section> Headers;
1884   auto ExpectedHeaders = loadSectionHeaders(getPdb(), Type);
1885   if (!ExpectedHeaders) {
1886     P.printLine(toString(ExpectedHeaders.takeError()));
1887     return;
1888   }
1889   std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
1890
1891   uint32_t I = 1;
1892   for (const auto &Header : Headers) {
1893     P.NewLine();
1894     P.formatLine("SECTION HEADER #{0}", I);
1895     P.formatLine("{0,8} name", Header.Name);
1896     P.formatLine("{0,8:X-} virtual size", uint32_t(Header.VirtualSize));
1897     P.formatLine("{0,8:X-} virtual address", uint32_t(Header.VirtualAddress));
1898     P.formatLine("{0,8:X-} size of raw data", uint32_t(Header.SizeOfRawData));
1899     P.formatLine("{0,8:X-} file pointer to raw data",
1900                  uint32_t(Header.PointerToRawData));
1901     P.formatLine("{0,8:X-} file pointer to relocation table",
1902                  uint32_t(Header.PointerToRelocations));
1903     P.formatLine("{0,8:X-} file pointer to line numbers",
1904                  uint32_t(Header.PointerToLinenumbers));
1905     P.formatLine("{0,8:X-} number of relocations",
1906                  uint32_t(Header.NumberOfRelocations));
1907     P.formatLine("{0,8:X-} number of line numbers",
1908                  uint32_t(Header.NumberOfLinenumbers));
1909     P.formatLine("{0,8:X-} flags", uint32_t(Header.Characteristics));
1910     AutoIndent IndentMore(P, 9);
1911     P.formatLine("{0}", formatSectionCharacteristics(
1912                             P.getIndentLevel(), Header.Characteristics, 1, ""));
1913     ++I;
1914   }
1915   return;
1916 }
1917
1918 Error DumpOutputStyle::dumpSectionContribs() {
1919   printHeader(P, "Section Contributions");
1920
1921   if (File.isObj()) {
1922     printStreamNotValidForObj();
1923     return Error::success();
1924   }
1925
1926   if (!getPdb().hasPDBDbiStream()) {
1927     printStreamNotPresent("DBI");
1928     return Error::success();
1929   }
1930
1931   AutoIndent Indent(P);
1932   ExitOnError Err("Error dumping section contributions: ");
1933
1934   auto &Dbi = Err(getPdb().getPDBDbiStream());
1935
1936   class Visitor : public ISectionContribVisitor {
1937   public:
1938     Visitor(LinePrinter &P, ArrayRef<std::string> Names) : P(P), Names(Names) {
1939       auto Max = std::max_element(
1940           Names.begin(), Names.end(),
1941           [](StringRef S1, StringRef S2) { return S1.size() < S2.size(); });
1942       MaxNameLen = (Max == Names.end() ? 0 : Max->size());
1943     }
1944     void visit(const SectionContrib &SC) override {
1945       dumpSectionContrib(P, SC, Names, MaxNameLen);
1946     }
1947     void visit(const SectionContrib2 &SC) override {
1948       dumpSectionContrib(P, SC, Names, MaxNameLen);
1949     }
1950
1951   private:
1952     LinePrinter &P;
1953     uint32_t MaxNameLen;
1954     ArrayRef<std::string> Names;
1955   };
1956
1957   std::vector<std::string> Names = getSectionNames(getPdb());
1958   Visitor V(P, makeArrayRef(Names));
1959   Dbi.visitSectionContributions(V);
1960   return Error::success();
1961 }
1962
1963 Error DumpOutputStyle::dumpSectionMap() {
1964   printHeader(P, "Section Map");
1965
1966   if (File.isObj()) {
1967     printStreamNotValidForObj();
1968     return Error::success();
1969   }
1970
1971   if (!getPdb().hasPDBDbiStream()) {
1972     printStreamNotPresent("DBI");
1973     return Error::success();
1974   }
1975
1976   AutoIndent Indent(P);
1977   ExitOnError Err("Error dumping section map: ");
1978
1979   auto &Dbi = Err(getPdb().getPDBDbiStream());
1980
1981   uint32_t I = 0;
1982   for (auto &M : Dbi.getSectionMap()) {
1983     P.formatLine(
1984         "Section {0:4} | ovl = {1}, group = {2}, frame = {3}, name = {4}", I,
1985         fmtle(M.Ovl), fmtle(M.Group), fmtle(M.Frame), fmtle(M.SecName));
1986     P.formatLine("               class = {0}, offset = {1}, size = {2}",
1987                  fmtle(M.ClassName), fmtle(M.Offset), fmtle(M.SecByteLength));
1988     P.formatLine("               flags = {0}",
1989                  formatSegMapDescriptorFlag(
1990                      P.getIndentLevel() + 13,
1991                      static_cast<OMFSegDescFlags>(uint16_t(M.Flags))));
1992     ++I;
1993   }
1994   return Error::success();
1995 }