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

   1 //===- MinimalSymbolDumper.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 "MinimalSymbolDumper.h"
  11
  12 #include "FormatUtil.h"
  13 #include "LinePrinter.h"
  14
  15 #include "llvm/DebugInfo/CodeView/CVRecord.h"
  16 #include "llvm/DebugInfo/CodeView/CodeView.h"
  17 #include "llvm/DebugInfo/CodeView/Formatters.h"
  18 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  19 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
  20 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
  21 #include "llvm/Support/FormatVariadic.h"
  22
  23 using namespace llvm;
  24 using namespace llvm::codeview;
  25 using namespace llvm::pdb;
  26
  27 static StringRef getSymbolKindName(SymbolKind K) {
  28   switch (K) {
  29 #define SYMBOL_RECORD(EnumName, value, name)                                   \
  30   case EnumName:                                                               \
  31     return #EnumName;
  32 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
  33   default:
  34     llvm_unreachable("Unknown symbol kind!");
  35   }
  36   return "";
  37 }
  38
  39 static std::string formatLocalSymFlags(uint32_t IndentLevel,
  40                                        LocalSymFlags Flags) {
  41   std::vector<std::string> Opts;
  42   if (Flags == LocalSymFlags::None)
  43     return "none";
  44
  45   PUSH_FLAG(LocalSymFlags, IsParameter, Flags, "param");
  46   PUSH_FLAG(LocalSymFlags, IsAddressTaken, Flags, "address is taken");
  47   PUSH_FLAG(LocalSymFlags, IsCompilerGenerated, Flags, "compiler generated");
  48   PUSH_FLAG(LocalSymFlags, IsAggregate, Flags, "aggregate");
  49   PUSH_FLAG(LocalSymFlags, IsAggregated, Flags, "aggregated");
  50   PUSH_FLAG(LocalSymFlags, IsAliased, Flags, "aliased");
  51   PUSH_FLAG(LocalSymFlags, IsAlias, Flags, "alias");
  52   PUSH_FLAG(LocalSymFlags, IsReturnValue, Flags, "return val");
  53   PUSH_FLAG(LocalSymFlags, IsOptimizedOut, Flags, "optimized away");
  54   PUSH_FLAG(LocalSymFlags, IsEnregisteredGlobal, Flags, "enreg global");
  55   PUSH_FLAG(LocalSymFlags, IsEnregisteredStatic, Flags, "enreg static");
  56   return typesetItemList(Opts, 4, IndentLevel, " | ");
  57 }
  58
  59 static std::string formatExportFlags(uint32_t IndentLevel, ExportFlags Flags) {
  60   std::vector<std::string> Opts;
  61   if (Flags == ExportFlags::None)
  62     return "none";
  63
  64   PUSH_FLAG(ExportFlags, IsConstant, Flags, "constant");
  65   PUSH_FLAG(ExportFlags, IsData, Flags, "data");
  66   PUSH_FLAG(ExportFlags, IsPrivate, Flags, "private");
  67   PUSH_FLAG(ExportFlags, HasNoName, Flags, "no name");
  68   PUSH_FLAG(ExportFlags, HasExplicitOrdinal, Flags, "explicit ord");
  69   PUSH_FLAG(ExportFlags, IsForwarder, Flags, "forwarder");
  70
  71   return typesetItemList(Opts, 4, IndentLevel, " | ");
  72 }
  73
  74 static std::string formatCompileSym2Flags(uint32_t IndentLevel,
  75                                           CompileSym2Flags Flags) {
  76   std::vector<std::string> Opts;
  77   Flags &= ~CompileSym2Flags::SourceLanguageMask;
  78   if (Flags == CompileSym2Flags::None)
  79     return "none";
  80
  81   PUSH_FLAG(CompileSym2Flags, EC, Flags, "edit and continue");
  82   PUSH_FLAG(CompileSym2Flags, NoDbgInfo, Flags, "no dbg info");
  83   PUSH_FLAG(CompileSym2Flags, LTCG, Flags, "ltcg");
  84   PUSH_FLAG(CompileSym2Flags, NoDataAlign, Flags, "no data align");
  85   PUSH_FLAG(CompileSym2Flags, ManagedPresent, Flags, "has managed code");
  86   PUSH_FLAG(CompileSym2Flags, SecurityChecks, Flags, "security checks");
  87   PUSH_FLAG(CompileSym2Flags, HotPatch, Flags, "hot patchable");
  88   PUSH_FLAG(CompileSym2Flags, CVTCIL, Flags, "cvtcil");
  89   PUSH_FLAG(CompileSym2Flags, MSILModule, Flags, "msil module");
  90   return typesetItemList(Opts, 4, IndentLevel, " | ");
  91 }
  92
  93 static std::string formatCompileSym3Flags(uint32_t IndentLevel,
  94                                           CompileSym3Flags Flags) {
  95   std::vector<std::string> Opts;
  96   Flags &= ~CompileSym3Flags::SourceLanguageMask;
  97
  98   if (Flags == CompileSym3Flags::None)
  99     return "none";
 100
 101   PUSH_FLAG(CompileSym3Flags, EC, Flags, "edit and continue");
 102   PUSH_FLAG(CompileSym3Flags, NoDbgInfo, Flags, "no dbg info");
 103   PUSH_FLAG(CompileSym3Flags, LTCG, Flags, "ltcg");
 104   PUSH_FLAG(CompileSym3Flags, NoDataAlign, Flags, "no data align");
 105   PUSH_FLAG(CompileSym3Flags, ManagedPresent, Flags, "has managed code");
 106   PUSH_FLAG(CompileSym3Flags, SecurityChecks, Flags, "security checks");
 107   PUSH_FLAG(CompileSym3Flags, HotPatch, Flags, "hot patchable");
 108   PUSH_FLAG(CompileSym3Flags, CVTCIL, Flags, "cvtcil");
 109   PUSH_FLAG(CompileSym3Flags, MSILModule, Flags, "msil module");
 110   PUSH_FLAG(CompileSym3Flags, Sdl, Flags, "sdl");
 111   PUSH_FLAG(CompileSym3Flags, PGO, Flags, "pgo");
 112   PUSH_FLAG(CompileSym3Flags, Exp, Flags, "exp");
 113   return typesetItemList(Opts, 4, IndentLevel, " | ");
 114 }
 115
 116 static std::string formatFrameProcedureOptions(uint32_t IndentLevel,
 117                                                FrameProcedureOptions FPO) {
 118   std::vector<std::string> Opts;
 119   if (FPO == FrameProcedureOptions::None)
 120     return "none";
 121
 122   PUSH_FLAG(FrameProcedureOptions, HasAlloca, FPO, "has alloca");
 123   PUSH_FLAG(FrameProcedureOptions, HasSetJmp, FPO, "has setjmp");
 124   PUSH_FLAG(FrameProcedureOptions, HasLongJmp, FPO, "has longjmp");
 125   PUSH_FLAG(FrameProcedureOptions, HasInlineAssembly, FPO, "has inline asm");
 126   PUSH_FLAG(FrameProcedureOptions, HasExceptionHandling, FPO, "has eh");
 127   PUSH_FLAG(FrameProcedureOptions, MarkedInline, FPO, "marked inline");
 128   PUSH_FLAG(FrameProcedureOptions, HasStructuredExceptionHandling, FPO,
 129             "has seh");
 130   PUSH_FLAG(FrameProcedureOptions, Naked, FPO, "naked");
 131   PUSH_FLAG(FrameProcedureOptions, SecurityChecks, FPO, "secure checks");
 132   PUSH_FLAG(FrameProcedureOptions, AsynchronousExceptionHandling, FPO,
 133             "has async eh");
 134   PUSH_FLAG(FrameProcedureOptions, NoStackOrderingForSecurityChecks, FPO,
 135             "no stack order");
 136   PUSH_FLAG(FrameProcedureOptions, Inlined, FPO, "inlined");
 137   PUSH_FLAG(FrameProcedureOptions, StrictSecurityChecks, FPO,
 138             "strict secure checks");
 139   PUSH_FLAG(FrameProcedureOptions, SafeBuffers, FPO, "safe buffers");
 140   PUSH_FLAG(FrameProcedureOptions, ProfileGuidedOptimization, FPO, "pgo");
 141   PUSH_FLAG(FrameProcedureOptions, ValidProfileCounts, FPO,
 142             "has profile counts");
 143   PUSH_FLAG(FrameProcedureOptions, OptimizedForSpeed, FPO, "opt speed");
 144   PUSH_FLAG(FrameProcedureOptions, GuardCfg, FPO, "guard cfg");
 145   PUSH_FLAG(FrameProcedureOptions, GuardCfw, FPO, "guard cfw");
 146   return typesetItemList(Opts, 4, IndentLevel, " | ");
 147 }
 148
 149 static std::string formatProcSymFlags(uint32_t IndentLevel,
 150                                       ProcSymFlags Flags) {
 151   std::vector<std::string> Opts;
 152   if (Flags == ProcSymFlags::None)
 153     return "none";
 154
 155   PUSH_FLAG(ProcSymFlags, HasFP, Flags, "has fp");
 156   PUSH_FLAG(ProcSymFlags, HasIRET, Flags, "has iret");
 157   PUSH_FLAG(ProcSymFlags, HasFRET, Flags, "has fret");
 158   PUSH_FLAG(ProcSymFlags, IsNoReturn, Flags, "noreturn");
 159   PUSH_FLAG(ProcSymFlags, IsUnreachable, Flags, "unreachable");
 160   PUSH_FLAG(ProcSymFlags, HasCustomCallingConv, Flags, "custom calling conv");
 161   PUSH_FLAG(ProcSymFlags, IsNoInline, Flags, "noinline");
 162   PUSH_FLAG(ProcSymFlags, HasOptimizedDebugInfo, Flags, "opt debuginfo");
 163   return typesetItemList(Opts, 4, IndentLevel, " | ");
 164 }
 165
 166 static std::string formatThunkOrdinal(ThunkOrdinal Ordinal) {
 167   switch (Ordinal) {
 168     RETURN_CASE(ThunkOrdinal, Standard, "thunk");
 169     RETURN_CASE(ThunkOrdinal, ThisAdjustor, "this adjustor");
 170     RETURN_CASE(ThunkOrdinal, Vcall, "vcall");
 171     RETURN_CASE(ThunkOrdinal, Pcode, "pcode");
 172     RETURN_CASE(ThunkOrdinal, UnknownLoad, "unknown load");
 173     RETURN_CASE(ThunkOrdinal, TrampIncremental, "tramp incremental");
 174     RETURN_CASE(ThunkOrdinal, BranchIsland, "branch island");
 175   }
 176   return formatUnknownEnum(Ordinal);
 177 }
 178
 179 static std::string formatTrampolineType(TrampolineType Tramp) {
 180   switch (Tramp) {
 181     RETURN_CASE(TrampolineType, TrampIncremental, "tramp incremental");
 182     RETURN_CASE(TrampolineType, BranchIsland, "branch island");
 183   }
 184   return formatUnknownEnum(Tramp);
 185 }
 186
 187 static std::string formatSourceLanguage(SourceLanguage Lang) {
 188   switch (Lang) {
 189     RETURN_CASE(SourceLanguage, C, "c");
 190     RETURN_CASE(SourceLanguage, Cpp, "c++");
 191     RETURN_CASE(SourceLanguage, Fortran, "fortran");
 192     RETURN_CASE(SourceLanguage, Masm, "masm");
 193     RETURN_CASE(SourceLanguage, Pascal, "pascal");
 194     RETURN_CASE(SourceLanguage, Basic, "basic");
 195     RETURN_CASE(SourceLanguage, Cobol, "cobol");
 196     RETURN_CASE(SourceLanguage, Link, "link");
 197     RETURN_CASE(SourceLanguage, VB, "vb");
 198     RETURN_CASE(SourceLanguage, Cvtres, "cvtres");
 199     RETURN_CASE(SourceLanguage, Cvtpgd, "cvtpgd");
 200     RETURN_CASE(SourceLanguage, CSharp, "c#");
 201     RETURN_CASE(SourceLanguage, ILAsm, "il asm");
 202     RETURN_CASE(SourceLanguage, Java, "java");
 203     RETURN_CASE(SourceLanguage, JScript, "javascript");
 204     RETURN_CASE(SourceLanguage, MSIL, "msil");
 205     RETURN_CASE(SourceLanguage, HLSL, "hlsl");
 206   }
 207   return formatUnknownEnum(Lang);
 208 }
 209
 210 static std::string formatMachineType(CPUType Cpu) {
 211   switch (Cpu) {
 212     RETURN_CASE(CPUType, Intel8080, "intel 8080");
 213     RETURN_CASE(CPUType, Intel8086, "intel 8086");
 214     RETURN_CASE(CPUType, Intel80286, "intel 80286");
 215     RETURN_CASE(CPUType, Intel80386, "intel 80386");
 216     RETURN_CASE(CPUType, Intel80486, "intel 80486");
 217     RETURN_CASE(CPUType, Pentium, "intel pentium");
 218     RETURN_CASE(CPUType, PentiumPro, "intel pentium pro");
 219     RETURN_CASE(CPUType, Pentium3, "intel pentium 3");
 220     RETURN_CASE(CPUType, MIPS, "mips");
 221     RETURN_CASE(CPUType, MIPS16, "mips-16");
 222     RETURN_CASE(CPUType, MIPS32, "mips-32");
 223     RETURN_CASE(CPUType, MIPS64, "mips-64");
 224     RETURN_CASE(CPUType, MIPSI, "mips i");
 225     RETURN_CASE(CPUType, MIPSII, "mips ii");
 226     RETURN_CASE(CPUType, MIPSIII, "mips iii");
 227     RETURN_CASE(CPUType, MIPSIV, "mips iv");
 228     RETURN_CASE(CPUType, MIPSV, "mips v");
 229     RETURN_CASE(CPUType, M68000, "motorola 68000");
 230     RETURN_CASE(CPUType, M68010, "motorola 68010");
 231     RETURN_CASE(CPUType, M68020, "motorola 68020");
 232     RETURN_CASE(CPUType, M68030, "motorola 68030");
 233     RETURN_CASE(CPUType, M68040, "motorola 68040");
 234     RETURN_CASE(CPUType, Alpha, "alpha");
 235     RETURN_CASE(CPUType, Alpha21164, "alpha 21164");
 236     RETURN_CASE(CPUType, Alpha21164A, "alpha 21164a");
 237     RETURN_CASE(CPUType, Alpha21264, "alpha 21264");
 238     RETURN_CASE(CPUType, Alpha21364, "alpha 21364");
 239     RETURN_CASE(CPUType, PPC601, "powerpc 601");
 240     RETURN_CASE(CPUType, PPC603, "powerpc 603");
 241     RETURN_CASE(CPUType, PPC604, "powerpc 604");
 242     RETURN_CASE(CPUType, PPC620, "powerpc 620");
 243     RETURN_CASE(CPUType, PPCFP, "powerpc fp");
 244     RETURN_CASE(CPUType, PPCBE, "powerpc be");
 245     RETURN_CASE(CPUType, SH3, "sh3");
 246     RETURN_CASE(CPUType, SH3E, "sh3e");
 247     RETURN_CASE(CPUType, SH3DSP, "sh3 dsp");
 248     RETURN_CASE(CPUType, SH4, "sh4");
 249     RETURN_CASE(CPUType, SHMedia, "shmedia");
 250     RETURN_CASE(CPUType, ARM3, "arm 3");
 251     RETURN_CASE(CPUType, ARM4, "arm 4");
 252     RETURN_CASE(CPUType, ARM4T, "arm 4t");
 253     RETURN_CASE(CPUType, ARM5, "arm 5");
 254     RETURN_CASE(CPUType, ARM5T, "arm 5t");
 255     RETURN_CASE(CPUType, ARM6, "arm 6");
 256     RETURN_CASE(CPUType, ARM_XMAC, "arm xmac");
 257     RETURN_CASE(CPUType, ARM_WMMX, "arm wmmx");
 258     RETURN_CASE(CPUType, ARM7, "arm 7");
 259     RETURN_CASE(CPUType, Omni, "omni");
 260     RETURN_CASE(CPUType, Ia64, "intel itanium ia64");
 261     RETURN_CASE(CPUType, Ia64_2, "intel itanium ia64 2");
 262     RETURN_CASE(CPUType, CEE, "cee");
 263     RETURN_CASE(CPUType, AM33, "am33");
 264     RETURN_CASE(CPUType, M32R, "m32r");
 265     RETURN_CASE(CPUType, TriCore, "tri-core");
 266     RETURN_CASE(CPUType, X64, "intel x86-x64");
 267     RETURN_CASE(CPUType, EBC, "ebc");
 268     RETURN_CASE(CPUType, Thumb, "thumb");
 269     RETURN_CASE(CPUType, ARMNT, "arm nt");
 270     RETURN_CASE(CPUType, D3D11_Shader, "d3d11 shader");
 271   }
 272   return formatUnknownEnum(Cpu);
 273 }
 274
 275 static std::string formatCookieKind(FrameCookieKind Kind) {
 276   switch (Kind) {
 277     RETURN_CASE(FrameCookieKind, Copy, "copy");
 278     RETURN_CASE(FrameCookieKind, XorStackPointer, "xor stack ptr");
 279     RETURN_CASE(FrameCookieKind, XorFramePointer, "xor frame ptr");
 280     RETURN_CASE(FrameCookieKind, XorR13, "xor rot13");
 281   }
 282   return formatUnknownEnum(Kind);
 283 }
 284
 285 static std::string formatRegisterId(RegisterId Id) {
 286   switch (Id) {
 287     RETURN_CASE(RegisterId, VFrame, "vframe");
 288     RETURN_CASE(RegisterId, AL, "al");
 289     RETURN_CASE(RegisterId, CL, "cl");
 290     RETURN_CASE(RegisterId, DL, "dl");
 291     RETURN_CASE(RegisterId, BL, "bl");
 292     RETURN_CASE(RegisterId, AH, "ah");
 293     RETURN_CASE(RegisterId, CH, "ch");
 294     RETURN_CASE(RegisterId, DH, "dh");
 295     RETURN_CASE(RegisterId, BH, "bh");
 296     RETURN_CASE(RegisterId, AX, "ax");
 297     RETURN_CASE(RegisterId, CX, "cx");
 298     RETURN_CASE(RegisterId, DX, "dx");
 299     RETURN_CASE(RegisterId, BX, "bx");
 300     RETURN_CASE(RegisterId, SP, "sp");
 301     RETURN_CASE(RegisterId, BP, "bp");
 302     RETURN_CASE(RegisterId, SI, "si");
 303     RETURN_CASE(RegisterId, DI, "di");
 304     RETURN_CASE(RegisterId, EAX, "eax");
 305     RETURN_CASE(RegisterId, ECX, "ecx");
 306     RETURN_CASE(RegisterId, EDX, "edx");
 307     RETURN_CASE(RegisterId, EBX, "ebx");
 308     RETURN_CASE(RegisterId, ESP, "esp");
 309     RETURN_CASE(RegisterId, EBP, "ebp");
 310     RETURN_CASE(RegisterId, ESI, "esi");
 311     RETURN_CASE(RegisterId, EDI, "edi");
 312     RETURN_CASE(RegisterId, ES, "es");
 313     RETURN_CASE(RegisterId, CS, "cs");
 314     RETURN_CASE(RegisterId, SS, "ss");
 315     RETURN_CASE(RegisterId, DS, "ds");
 316     RETURN_CASE(RegisterId, FS, "fs");
 317     RETURN_CASE(RegisterId, GS, "gs");
 318     RETURN_CASE(RegisterId, IP, "ip");
 319     RETURN_CASE(RegisterId, RAX, "rax");
 320     RETURN_CASE(RegisterId, RBX, "rbx");
 321     RETURN_CASE(RegisterId, RCX, "rcx");
 322     RETURN_CASE(RegisterId, RDX, "rdx");
 323     RETURN_CASE(RegisterId, RSI, "rsi");
 324     RETURN_CASE(RegisterId, RDI, "rdi");
 325     RETURN_CASE(RegisterId, RBP, "rbp");
 326     RETURN_CASE(RegisterId, RSP, "rsp");
 327     RETURN_CASE(RegisterId, R8, "r8");
 328     RETURN_CASE(RegisterId, R9, "r9");
 329     RETURN_CASE(RegisterId, R10, "r10");
 330     RETURN_CASE(RegisterId, R11, "r11");
 331     RETURN_CASE(RegisterId, R12, "r12");
 332     RETURN_CASE(RegisterId, R13, "r13");
 333     RETURN_CASE(RegisterId, R14, "r14");
 334     RETURN_CASE(RegisterId, R15, "r15");
 335   default:
 336     return formatUnknownEnum(Id);
 337   }
 338 }
 339
 340 static std::string formatRange(LocalVariableAddrRange Range) {
 341   return formatv("[{0},+{1})",
 342                  formatSegmentOffset(Range.ISectStart, Range.OffsetStart),
 343                  Range.Range)
 344       .str();
 345 }
 346
 347 static std::string formatGaps(uint32_t IndentLevel,
 348                               ArrayRef<LocalVariableAddrGap> Gaps) {
 349   std::vector<std::string> GapStrs;
 350   for (const auto &G : Gaps) {
 351     GapStrs.push_back(formatv("({0},{1})", G.GapStartOffset, G.Range).str());
 352   }
 353   return typesetItemList(GapStrs, 7, IndentLevel, ", ");
 354 }
 355
 356 Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record) {
 357   // formatLine puts the newline at the beginning, so we use formatLine here
 358   // to start a new line, and then individual visit methods use format to
 359   // append to the existing line.
 360   P.formatLine("- {0} [size = {1}]", getSymbolKindName(Record.Type),
 361                Record.length());
 362   P.Indent();
 363   return Error::success();
 364 }
 365
 366 Error MinimalSymbolDumper::visitSymbolEnd(CVSymbol &Record) {
 367   P.Unindent();
 368   return Error::success();
 369 }
 370
 371 std::string MinimalSymbolDumper::typeIndex(TypeIndex TI) const {
 372   if (TI.isSimple())
 373     return formatv("{0}", TI).str();
 374   StringRef Name = Types.getTypeName(TI);
 375   if (Name.size() > 32) {
 376     Name = Name.take_front(32);
 377     return formatv("{0} ({1}...)", TI, Name);
 378   } else
 379     return formatv("{0} ({1})", TI, Name);
 380 }
 381
 382 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, BlockSym &Block) {
 383   P.format(" `{0}`", Block.Name);
 384   AutoIndent Indent(P);
 385   P.formatLine("parent = {0}, addr = {1}", Block.Parent,
 386                formatSegmentOffset(Block.Segment, Block.CodeOffset));
 387   P.formatLine("code size = {0}, end = {1}", Block.CodeSize, Block.End);
 388   return Error::success();
 389 }
 390
 391 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, Thunk32Sym &Thunk) {
 392   P.format(" `{0}`", Thunk.Name);
 393   AutoIndent Indent(P);
 394   P.formatLine("parent = {0}, addr = {1}", Thunk.Parent,
 395                formatSegmentOffset(Thunk.Segment, Thunk.Offset));
 396   P.formatLine("kind = {0}, size = {1}, end = {2}, next = {3}",
 397                formatThunkOrdinal(Thunk.Thunk), Thunk.Length, Thunk.End,
 398                Thunk.Next);
 399
 400   return Error::success();
 401 }
 402
 403 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 404                                             TrampolineSym &Tramp) {
 405   AutoIndent Indent(P);
 406   P.formatLine("type = {0}, size = {1}, source = {2}, target = {3}",
 407                formatTrampolineType(Tramp.Type), Tramp.Size,
 408                formatSegmentOffset(Tramp.ThunkSection, Tramp.ThunkOffset),
 409                formatSegmentOffset(Tramp.TargetSection, Tramp.ThunkOffset));
 410
 411   return Error::success();
 412 }
 413
 414 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 415                                             SectionSym &Section) {
 416   P.format(" `{0}`", Section.Name);
 417   AutoIndent Indent(P);
 418   P.formatLine("length = {0}, alignment = {1}, rva = {2}, section # = {3}, "
 419                "characteristics = {4}",
 420                Section.Length, Section.Alignment, Section.Rva,
 421                Section.SectionNumber, Section.Characteristics);
 422   return Error::success();
 423 }
 424
 425 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CoffGroupSym &CG) {
 426   P.format(" `{0}`", CG.Name);
 427   AutoIndent Indent(P);
 428   P.formatLine("length = {0}, addr = {1}, characteristics = {2}", CG.Size,
 429                formatSegmentOffset(CG.Segment, CG.Offset), CG.Characteristics);
 430   return Error::success();
 431 }
 432
 433 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 434                                             BPRelativeSym &BPRel) {
 435   P.format(" `{0}`", BPRel.Name);
 436   AutoIndent Indent(P);
 437   P.formatLine("type = {0}, offset = {1}", typeIndex(BPRel.Type), BPRel.Offset);
 438   return Error::success();
 439 }
 440
 441 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 442                                             BuildInfoSym &BuildInfo) {
 443   P.format(" BuildId = `{0}`", BuildInfo.BuildId);
 444   return Error::success();
 445 }
 446
 447 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 448                                             CallSiteInfoSym &CSI) {
 449   AutoIndent Indent(P);
 450   P.formatLine("type = {0}, addr = {1}", typeIndex(CSI.Type),
 451                formatSegmentOffset(CSI.Segment, CSI.CodeOffset));
 452   return Error::success();
 453 }
 454
 455 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 456                                             EnvBlockSym &EnvBlock) {
 457   for (const auto &Entry : EnvBlock.Fields) {
 458     P.formatLine("- {0}", Entry);
 459   }
 460   return Error::success();
 461 }
 462
 463 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FileStaticSym &FS) {
 464   P.format(" `{0}`", FS.Name);
 465   AutoIndent Indent(P);
 466   P.formatLine("type = {0}, file name offset = {1}, flags = {2}",
 467                typeIndex(FS.Index), FS.ModFilenameOffset,
 468                formatLocalSymFlags(P.getIndentLevel() + 9, FS.Flags));
 469   return Error::success();
 470 }
 471
 472 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
 473   P.format(" `{0}`", Export.Name);
 474   AutoIndent Indent(P);
 475   P.formatLine("ordinal = {0}, flags = {1}", Export.Ordinal,
 476                formatExportFlags(P.getIndentLevel() + 9, Export.Flags));
 477   return Error::success();
 478 }
 479
 480 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 481                                             Compile2Sym &Compile2) {
 482   AutoIndent Indent(P);
 483   SourceLanguage Lang = static_cast<SourceLanguage>(
 484       Compile2.Flags & CompileSym2Flags::SourceLanguageMask);
 485   P.formatLine("machine = {0}, ver = {1}, language = {2}",
 486                formatMachineType(Compile2.Machine), Compile2.Version,
 487                formatSourceLanguage(Lang));
 488   P.formatLine("frontend = {0}.{1}.{2}, backend = {3}.{4}.{5}",
 489                Compile2.VersionFrontendMajor, Compile2.VersionFrontendMinor,
 490                Compile2.VersionFrontendBuild, Compile2.VersionBackendMajor,
 491                Compile2.VersionBackendMinor, Compile2.VersionBackendBuild);
 492   P.formatLine("flags = {0}",
 493                formatCompileSym2Flags(P.getIndentLevel() + 9, Compile2.Flags));
 494   P.formatLine(
 495       "extra strings = {0}",
 496       typesetStringList(P.getIndentLevel() + 9 + 2, Compile2.ExtraStrings));
 497   return Error::success();
 498 }
 499
 500 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 501                                             Compile3Sym &Compile3) {
 502   AutoIndent Indent(P);
 503   SourceLanguage Lang = static_cast<SourceLanguage>(
 504       Compile3.Flags & CompileSym3Flags::SourceLanguageMask);
 505   P.formatLine("machine = {0}, Ver = {1}, language = {2}",
 506                formatMachineType(Compile3.Machine), Compile3.Version,
 507                formatSourceLanguage(Lang));
 508   P.formatLine("frontend = {0}.{1}.{2}.{3}, backend = {4}.{5}.{6}.{7}",
 509                Compile3.VersionFrontendMajor, Compile3.VersionFrontendMinor,
 510                Compile3.VersionFrontendBuild, Compile3.VersionFrontendQFE,
 511                Compile3.VersionBackendMajor, Compile3.VersionBackendMinor,
 512                Compile3.VersionBackendBuild, Compile3.VersionBackendQFE);
 513   P.formatLine("flags = {0}",
 514                formatCompileSym3Flags(P.getIndentLevel() + 9, Compile3.Flags));
 515   return Error::success();
 516 }
 517
 518 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 519                                             ConstantSym &Constant) {
 520   P.format(" `{0}`", Constant.Name);
 521   AutoIndent Indent(P);
 522   P.formatLine("type = {0}, value = {1}", typeIndex(Constant.Type),
 523                Constant.Value.toString(10));
 524   return Error::success();
 525 }
 526
 527 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
 528   P.format(" `{0}`", Data.Name);
 529   AutoIndent Indent(P);
 530   P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
 531                formatSegmentOffset(Data.Segment, Data.DataOffset));
 532   return Error::success();
 533 }
 534
 535 Error MinimalSymbolDumper::visitKnownRecord(
 536     CVSymbol &CVR, DefRangeFramePointerRelFullScopeSym &Def) {
 537   P.format(" offset = {0}", Def.Offset);
 538   return Error::success();
 539 }
 540
 541 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 542                                             DefRangeFramePointerRelSym &Def) {
 543   AutoIndent Indent(P);
 544   P.formatLine("offset = {0}, range = {1}", Def.Offset, formatRange(Def.Range));
 545   P.formatLine("gaps = {2}", Def.Offset,
 546                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 547   return Error::success();
 548 }
 549
 550 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 551                                             DefRangeRegisterRelSym &Def) {
 552   AutoIndent Indent(P);
 553   P.formatLine("register = {0}, base ptr = {1}, offset in parent = {2}, has "
 554                "spilled udt = {3}",
 555                uint16_t(Def.Hdr.Register), int32_t(Def.Hdr.BasePointerOffset),
 556                Def.offsetInParent(), Def.hasSpilledUDTMember());
 557   P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
 558                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 559   return Error::success();
 560 }
 561
 562 Error MinimalSymbolDumper::visitKnownRecord(
 563     CVSymbol &CVR, DefRangeRegisterSym &DefRangeRegister) {
 564   AutoIndent Indent(P);
 565   P.formatLine("register = {0}, may have no name = {1}, range start = "
 566                "{2}, length = {3}",
 567                uint16_t(DefRangeRegister.Hdr.Register),
 568                uint16_t(DefRangeRegister.Hdr.MayHaveNoName),
 569                formatSegmentOffset(DefRangeRegister.Range.ISectStart,
 570                                    DefRangeRegister.Range.OffsetStart),
 571                DefRangeRegister.Range.Range);
 572   P.formatLine("gaps = [{0}]",
 573                formatGaps(P.getIndentLevel() + 9, DefRangeRegister.Gaps));
 574   return Error::success();
 575 }
 576
 577 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 578                                             DefRangeSubfieldRegisterSym &Def) {
 579   AutoIndent Indent(P);
 580   bool NoName = !!(Def.Hdr.MayHaveNoName == 0);
 581   P.formatLine("register = {0}, may have no name = {1}, offset in parent = {2}",
 582                uint16_t(Def.Hdr.Register), NoName,
 583                uint32_t(Def.Hdr.OffsetInParent));
 584   P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
 585                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 586   return Error::success();
 587 }
 588
 589 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 590                                             DefRangeSubfieldSym &Def) {
 591   AutoIndent Indent(P);
 592   P.formatLine("program = {0}, offset in parent = {1}, range = {2}",
 593                Def.Program, Def.OffsetInParent, formatRange(Def.Range));
 594   P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 595   return Error::success();
 596 }
 597
 598 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DefRangeSym &Def) {
 599   AutoIndent Indent(P);
 600   P.formatLine("program = {0}, range = {1}", Def.Program,
 601                formatRange(Def.Range));
 602   P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 603   return Error::success();
 604 }
 605
 606 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameCookieSym &FC) {
 607   AutoIndent Indent(P);
 608   P.formatLine("code offset = {0}, Register = {1}, kind = {2}, flags = {3}",
 609                FC.CodeOffset, FC.Register, formatCookieKind(FC.CookieKind),
 610                FC.Flags);
 611   return Error::success();
 612 }
 613
 614 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameProcSym &FP) {
 615   AutoIndent Indent(P);
 616   P.formatLine("size = {0}, padding size = {1}, offset to padding = {2}",
 617                FP.TotalFrameBytes, FP.PaddingFrameBytes, FP.OffsetToPadding);
 618   P.formatLine("bytes of callee saved registers = {0}, exception handler addr "
 619                "= {1}",
 620                FP.BytesOfCalleeSavedRegisters,
 621                formatSegmentOffset(FP.SectionIdOfExceptionHandler,
 622                                    FP.OffsetOfExceptionHandler));
 623   P.formatLine("flags = {0}",
 624                formatFrameProcedureOptions(P.getIndentLevel() + 9, FP.Flags));
 625   return Error::success();
 626 }
 627
 628 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 629                                             HeapAllocationSiteSym &HAS) {
 630   AutoIndent Indent(P);
 631   P.formatLine("type = {0}, addr = {1} call size = {2}", typeIndex(HAS.Type),
 632                formatSegmentOffset(HAS.Segment, HAS.CodeOffset),
 633                HAS.CallInstructionSize);
 634   return Error::success();
 635 }
 636
 637 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, InlineSiteSym &IS) {
 638   AutoIndent Indent(P);
 639   auto Bytes = makeArrayRef(IS.AnnotationData);
 640   StringRef Annotations(reinterpret_cast<const char *>(Bytes.begin()),
 641                         Bytes.size());
 642
 643   P.formatLine("inlinee = {0}, parent = {1}, end = {2}", typeIndex(IS.Inlinee),
 644                IS.Parent, IS.End);
 645   P.formatLine("annotations = {0}", toHex(Annotations));
 646   return Error::success();
 647 }
 648
 649 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 650                                             RegisterSym &Register) {
 651   P.format(" `{0}`", Register.Name);
 652   AutoIndent Indent(P);
 653   P.formatLine("register = {0}, type = {1}",
 654                formatRegisterId(Register.Register), typeIndex(Register.Index));
 655   return Error::success();
 656 }
 657
 658 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 659                                             PublicSym32 &Public) {
 660   P.format(" `{0}`", Public.Name);
 661   AutoIndent Indent(P);
 662   P.formatLine("type = {0}, addr = {1}", typeIndex(Public.Index),
 663                formatSegmentOffset(Public.Segment, Public.Offset));
 664   return Error::success();
 665 }
 666
 667 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcRefSym &PR) {
 668   P.format(" `{0}`", PR.Name);
 669   AutoIndent Indent(P);
 670   P.formatLine("module = {0}, sum name = {1}, offset = {2}", PR.Module,
 671                PR.SumName, PR.SymOffset);
 672   return Error::success();
 673 }
 674
 675 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LabelSym &Label) {
 676   P.format(" `{0}` (addr = {1})", Label.Name,
 677            formatSegmentOffset(Label.Segment, Label.CodeOffset));
 678   AutoIndent Indent(P);
 679   P.formatLine("flags = {0}",
 680                formatProcSymFlags(P.getIndentLevel() + 9, Label.Flags));
 681   return Error::success();
 682 }
 683
 684 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LocalSym &Local) {
 685   P.format(" `{0}`", Local.Name);
 686   AutoIndent Indent(P);
 687
 688   std::string FlagStr =
 689       formatLocalSymFlags(P.getIndentLevel() + 9, Local.Flags);
 690   P.formatLine("type={0}, flags = {1}", typeIndex(Local.Type), FlagStr);
 691   return Error::success();
 692 }
 693
 694 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 695                                             ObjNameSym &ObjName) {
 696   P.format(" sig={0}, `{1}`", ObjName.Signature, ObjName.Name);
 697   return Error::success();
 698 }
 699
 700 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcSym &Proc) {
 701   P.format(" `{0}`", Proc.Name);
 702   AutoIndent Indent(P);
 703   P.formatLine("parent = {0}, addr = {1}, code size = {2}, end = {3}",
 704                Proc.Parent, formatSegmentOffset(Proc.Segment, Proc.CodeOffset),
 705                Proc.CodeSize, Proc.End);
 706   P.formatLine("debug start = {0}, debug end = {1}, flags = {2}", Proc.DbgStart,
 707                Proc.DbgEnd,
 708                formatProcSymFlags(P.getIndentLevel() + 9, Proc.Flags));
 709   return Error::success();
 710 }
 711
 712 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 713                                             ScopeEndSym &ScopeEnd) {
 714   return Error::success();
 715 }
 716
 717 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CallerSym &Caller) {
 718   AutoIndent Indent(P);
 719   for (const auto &I : Caller.Indices) {
 720     P.formatLine("callee: {0}", typeIndex(I));
 721   }
 722   return Error::success();
 723 }
 724
 725 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 726                                             RegRelativeSym &RegRel) {
 727   P.format(" `{0}`", RegRel.Name);
 728   AutoIndent Indent(P);
 729   P.formatLine("type = {0}, register = {1}, offset = {2}",
 730                typeIndex(RegRel.Type), formatRegisterId(RegRel.Register),
 731                RegRel.Offset);
 732   return Error::success();
 733 }
 734
 735 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 736                                             ThreadLocalDataSym &Data) {
 737   P.format(" `{0}`", Data.Name);
 738   AutoIndent Indent(P);
 739   P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
 740                formatSegmentOffset(Data.Segment, Data.DataOffset));
 741   return Error::success();
 742 }
 743
 744 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, UDTSym &UDT) {
 745   P.format(" `{0}`", UDT.Name);
 746   AutoIndent Indent(P);
 747   P.formatLine("original type = {0}", UDT.Type);
 748   return Error::success();
 749 }