contrib/llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

   1 //===- DumpOutputStyle.cpp ------------------------------------ *- C++ --*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "DumpOutputStyle.h"
  11
  12 #include "FormatUtil.h"
  13 #include "MinimalSymbolDumper.h"
  14 #include "MinimalTypeDumper.h"
  15 #include "StreamUtil.h"
  16 #include "llvm-pdbutil.h"
  17
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
  20 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
  21 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
  22 #include "llvm/DebugInfo/CodeView/DebugCrossExSubsection.h"
  23 #include "llvm/DebugInfo/CodeView/DebugCrossImpSubsection.h"
  24 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
  25 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
  26 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
  27 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
  28 #include "llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h"
  29 #include "llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h"
  30 #include "llvm/DebugInfo/CodeView/DebugUnknownSubsection.h"
  31 #include "llvm/DebugInfo/CodeView/EnumTables.h"
  32 #include "llvm/DebugInfo/CodeView/Formatters.h"
  33 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  34 #include "llvm/DebugInfo/CodeView/Line.h"
  35 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
  36 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
  37 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
  38 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
  39 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
  40 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
  41 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
  42 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
  43 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
  44 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  45 #include "llvm/DebugInfo/PDB/Native/EnumTables.h"
  46 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
  47 #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
  48 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
  49 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
  50 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  51 #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
  52 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  53 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
  54 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  55 #include "llvm/DebugInfo/PDB/PDBExtras.h"
  56 #include "llvm/Object/COFF.h"
  57 #include "llvm/Support/BinaryStreamReader.h"
  58 #include "llvm/Support/FormatAdapters.h"
  59 #include "llvm/Support/FormatVariadic.h"
  60
  61 #include <unordered_map>
  62
  63 using namespace llvm;
  64 using namespace llvm::codeview;
  65 using namespace llvm::msf;
  66 using namespace llvm::pdb;
  67
  68 DumpOutputStyle::DumpOutputStyle(PDBFile &File)
  69     : File(File), P(2, false, outs()) {}
  70
  71 Error DumpOutputStyle::dump() {
  72   if (opts::dump::DumpSummary) {
  73     if (auto EC = dumpFileSummary())
  74       return EC;
  75     P.NewLine();
  76   }
  77
  78   if (opts::dump::DumpStreams) {
  79     if (auto EC = dumpStreamSummary())
  80       return EC;
  81     P.NewLine();
  82   }
  83
  84   if (opts::dump::DumpStringTable) {
  85     if (auto EC = dumpStringTable())
  86       return EC;
  87     P.NewLine();
  88   }
  89
  90   if (opts::dump::DumpModules) {
  91     if (auto EC = dumpModules())
  92       return EC;
  93   }
  94
  95   if (opts::dump::DumpModuleFiles) {
  96     if (auto EC = dumpModuleFiles())
  97       return EC;
  98   }
  99
 100   if (opts::dump::DumpLines) {
 101     if (auto EC = dumpLines())
 102       return EC;
 103   }
 104
 105   if (opts::dump::DumpInlineeLines) {
 106     if (auto EC = dumpInlineeLines())
 107       return EC;
 108   }
 109
 110   if (opts::dump::DumpXmi) {
 111     if (auto EC = dumpXmi())
 112       return EC;
 113   }
 114
 115   if (opts::dump::DumpXme) {
 116     if (auto EC = dumpXme())
 117       return EC;
 118   }
 119
 120   if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
 121       opts::dump::DumpTypeExtras) {
 122     if (auto EC = dumpTpiStream(StreamTPI))
 123       return EC;
 124   }
 125
 126   if (opts::dump::DumpIds || !opts::dump::DumpIdIndex.empty() ||
 127       opts::dump::DumpIdExtras) {
 128     if (auto EC = dumpTpiStream(StreamIPI))
 129       return EC;
 130   }
 131
 132   if (opts::dump::DumpPublics) {
 133     if (auto EC = dumpPublics())
 134       return EC;
 135   }
 136
 137   if (opts::dump::DumpSymbols) {
 138     if (auto EC = dumpModuleSyms())
 139       return EC;
 140   }
 141
 142   if (opts::dump::DumpSectionContribs) {
 143     if (auto EC = dumpSectionContribs())
 144       return EC;
 145   }
 146
 147   if (opts::dump::DumpSectionMap) {
 148     if (auto EC = dumpSectionMap())
 149       return EC;
 150   }
 151
 152   return Error::success();
 153 }
 154
 155 static void printHeader(LinePrinter &P, const Twine &S) {
 156   P.NewLine();
 157   P.formatLine("{0,=60}", S);
 158   P.formatLine("{0}", fmt_repeat('=', 60));
 159 }
 160
 161 Error DumpOutputStyle::dumpFileSummary() {
 162   printHeader(P, "Summary");
 163
 164   ExitOnError Err("Invalid PDB Format");
 165
 166   AutoIndent Indent(P);
 167   P.formatLine("Block Size: {0}", File.getBlockSize());
 168   P.formatLine("Number of blocks: {0}", File.getBlockCount());
 169   P.formatLine("Number of streams: {0}", File.getNumStreams());
 170
 171   auto &PS = Err(File.getPDBInfoStream());
 172   P.formatLine("Signature: {0}", PS.getSignature());
 173   P.formatLine("Age: {0}", PS.getAge());
 174   P.formatLine("GUID: {0}", fmt_guid(PS.getGuid().Guid));
 175   P.formatLine("Features: {0:x+}", static_cast<uint32_t>(PS.getFeatures()));
 176   P.formatLine("Has Debug Info: {0}", File.hasPDBDbiStream());
 177   P.formatLine("Has Types: {0}", File.hasPDBTpiStream());
 178   P.formatLine("Has IDs: {0}", File.hasPDBIpiStream());
 179   P.formatLine("Has Globals: {0}", File.hasPDBGlobalsStream());
 180   P.formatLine("Has Publics: {0}", File.hasPDBPublicsStream());
 181   if (File.hasPDBDbiStream()) {
 182     auto &DBI = Err(File.getPDBDbiStream());
 183     P.formatLine("Is incrementally linked: {0}", DBI.isIncrementallyLinked());
 184     P.formatLine("Has conflicting types: {0}", DBI.hasCTypes());
 185     P.formatLine("Is stripped: {0}", DBI.isStripped());
 186   }
 187
 188   return Error::success();
 189 }
 190
 191 Error DumpOutputStyle::dumpStreamSummary() {
 192   printHeader(P, "Streams");
 193
 194   if (StreamPurposes.empty())
 195     discoverStreamPurposes(File, StreamPurposes);
 196
 197   AutoIndent Indent(P);
 198   uint32_t StreamCount = File.getNumStreams();
 199
 200   for (uint16_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
 201     P.formatLine(
 202         "Stream {0}: [{1}] ({2} bytes)",
 203         fmt_align(StreamIdx, AlignStyle::Right, NumDigits(StreamCount)),
 204         StreamPurposes[StreamIdx], File.getStreamByteSize(StreamIdx));
 205     if (opts::dump::DumpStreamBlocks) {
 206       auto Blocks = File.getStreamBlockList(StreamIdx);
 207       std::vector<uint32_t> BV(Blocks.begin(), Blocks.end());
 208       P.formatLine("       {0}  Blocks: [{1}]",
 209                    fmt_repeat(' ', NumDigits(StreamCount)),
 210                    make_range(BV.begin(), BV.end()));
 211     }
 212   }
 213
 214   return Error::success();
 215 }
 216
 217 static Expected<ModuleDebugStreamRef> getModuleDebugStream(PDBFile &File,
 218                                                            uint32_t Index) {
 219   ExitOnError Err("Unexpected error");
 220
 221   auto &Dbi = Err(File.getPDBDbiStream());
 222   const auto &Modules = Dbi.modules();
 223   auto Modi = Modules.getModuleDescriptor(Index);
 224
 225   uint16_t ModiStream = Modi.getModuleStreamIndex();
 226   if (ModiStream == kInvalidStreamIndex)
 227     return make_error<RawError>(raw_error_code::no_stream,
 228                                 "Module stream not present");
 229
 230   auto ModStreamData = MappedBlockStream::createIndexedStream(
 231       File.getMsfLayout(), File.getMsfBuffer(), ModiStream,
 232       File.getAllocator());
 233
 234   ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
 235   if (auto EC = ModS.reload())
 236     return make_error<RawError>(raw_error_code::corrupt_file,
 237                                 "Invalid module stream");
 238
 239   return std::move(ModS);
 240 }
 241
 242 static std::string formatChecksumKind(FileChecksumKind Kind) {
 243   switch (Kind) {
 244     RETURN_CASE(FileChecksumKind, None, "None");
 245     RETURN_CASE(FileChecksumKind, MD5, "MD5");
 246     RETURN_CASE(FileChecksumKind, SHA1, "SHA-1");
 247     RETURN_CASE(FileChecksumKind, SHA256, "SHA-256");
 248   }
 249   return formatUnknownEnum(Kind);
 250 }
 251
 252 namespace {
 253 class StringsAndChecksumsPrinter {
 254   const DebugStringTableSubsectionRef &extractStringTable(PDBFile &File) {
 255     ExitOnError Err("Unexpected error processing modules");
 256     return Err(File.getStringTable()).getStringTable();
 257   }
 258
 259   template <typename... Args>
 260   void formatInternal(LinePrinter &Printer, bool Append,
 261                       Args &&... args) const {
 262     if (Append)
 263       Printer.format(std::forward<Args>(args)...);
 264     else
 265       Printer.formatLine(std::forward<Args>(args)...);
 266   }
 267
 268 public:
 269   StringsAndChecksumsPrinter(PDBFile &File, uint32_t Modi)
 270       : Records(extractStringTable(File)) {
 271     auto MDS = getModuleDebugStream(File, Modi);
 272     if (!MDS) {
 273       consumeError(MDS.takeError());
 274       return;
 275     }
 276
 277     DebugStream = llvm::make_unique<ModuleDebugStreamRef>(std::move(*MDS));
 278     Records.initialize(MDS->subsections());
 279     if (Records.hasChecksums()) {
 280       for (const auto &Entry : Records.checksums()) {
 281         auto S = Records.strings().getString(Entry.FileNameOffset);
 282         if (!S)
 283           continue;
 284         ChecksumsByFile[*S] = Entry;
 285       }
 286     }
 287   }
 288
 289   Expected<StringRef> getNameFromStringTable(uint32_t Offset) const {
 290     return Records.strings().getString(Offset);
 291   }
 292
 293   void formatFromFileName(LinePrinter &Printer, StringRef File,
 294                           bool Append = false) const {
 295     auto FC = ChecksumsByFile.find(File);
 296     if (FC == ChecksumsByFile.end()) {
 297       formatInternal(Printer, Append, "- (no checksum) {0}", File);
 298       return;
 299     }
 300
 301     formatInternal(Printer, Append, "- ({0}: {1}) {2}",
 302                    formatChecksumKind(FC->getValue().Kind),
 303                    toHex(FC->getValue().Checksum), File);
 304   }
 305
 306   void formatFromChecksumsOffset(LinePrinter &Printer, uint32_t Offset,
 307                                  bool Append = false) const {
 308     if (!Records.hasChecksums()) {
 309       formatInternal(Printer, Append, "(unknown file name offset {0})", Offset);
 310       return;
 311     }
 312
 313     auto Iter = Records.checksums().getArray().at(Offset);
 314     if (Iter == Records.checksums().getArray().end()) {
 315       formatInternal(Printer, Append, "(unknown file name offset {0})", Offset);
 316       return;
 317     }
 318
 319     uint32_t FO = Iter->FileNameOffset;
 320     auto ExpectedFile = getNameFromStringTable(FO);
 321     if (!ExpectedFile) {
 322       formatInternal(Printer, Append, "(unknown file name offset {0})", Offset);
 323       consumeError(ExpectedFile.takeError());
 324       return;
 325     }
 326     if (Iter->Kind == FileChecksumKind::None) {
 327       formatInternal(Printer, Append, "{0} (no checksum)", *ExpectedFile);
 328     } else {
 329       formatInternal(Printer, Append, "{0} ({1}: {2})", *ExpectedFile,
 330                      formatChecksumKind(Iter->Kind), toHex(Iter->Checksum));
 331     }
 332   }
 333
 334   std::unique_ptr<ModuleDebugStreamRef> DebugStream;
 335   StringsAndChecksumsRef Records;
 336   StringMap<FileChecksumEntry> ChecksumsByFile;
 337 };
 338 } // namespace
 339
 340 template <typename CallbackT>
 341 static void iterateModules(PDBFile &File, LinePrinter &P, uint32_t IndentLevel,
 342                            CallbackT Callback) {
 343   AutoIndent Indent(P);
 344   if (!File.hasPDBDbiStream()) {
 345     P.formatLine("DBI Stream not present");
 346     return;
 347   }
 348
 349   ExitOnError Err("Unexpected error processing modules");
 350
 351   auto &Stream = Err(File.getPDBDbiStream());
 352
 353   const DbiModuleList &Modules = Stream.modules();
 354   uint32_t Count = Modules.getModuleCount();
 355   uint32_t Digits = NumDigits(Count);
 356   for (uint32_t I = 0; I < Count; ++I) {
 357     auto Modi = Modules.getModuleDescriptor(I);
 358     P.formatLine("Mod {0:4} | `{1}`: ", fmt_align(I, AlignStyle::Right, Digits),
 359                  Modi.getModuleName());
 360
 361     StringsAndChecksumsPrinter Strings(File, I);
 362     AutoIndent Indent2(P, IndentLevel);
 363     Callback(I, Strings);
 364   }
 365 }
 366
 367 template <typename SubsectionT>
 368 static void iterateModuleSubsections(
 369     PDBFile &File, LinePrinter &P, uint32_t IndentLevel,
 370     llvm::function_ref<void(uint32_t, StringsAndChecksumsPrinter &,
 371                             SubsectionT &)>
 372         Callback) {
 373
 374   iterateModules(
 375       File, P, IndentLevel,
 376       [&File, &Callback](uint32_t Modi, StringsAndChecksumsPrinter &Strings) {
 377         auto MDS = getModuleDebugStream(File, Modi);
 378         if (!MDS) {
 379           consumeError(MDS.takeError());
 380           return;
 381         }
 382
 383         for (const auto &SS : MDS->subsections()) {
 384           SubsectionT Subsection;
 385
 386           if (SS.kind() != Subsection.kind())
 387             continue;
 388
 389           BinaryStreamReader Reader(SS.getRecordData());
 390           if (auto EC = Subsection.initialize(Reader))
 391             continue;
 392           Callback(Modi, Strings, Subsection);
 393         }
 394       });
 395 }
 396
 397 Error DumpOutputStyle::dumpModules() {
 398   printHeader(P, "Modules");
 399
 400   AutoIndent Indent(P);
 401   if (!File.hasPDBDbiStream()) {
 402     P.formatLine("DBI Stream not present");
 403     return Error::success();
 404   }
 405
 406   ExitOnError Err("Unexpected error processing modules");
 407
 408   auto &Stream = Err(File.getPDBDbiStream());
 409
 410   const DbiModuleList &Modules = Stream.modules();
 411   uint32_t Count = Modules.getModuleCount();
 412   uint32_t Digits = NumDigits(Count);
 413   for (uint32_t I = 0; I < Count; ++I) {
 414     auto Modi = Modules.getModuleDescriptor(I);
 415     P.formatLine("Mod {0:4} | Name: `{1}`: ",
 416                  fmt_align(I, AlignStyle::Right, Digits), Modi.getModuleName());
 417     P.formatLine("           Obj: `{0}`: ", Modi.getObjFileName());
 418     P.formatLine("           debug stream: {0}, # files: {1}, has ec info: {2}",
 419                  Modi.getModuleStreamIndex(), Modi.getNumberOfFiles(),
 420                  Modi.hasECInfo());
 421     StringRef PdbFilePath =
 422         Err(Stream.getECName(Modi.getPdbFilePathNameIndex()));
 423     StringRef SrcFilePath =
 424         Err(Stream.getECName(Modi.getSourceFileNameIndex()));
 425     P.formatLine("           pdb file ni: {0} `{1}`, src file ni: {2} `{3}`",
 426                  Modi.getPdbFilePathNameIndex(), PdbFilePath,
 427                  Modi.getSourceFileNameIndex(), SrcFilePath);
 428   }
 429   return Error::success();
 430 }
 431
 432 Error DumpOutputStyle::dumpModuleFiles() {
 433   printHeader(P, "Files");
 434
 435   ExitOnError Err("Unexpected error processing modules");
 436
 437   iterateModules(
 438       File, P, 11,
 439       [this, &Err](uint32_t Modi, StringsAndChecksumsPrinter &Strings) {
 440         auto &Stream = Err(File.getPDBDbiStream());
 441
 442         const DbiModuleList &Modules = Stream.modules();
 443         for (const auto &F : Modules.source_files(Modi)) {
 444           Strings.formatFromFileName(P, F);
 445         }
 446       });
 447   return Error::success();
 448 }
 449
 450 static void typesetLinesAndColumns(PDBFile &File, LinePrinter &P,
 451                                    uint32_t Start, const LineColumnEntry &E) {
 452   const uint32_t kMaxCharsPerLineNumber = 4; // 4 digit line number
 453   uint32_t MinColumnWidth = kMaxCharsPerLineNumber + 5;
 454
 455   // Let's try to keep it under 100 characters
 456   constexpr uint32_t kMaxRowLength = 100;
 457   // At least 3 spaces between columns.
 458   uint32_t ColumnsPerRow = kMaxRowLength / (MinColumnWidth + 3);
 459   uint32_t ItemsLeft = E.LineNumbers.size();
 460   auto LineIter = E.LineNumbers.begin();
 461   while (ItemsLeft != 0) {
 462     uint32_t RowColumns = std::min(ItemsLeft, ColumnsPerRow);
 463     for (uint32_t I = 0; I < RowColumns; ++I) {
 464       LineInfo Line(LineIter->Flags);
 465       std::string LineStr;
 466       if (Line.isAlwaysStepInto())
 467         LineStr = "ASI";
 468       else if (Line.isNeverStepInto())
 469         LineStr = "NSI";
 470       else
 471         LineStr = utostr(Line.getStartLine());
 472       char Statement = Line.isStatement() ? ' ' : '!';
 473       P.format("{0} {1:X-} {2} ",
 474                fmt_align(LineStr, AlignStyle::Right, kMaxCharsPerLineNumber),
 475                fmt_align(Start + LineIter->Offset, AlignStyle::Right, 8, '0'),
 476                Statement);
 477       ++LineIter;
 478       --ItemsLeft;
 479     }
 480     P.NewLine();
 481   }
 482 }
 483
 484 Error DumpOutputStyle::dumpLines() {
 485   printHeader(P, "Lines");
 486
 487   uint32_t LastModi = UINT32_MAX;
 488   uint32_t LastNameIndex = UINT32_MAX;
 489   iterateModuleSubsections<DebugLinesSubsectionRef>(
 490       File, P, 4,
 491       [this, &LastModi, &LastNameIndex](uint32_t Modi,
 492                                         StringsAndChecksumsPrinter &Strings,
 493                                         DebugLinesSubsectionRef &Lines) {
 494         uint16_t Segment = Lines.header()->RelocSegment;
 495         uint32_t Begin = Lines.header()->RelocOffset;
 496         uint32_t End = Begin + Lines.header()->CodeSize;
 497         for (const auto &Block : Lines) {
 498           if (LastModi != Modi || LastNameIndex != Block.NameIndex) {
 499             LastModi = Modi;
 500             LastNameIndex = Block.NameIndex;
 501             Strings.formatFromChecksumsOffset(P, Block.NameIndex);
 502           }
 503
 504           AutoIndent Indent(P, 2);
 505           P.formatLine("{0:X-4}:{1:X-8}-{2:X-8}, ", Segment, Begin, End);
 506           uint32_t Count = Block.LineNumbers.size();
 507           if (Lines.hasColumnInfo())
 508             P.format("line/column/addr entries = {0}", Count);
 509           else
 510             P.format("line/addr entries = {0}", Count);
 511
 512           P.NewLine();
 513           typesetLinesAndColumns(File, P, Begin, Block);
 514         }
 515       });
 516
 517   return Error::success();
 518 }
 519
 520 Error DumpOutputStyle::dumpInlineeLines() {
 521   printHeader(P, "Inlinee Lines");
 522
 523   iterateModuleSubsections<DebugInlineeLinesSubsectionRef>(
 524       File, P, 2,
 525       [this](uint32_t Modi, StringsAndChecksumsPrinter &Strings,
 526              DebugInlineeLinesSubsectionRef &Lines) {
 527         P.formatLine("{0,+8} | {1,+5} | {2}", "Inlinee", "Line", "Source File");
 528         for (const auto &Entry : Lines) {
 529           P.formatLine("{0,+8} | {1,+5} | ", Entry.Header->Inlinee,
 530                        fmtle(Entry.Header->SourceLineNum));
 531           Strings.formatFromChecksumsOffset(P, Entry.Header->FileID, true);
 532         }
 533         P.NewLine();
 534       });
 535
 536   return Error::success();
 537 }
 538
 539 Error DumpOutputStyle::dumpXmi() {
 540   printHeader(P, "Cross Module Imports");
 541   iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
 542       File, P, 2,
 543       [this](uint32_t Modi, StringsAndChecksumsPrinter &Strings,
 544              DebugCrossModuleImportsSubsectionRef &Imports) {
 545         P.formatLine("{0,=32} | {1}", "Imported Module", "Type IDs");
 546
 547         for (const auto &Xmi : Imports) {
 548           auto ExpectedModule =
 549               Strings.getNameFromStringTable(Xmi.Header->ModuleNameOffset);
 550           StringRef Module;
 551           SmallString<32> ModuleStorage;
 552           if (!ExpectedModule) {
 553             Module = "(unknown module)";
 554             consumeError(ExpectedModule.takeError());
 555           } else
 556             Module = *ExpectedModule;
 557           if (Module.size() > 32) {
 558             ModuleStorage = "...";
 559             ModuleStorage += Module.take_back(32 - 3);
 560             Module = ModuleStorage;
 561           }
 562           std::vector<std::string> TIs;
 563           for (const auto I : Xmi.Imports)
 564             TIs.push_back(formatv("{0,+10:X+}", fmtle(I)));
 565           std::string Result =
 566               typesetItemList(TIs, P.getIndentLevel() + 35, 12, " ");
 567           P.formatLine("{0,+32} | {1}", Module, Result);
 568         }
 569       });
 570
 571   return Error::success();
 572 }
 573
 574 Error DumpOutputStyle::dumpXme() {
 575   printHeader(P, "Cross Module Exports");
 576
 577   iterateModuleSubsections<DebugCrossModuleExportsSubsectionRef>(
 578       File, P, 2,
 579       [this](uint32_t Modi, StringsAndChecksumsPrinter &Strings,
 580              DebugCrossModuleExportsSubsectionRef &Exports) {
 581         P.formatLine("{0,-10} | {1}", "Local ID", "Global ID");
 582         for (const auto &Export : Exports) {
 583           P.formatLine("{0,+10:X+} | {1}", TypeIndex(Export.Local),
 584                        TypeIndex(Export.Global));
 585         }
 586       });
 587
 588   return Error::success();
 589 }
 590
 591 Error DumpOutputStyle::dumpStringTable() {
 592   printHeader(P, "String Table");
 593
 594   AutoIndent Indent(P);
 595   auto IS = File.getStringTable();
 596   if (!IS) {
 597     P.formatLine("Not present in file");
 598     consumeError(IS.takeError());
 599     return Error::success();
 600   }
 601
 602   if (IS->name_ids().empty()) {
 603     P.formatLine("Empty");
 604     return Error::success();
 605   }
 606
 607   auto MaxID = std::max_element(IS->name_ids().begin(), IS->name_ids().end());
 608   uint32_t Digits = NumDigits(*MaxID);
 609
 610   P.formatLine("{0} | {1}", fmt_align("ID", AlignStyle::Right, Digits),
 611                "String");
 612
 613   std::vector<uint32_t> SortedIDs(IS->name_ids().begin(), IS->name_ids().end());
 614   std::sort(SortedIDs.begin(), SortedIDs.end());
 615   for (uint32_t I : SortedIDs) {
 616     auto ES = IS->getStringForID(I);
 617     llvm::SmallString<32> Str;
 618     if (!ES) {
 619       consumeError(ES.takeError());
 620       Str = "Error reading string";
 621     } else if (!ES->empty()) {
 622       Str.append("'");
 623       Str.append(*ES);
 624       Str.append("'");
 625     }
 626
 627     if (!Str.empty())
 628       P.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Digits), Str);
 629   }
 630   return Error::success();
 631 }
 632
 633 static void buildDepSet(LazyRandomTypeCollection &Types,
 634                         ArrayRef<TypeIndex> Indices,
 635                         std::map<TypeIndex, CVType> &DepSet) {
 636   SmallVector<TypeIndex, 4> DepList;
 637   for (const auto &I : Indices) {
 638     TypeIndex TI(I);
 639     if (DepSet.find(TI) != DepSet.end() || TI.isSimple() || TI.isNoneType())
 640       continue;
 641
 642     CVType Type = Types.getType(TI);
 643     DepSet[TI] = Type;
 644     codeview::discoverTypeIndices(Type, DepList);
 645     buildDepSet(Types, DepList, DepSet);
 646   }
 647 }
 648
 649 static void dumpFullTypeStream(LinePrinter &Printer,
 650                                LazyRandomTypeCollection &Types,
 651                                TpiStream &Stream, bool Bytes, bool Extras) {
 652   Printer.formatLine("Showing {0:N} records", Stream.getNumTypeRecords());
 653   uint32_t Width =
 654       NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
 655
 656   MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types,
 657                            Stream.getNumHashBuckets(), Stream.getHashValues());
 658
 659   if (auto EC = codeview::visitTypeStream(Types, V)) {
 660     Printer.formatLine("An error occurred dumping type records: {0}",
 661                        toString(std::move(EC)));
 662   }
 663 }
 664
 665 static void dumpPartialTypeStream(LinePrinter &Printer,
 666                                   LazyRandomTypeCollection &Types,
 667                                   TpiStream &Stream, ArrayRef<TypeIndex> TiList,
 668                                   bool Bytes, bool Extras, bool Deps) {
 669   uint32_t Width =
 670       NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
 671
 672   MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types,
 673                            Stream.getNumHashBuckets(), Stream.getHashValues());
 674
 675   if (opts::dump::DumpTypeDependents) {
 676     // If we need to dump all dependents, then iterate each index and find
 677     // all dependents, adding them to a map ordered by TypeIndex.
 678     std::map<TypeIndex, CVType> DepSet;
 679     buildDepSet(Types, TiList, DepSet);
 680
 681     Printer.formatLine(
 682         "Showing {0:N} records and their dependents ({1:N} records total)",
 683         TiList.size(), DepSet.size());
 684
 685     for (auto &Dep : DepSet) {
 686       if (auto EC = codeview::visitTypeRecord(Dep.second, Dep.first, V))
 687         Printer.formatLine("An error occurred dumping type record {0}: {1}",
 688                            Dep.first, toString(std::move(EC)));
 689     }
 690   } else {
 691     Printer.formatLine("Showing {0:N} records.", TiList.size());
 692
 693     for (const auto &I : TiList) {
 694       TypeIndex TI(I);
 695       CVType Type = Types.getType(TI);
 696       if (auto EC = codeview::visitTypeRecord(Type, TI, V))
 697         Printer.formatLine("An error occurred dumping type record {0}: {1}", TI,
 698                            toString(std::move(EC)));
 699     }
 700   }
 701 }
 702
 703 Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
 704   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 705
 706   bool Present = false;
 707   bool DumpTypes = false;
 708   bool DumpBytes = false;
 709   bool DumpExtras = false;
 710   std::vector<uint32_t> Indices;
 711   if (StreamIdx == StreamTPI) {
 712     printHeader(P, "Types (TPI Stream)");
 713     Present = File.hasPDBTpiStream();
 714     DumpTypes = opts::dump::DumpTypes;
 715     DumpBytes = opts::dump::DumpTypeData;
 716     DumpExtras = opts::dump::DumpTypeExtras;
 717     Indices.assign(opts::dump::DumpTypeIndex.begin(),
 718                    opts::dump::DumpTypeIndex.end());
 719   } else if (StreamIdx == StreamIPI) {
 720     printHeader(P, "Types (IPI Stream)");
 721     Present = File.hasPDBIpiStream();
 722     DumpTypes = opts::dump::DumpIds;
 723     DumpBytes = opts::dump::DumpIdData;
 724     DumpExtras = opts::dump::DumpIdExtras;
 725     Indices.assign(opts::dump::DumpIdIndex.begin(),
 726                    opts::dump::DumpIdIndex.end());
 727   }
 728
 729   AutoIndent Indent(P);
 730   if (!Present) {
 731     P.formatLine("Stream not present");
 732     return Error::success();
 733   }
 734
 735   ExitOnError Err("Unexpected error processing types");
 736
 737   auto &Stream = Err((StreamIdx == StreamTPI) ? File.getPDBTpiStream()
 738                                               : File.getPDBIpiStream());
 739
 740   auto &Types = Err(initializeTypes(StreamIdx));
 741
 742   if (DumpTypes || !Indices.empty()) {
 743     if (Indices.empty())
 744       dumpFullTypeStream(P, Types, Stream, DumpBytes, DumpExtras);
 745     else {
 746       std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
 747       dumpPartialTypeStream(P, Types, Stream, TiList, DumpBytes, DumpExtras,
 748                             opts::dump::DumpTypeDependents);
 749     }
 750   }
 751
 752   if (DumpExtras) {
 753     P.NewLine();
 754     auto IndexOffsets = Stream.getTypeIndexOffsets();
 755     P.formatLine("Type Index Offsets:");
 756     for (const auto &IO : IndexOffsets) {
 757       AutoIndent Indent2(P);
 758       P.formatLine("TI: {0}, Offset: {1}", IO.Type, fmtle(IO.Offset));
 759     }
 760
 761     P.NewLine();
 762     P.formatLine("Hash Adjusters:");
 763     auto &Adjusters = Stream.getHashAdjusters();
 764     auto &Strings = Err(File.getStringTable());
 765     for (const auto &A : Adjusters) {
 766       AutoIndent Indent2(P);
 767       auto ExpectedStr = Strings.getStringForID(A.first);
 768       TypeIndex TI(A.second);
 769       if (ExpectedStr)
 770         P.formatLine("`{0}` -> {1}", *ExpectedStr, TI);
 771       else {
 772         P.formatLine("unknown str id ({0}) -> {1}", A.first, TI);
 773         consumeError(ExpectedStr.takeError());
 774       }
 775     }
 776   }
 777   return Error::success();
 778 }
 779
 780 Expected<codeview::LazyRandomTypeCollection &>
 781 DumpOutputStyle::initializeTypes(uint32_t SN) {
 782   auto &TypeCollection = (SN == StreamTPI) ? TpiTypes : IpiTypes;
 783   auto Tpi =
 784       (SN == StreamTPI) ? File.getPDBTpiStream() : File.getPDBIpiStream();
 785   if (!Tpi)
 786     return Tpi.takeError();
 787
 788   if (!TypeCollection) {
 789     auto &Types = Tpi->typeArray();
 790     uint32_t Count = Tpi->getNumTypeRecords();
 791     auto Offsets = Tpi->getTypeIndexOffsets();
 792     TypeCollection =
 793         llvm::make_unique<LazyRandomTypeCollection>(Types, Count, Offsets);
 794   }
 795
 796   return *TypeCollection;
 797 }
 798
 799 Error DumpOutputStyle::dumpModuleSyms() {
 800   printHeader(P, "Symbols");
 801
 802   AutoIndent Indent(P);
 803   if (!File.hasPDBDbiStream()) {
 804     P.formatLine("DBI Stream not present");
 805     return Error::success();
 806   }
 807
 808   ExitOnError Err("Unexpected error processing symbols");
 809
 810   auto &Stream = Err(File.getPDBDbiStream());
 811
 812   auto &Types = Err(initializeTypes(StreamTPI));
 813
 814   const DbiModuleList &Modules = Stream.modules();
 815   uint32_t Count = Modules.getModuleCount();
 816   uint32_t Digits = NumDigits(Count);
 817   for (uint32_t I = 0; I < Count; ++I) {
 818     auto Modi = Modules.getModuleDescriptor(I);
 819     P.formatLine("Mod {0:4} | `{1}`: ", fmt_align(I, AlignStyle::Right, Digits),
 820                  Modi.getModuleName());
 821     uint16_t ModiStream = Modi.getModuleStreamIndex();
 822     if (ModiStream == kInvalidStreamIndex) {
 823       P.formatLine("           <symbols not present>");
 824       continue;
 825     }
 826     auto ModStreamData = MappedBlockStream::createIndexedStream(
 827         File.getMsfLayout(), File.getMsfBuffer(), ModiStream,
 828         File.getAllocator());
 829
 830     ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
 831     if (auto EC = ModS.reload()) {
 832       P.formatLine("Error loading module stream {0}.  {1}", I,
 833                    toString(std::move(EC)));
 834       continue;
 835     }
 836
 837     SymbolVisitorCallbackPipeline Pipeline;
 838     SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
 839     MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Types);
 840
 841     Pipeline.addCallbackToPipeline(Deserializer);
 842     Pipeline.addCallbackToPipeline(Dumper);
 843     CVSymbolVisitor Visitor(Pipeline);
 844     auto SS = ModS.getSymbolsSubstream();
 845     if (auto EC = Visitor.visitSymbolStream(ModS.getSymbolArray(), SS.Offset)) {
 846       P.formatLine("Error while processing symbol records.  {0}",
 847                    toString(std::move(EC)));
 848       continue;
 849     }
 850   }
 851   return Error::success();
 852 }
 853
 854 Error DumpOutputStyle::dumpPublics() {
 855   printHeader(P, "Public Symbols");
 856
 857   AutoIndent Indent(P);
 858   if (!File.hasPDBPublicsStream()) {
 859     P.formatLine("Publics stream not present");
 860     return Error::success();
 861   }
 862
 863   ExitOnError Err("Error dumping publics stream");
 864
 865   auto &Types = Err(initializeTypes(StreamTPI));
 866   auto &Publics = Err(File.getPDBPublicsStream());
 867   SymbolVisitorCallbackPipeline Pipeline;
 868   SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
 869   MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Types);
 870
 871   Pipeline.addCallbackToPipeline(Deserializer);
 872   Pipeline.addCallbackToPipeline(Dumper);
 873   CVSymbolVisitor Visitor(Pipeline);
 874
 875   auto ExpectedSymbols = Publics.getSymbolArray();
 876   if (!ExpectedSymbols) {
 877     P.formatLine("Could not read public symbol record stream");
 878     return Error::success();
 879   }
 880
 881   if (auto EC = Visitor.visitSymbolStream(*ExpectedSymbols, 0))
 882     P.formatLine("Error while processing public symbol records.  {0}",
 883                  toString(std::move(EC)));
 884
 885   return Error::success();
 886 }
 887
 888 static std::string formatSectionCharacteristics(uint32_t IndentLevel,
 889                                                 uint32_t C) {
 890   using SC = COFF::SectionCharacteristics;
 891   std::vector<std::string> Opts;
 892   if (C == COFF::SC_Invalid)
 893     return "invalid";
 894   if (C == 0)
 895     return "none";
 896
 897   PUSH_FLAG(SC, IMAGE_SCN_TYPE_NOLOAD, C, "IMAGE_SCN_TYPE_NOLOAD");
 898   PUSH_FLAG(SC, IMAGE_SCN_TYPE_NO_PAD, C, "IMAGE_SCN_TYPE_NO_PAD");
 899   PUSH_FLAG(SC, IMAGE_SCN_CNT_CODE, C, "IMAGE_SCN_CNT_CODE");
 900   PUSH_FLAG(SC, IMAGE_SCN_CNT_INITIALIZED_DATA, C,
 901             "IMAGE_SCN_CNT_INITIALIZED_DATA");
 902   PUSH_FLAG(SC, IMAGE_SCN_CNT_UNINITIALIZED_DATA, C,
 903             "IMAGE_SCN_CNT_UNINITIALIZED_DATA");
 904   PUSH_FLAG(SC, IMAGE_SCN_LNK_OTHER, C, "IMAGE_SCN_LNK_OTHER");
 905   PUSH_FLAG(SC, IMAGE_SCN_LNK_INFO, C, "IMAGE_SCN_LNK_INFO");
 906   PUSH_FLAG(SC, IMAGE_SCN_LNK_REMOVE, C, "IMAGE_SCN_LNK_REMOVE");
 907   PUSH_FLAG(SC, IMAGE_SCN_LNK_COMDAT, C, "IMAGE_SCN_LNK_COMDAT");
 908   PUSH_FLAG(SC, IMAGE_SCN_GPREL, C, "IMAGE_SCN_GPREL");
 909   PUSH_FLAG(SC, IMAGE_SCN_MEM_PURGEABLE, C, "IMAGE_SCN_MEM_PURGEABLE");
 910   PUSH_FLAG(SC, IMAGE_SCN_MEM_16BIT, C, "IMAGE_SCN_MEM_16BIT");
 911   PUSH_FLAG(SC, IMAGE_SCN_MEM_LOCKED, C, "IMAGE_SCN_MEM_LOCKED");
 912   PUSH_FLAG(SC, IMAGE_SCN_MEM_PRELOAD, C, "IMAGE_SCN_MEM_PRELOAD");
 913   PUSH_FLAG(SC, IMAGE_SCN_GPREL, C, "IMAGE_SCN_GPREL");
 914   PUSH_FLAG(SC, IMAGE_SCN_GPREL, C, "IMAGE_SCN_GPREL");
 915   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_1BYTES, C,
 916                    "IMAGE_SCN_ALIGN_1BYTES");
 917   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_2BYTES, C,
 918                    "IMAGE_SCN_ALIGN_2BYTES");
 919   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_4BYTES, C,
 920                    "IMAGE_SCN_ALIGN_4BYTES");
 921   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_8BYTES, C,
 922                    "IMAGE_SCN_ALIGN_8BYTES");
 923   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_16BYTES, C,
 924                    "IMAGE_SCN_ALIGN_16BYTES");
 925   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_32BYTES, C,
 926                    "IMAGE_SCN_ALIGN_32BYTES");
 927   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_64BYTES, C,
 928                    "IMAGE_SCN_ALIGN_64BYTES");
 929   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_128BYTES, C,
 930                    "IMAGE_SCN_ALIGN_128BYTES");
 931   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_256BYTES, C,
 932                    "IMAGE_SCN_ALIGN_256BYTES");
 933   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_512BYTES, C,
 934                    "IMAGE_SCN_ALIGN_512BYTES");
 935   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_1024BYTES, C,
 936                    "IMAGE_SCN_ALIGN_1024BYTES");
 937   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_2048BYTES, C,
 938                    "IMAGE_SCN_ALIGN_2048BYTES");
 939   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_4096BYTES, C,
 940                    "IMAGE_SCN_ALIGN_4096BYTES");
 941   PUSH_MASKED_FLAG(SC, 0xF00000, IMAGE_SCN_ALIGN_8192BYTES, C,
 942                    "IMAGE_SCN_ALIGN_8192BYTES");
 943   PUSH_FLAG(SC, IMAGE_SCN_LNK_NRELOC_OVFL, C, "IMAGE_SCN_LNK_NRELOC_OVFL");
 944   PUSH_FLAG(SC, IMAGE_SCN_MEM_DISCARDABLE, C, "IMAGE_SCN_MEM_DISCARDABLE");
 945   PUSH_FLAG(SC, IMAGE_SCN_MEM_NOT_CACHED, C, "IMAGE_SCN_MEM_NOT_CACHED");
 946   PUSH_FLAG(SC, IMAGE_SCN_MEM_NOT_PAGED, C, "IMAGE_SCN_MEM_NOT_PAGED");
 947   PUSH_FLAG(SC, IMAGE_SCN_MEM_SHARED, C, "IMAGE_SCN_MEM_SHARED");
 948   PUSH_FLAG(SC, IMAGE_SCN_MEM_EXECUTE, C, "IMAGE_SCN_MEM_EXECUTE");
 949   PUSH_FLAG(SC, IMAGE_SCN_MEM_READ, C, "IMAGE_SCN_MEM_READ");
 950   PUSH_FLAG(SC, IMAGE_SCN_MEM_WRITE, C, "IMAGE_SCN_MEM_WRITE");
 951   return typesetItemList(Opts, IndentLevel, 3, " | ");
 952 }
 953
 954 static std::string formatSegMapDescriptorFlag(uint32_t IndentLevel,
 955                                               OMFSegDescFlags Flags) {
 956   std::vector<std::string> Opts;
 957   if (Flags == OMFSegDescFlags::None)
 958     return "none";
 959
 960   PUSH_FLAG(OMFSegDescFlags, Read, Flags, "read");
 961   PUSH_FLAG(OMFSegDescFlags, Write, Flags, "write");
 962   PUSH_FLAG(OMFSegDescFlags, Execute, Flags, "execute");
 963   PUSH_FLAG(OMFSegDescFlags, AddressIs32Bit, Flags, "32 bit addr");
 964   PUSH_FLAG(OMFSegDescFlags, IsSelector, Flags, "selector");
 965   PUSH_FLAG(OMFSegDescFlags, IsAbsoluteAddress, Flags, "absolute addr");
 966   PUSH_FLAG(OMFSegDescFlags, IsGroup, Flags, "group");
 967   return typesetItemList(Opts, IndentLevel, 4, " | ");
 968 }
 969
 970 Error DumpOutputStyle::dumpSectionContribs() {
 971   printHeader(P, "Section Contributions");
 972   ExitOnError Err("Error dumping publics stream");
 973
 974   AutoIndent Indent(P);
 975   if (!File.hasPDBDbiStream()) {
 976     P.formatLine(
 977         "Section contribs require a DBI Stream, which could not be loaded");
 978     return Error::success();
 979   }
 980
 981   auto &Dbi = Err(File.getPDBDbiStream());
 982
 983   class Visitor : public ISectionContribVisitor {
 984   public:
 985     Visitor(LinePrinter &P) : P(P) {}
 986     void visit(const SectionContrib &SC) override {
 987       P.formatLine(
 988           "SC  | mod = {2}, {0}, size = {1}, data crc = {3}, reloc crc = {4}",
 989           formatSegmentOffset(SC.ISect, SC.Off), fmtle(SC.Size), fmtle(SC.Imod),
 990           fmtle(SC.DataCrc), fmtle(SC.RelocCrc));
 991       P.formatLine("      {0}",
 992                    formatSectionCharacteristics(P.getIndentLevel() + 6,
 993                                                 SC.Characteristics));
 994     }
 995     void visit(const SectionContrib2 &SC) override {
 996       P.formatLine("SC2 | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
 997                    "crc = {4}, coff section = {5}",
 998                    formatSegmentOffset(SC.Base.ISect, SC.Base.Off),
 999                    fmtle(SC.Base.Size), fmtle(SC.Base.Imod),
1000                    fmtle(SC.Base.DataCrc), fmtle(SC.Base.RelocCrc),
1001                    fmtle(SC.ISectCoff));
1002       P.formatLine("      {0}",
1003                    formatSectionCharacteristics(P.getIndentLevel() + 6,
1004                                                 SC.Base.Characteristics));
1005     }
1006
1007   private:
1008     LinePrinter &P;
1009   };
1010
1011   Visitor V(P);
1012   Dbi.visitSectionContributions(V);
1013   return Error::success();
1014 }
1015
1016 Error DumpOutputStyle::dumpSectionMap() {
1017   printHeader(P, "Section Map");
1018   ExitOnError Err("Error dumping section map");
1019
1020   AutoIndent Indent(P);
1021   if (!File.hasPDBDbiStream()) {
1022     P.formatLine("Dumping the section map requires a DBI Stream, which could "
1023                  "not be loaded");
1024     return Error::success();
1025   }
1026
1027   auto &Dbi = Err(File.getPDBDbiStream());
1028
1029   uint32_t I = 0;
1030   for (auto &M : Dbi.getSectionMap()) {
1031     P.formatLine(
1032         "Section {0:4} | ovl = {0}, group = {1}, frame = {2}, name = {3}", I,
1033         fmtle(M.Ovl), fmtle(M.Group), fmtle(M.Frame), fmtle(M.SecName));
1034     P.formatLine("               class = {0}, offset = {1}, size = {2}",
1035                  fmtle(M.ClassName), fmtle(M.Offset), fmtle(M.SecByteLength));
1036     P.formatLine("               flags = {0}",
1037                  formatSegMapDescriptorFlag(
1038                      P.getIndentLevel() + 13,
1039                      static_cast<OMFSegDescFlags>(uint16_t(M.Flags))));
1040     ++I;
1041   }
1042   return Error::success();
1043 }