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 formatPublicSymFlags(uint32_t IndentLevel,
 150                                         PublicSymFlags Flags) {
 151   std::vector<std::string> Opts;
 152   if (Flags == PublicSymFlags::None)
 153     return "none";
 154
 155   PUSH_FLAG(PublicSymFlags, Code, Flags, "code");
 156   PUSH_FLAG(PublicSymFlags, Function, Flags, "function");
 157   PUSH_FLAG(PublicSymFlags, Managed, Flags, "managed");
 158   PUSH_FLAG(PublicSymFlags, MSIL, Flags, "msil");
 159   return typesetItemList(Opts, 4, IndentLevel, " | ");
 160 }
 161
 162 static std::string formatProcSymFlags(uint32_t IndentLevel,
 163                                       ProcSymFlags Flags) {
 164   std::vector<std::string> Opts;
 165   if (Flags == ProcSymFlags::None)
 166     return "none";
 167
 168   PUSH_FLAG(ProcSymFlags, HasFP, Flags, "has fp");
 169   PUSH_FLAG(ProcSymFlags, HasIRET, Flags, "has iret");
 170   PUSH_FLAG(ProcSymFlags, HasFRET, Flags, "has fret");
 171   PUSH_FLAG(ProcSymFlags, IsNoReturn, Flags, "noreturn");
 172   PUSH_FLAG(ProcSymFlags, IsUnreachable, Flags, "unreachable");
 173   PUSH_FLAG(ProcSymFlags, HasCustomCallingConv, Flags, "custom calling conv");
 174   PUSH_FLAG(ProcSymFlags, IsNoInline, Flags, "noinline");
 175   PUSH_FLAG(ProcSymFlags, HasOptimizedDebugInfo, Flags, "opt debuginfo");
 176   return typesetItemList(Opts, 4, IndentLevel, " | ");
 177 }
 178
 179 static std::string formatThunkOrdinal(ThunkOrdinal Ordinal) {
 180   switch (Ordinal) {
 181     RETURN_CASE(ThunkOrdinal, Standard, "thunk");
 182     RETURN_CASE(ThunkOrdinal, ThisAdjustor, "this adjustor");
 183     RETURN_CASE(ThunkOrdinal, Vcall, "vcall");
 184     RETURN_CASE(ThunkOrdinal, Pcode, "pcode");
 185     RETURN_CASE(ThunkOrdinal, UnknownLoad, "unknown load");
 186     RETURN_CASE(ThunkOrdinal, TrampIncremental, "tramp incremental");
 187     RETURN_CASE(ThunkOrdinal, BranchIsland, "branch island");
 188   }
 189   return formatUnknownEnum(Ordinal);
 190 }
 191
 192 static std::string formatTrampolineType(TrampolineType Tramp) {
 193   switch (Tramp) {
 194     RETURN_CASE(TrampolineType, TrampIncremental, "tramp incremental");
 195     RETURN_CASE(TrampolineType, BranchIsland, "branch island");
 196   }
 197   return formatUnknownEnum(Tramp);
 198 }
 199
 200 static std::string formatSourceLanguage(SourceLanguage Lang) {
 201   switch (Lang) {
 202     RETURN_CASE(SourceLanguage, C, "c");
 203     RETURN_CASE(SourceLanguage, Cpp, "c++");
 204     RETURN_CASE(SourceLanguage, Fortran, "fortran");
 205     RETURN_CASE(SourceLanguage, Masm, "masm");
 206     RETURN_CASE(SourceLanguage, Pascal, "pascal");
 207     RETURN_CASE(SourceLanguage, Basic, "basic");
 208     RETURN_CASE(SourceLanguage, Cobol, "cobol");
 209     RETURN_CASE(SourceLanguage, Link, "link");
 210     RETURN_CASE(SourceLanguage, VB, "vb");
 211     RETURN_CASE(SourceLanguage, Cvtres, "cvtres");
 212     RETURN_CASE(SourceLanguage, Cvtpgd, "cvtpgd");
 213     RETURN_CASE(SourceLanguage, CSharp, "c#");
 214     RETURN_CASE(SourceLanguage, ILAsm, "il asm");
 215     RETURN_CASE(SourceLanguage, Java, "java");
 216     RETURN_CASE(SourceLanguage, JScript, "javascript");
 217     RETURN_CASE(SourceLanguage, MSIL, "msil");
 218     RETURN_CASE(SourceLanguage, HLSL, "hlsl");
 219   }
 220   return formatUnknownEnum(Lang);
 221 }
 222
 223 static std::string formatMachineType(CPUType Cpu) {
 224   switch (Cpu) {
 225     RETURN_CASE(CPUType, Intel8080, "intel 8080");
 226     RETURN_CASE(CPUType, Intel8086, "intel 8086");
 227     RETURN_CASE(CPUType, Intel80286, "intel 80286");
 228     RETURN_CASE(CPUType, Intel80386, "intel 80386");
 229     RETURN_CASE(CPUType, Intel80486, "intel 80486");
 230     RETURN_CASE(CPUType, Pentium, "intel pentium");
 231     RETURN_CASE(CPUType, PentiumPro, "intel pentium pro");
 232     RETURN_CASE(CPUType, Pentium3, "intel pentium 3");
 233     RETURN_CASE(CPUType, MIPS, "mips");
 234     RETURN_CASE(CPUType, MIPS16, "mips-16");
 235     RETURN_CASE(CPUType, MIPS32, "mips-32");
 236     RETURN_CASE(CPUType, MIPS64, "mips-64");
 237     RETURN_CASE(CPUType, MIPSI, "mips i");
 238     RETURN_CASE(CPUType, MIPSII, "mips ii");
 239     RETURN_CASE(CPUType, MIPSIII, "mips iii");
 240     RETURN_CASE(CPUType, MIPSIV, "mips iv");
 241     RETURN_CASE(CPUType, MIPSV, "mips v");
 242     RETURN_CASE(CPUType, M68000, "motorola 68000");
 243     RETURN_CASE(CPUType, M68010, "motorola 68010");
 244     RETURN_CASE(CPUType, M68020, "motorola 68020");
 245     RETURN_CASE(CPUType, M68030, "motorola 68030");
 246     RETURN_CASE(CPUType, M68040, "motorola 68040");
 247     RETURN_CASE(CPUType, Alpha, "alpha");
 248     RETURN_CASE(CPUType, Alpha21164, "alpha 21164");
 249     RETURN_CASE(CPUType, Alpha21164A, "alpha 21164a");
 250     RETURN_CASE(CPUType, Alpha21264, "alpha 21264");
 251     RETURN_CASE(CPUType, Alpha21364, "alpha 21364");
 252     RETURN_CASE(CPUType, PPC601, "powerpc 601");
 253     RETURN_CASE(CPUType, PPC603, "powerpc 603");
 254     RETURN_CASE(CPUType, PPC604, "powerpc 604");
 255     RETURN_CASE(CPUType, PPC620, "powerpc 620");
 256     RETURN_CASE(CPUType, PPCFP, "powerpc fp");
 257     RETURN_CASE(CPUType, PPCBE, "powerpc be");
 258     RETURN_CASE(CPUType, SH3, "sh3");
 259     RETURN_CASE(CPUType, SH3E, "sh3e");
 260     RETURN_CASE(CPUType, SH3DSP, "sh3 dsp");
 261     RETURN_CASE(CPUType, SH4, "sh4");
 262     RETURN_CASE(CPUType, SHMedia, "shmedia");
 263     RETURN_CASE(CPUType, ARM3, "arm 3");
 264     RETURN_CASE(CPUType, ARM4, "arm 4");
 265     RETURN_CASE(CPUType, ARM4T, "arm 4t");
 266     RETURN_CASE(CPUType, ARM5, "arm 5");
 267     RETURN_CASE(CPUType, ARM5T, "arm 5t");
 268     RETURN_CASE(CPUType, ARM6, "arm 6");
 269     RETURN_CASE(CPUType, ARM_XMAC, "arm xmac");
 270     RETURN_CASE(CPUType, ARM_WMMX, "arm wmmx");
 271     RETURN_CASE(CPUType, ARM7, "arm 7");
 272     RETURN_CASE(CPUType, Omni, "omni");
 273     RETURN_CASE(CPUType, Ia64, "intel itanium ia64");
 274     RETURN_CASE(CPUType, Ia64_2, "intel itanium ia64 2");
 275     RETURN_CASE(CPUType, CEE, "cee");
 276     RETURN_CASE(CPUType, AM33, "am33");
 277     RETURN_CASE(CPUType, M32R, "m32r");
 278     RETURN_CASE(CPUType, TriCore, "tri-core");
 279     RETURN_CASE(CPUType, X64, "intel x86-x64");
 280     RETURN_CASE(CPUType, EBC, "ebc");
 281     RETURN_CASE(CPUType, Thumb, "thumb");
 282     RETURN_CASE(CPUType, ARMNT, "arm nt");
 283     RETURN_CASE(CPUType, D3D11_Shader, "d3d11 shader");
 284   }
 285   return formatUnknownEnum(Cpu);
 286 }
 287
 288 static std::string formatCookieKind(FrameCookieKind Kind) {
 289   switch (Kind) {
 290     RETURN_CASE(FrameCookieKind, Copy, "copy");
 291     RETURN_CASE(FrameCookieKind, XorStackPointer, "xor stack ptr");
 292     RETURN_CASE(FrameCookieKind, XorFramePointer, "xor frame ptr");
 293     RETURN_CASE(FrameCookieKind, XorR13, "xor rot13");
 294   }
 295   return formatUnknownEnum(Kind);
 296 }
 297
 298 static std::string formatRegisterId(RegisterId Id) {
 299   switch (Id) {
 300     RETURN_CASE(RegisterId, VFrame, "vframe");
 301     RETURN_CASE(RegisterId, AL, "al");
 302     RETURN_CASE(RegisterId, CL, "cl");
 303     RETURN_CASE(RegisterId, DL, "dl");
 304     RETURN_CASE(RegisterId, BL, "bl");
 305     RETURN_CASE(RegisterId, AH, "ah");
 306     RETURN_CASE(RegisterId, CH, "ch");
 307     RETURN_CASE(RegisterId, DH, "dh");
 308     RETURN_CASE(RegisterId, BH, "bh");
 309     RETURN_CASE(RegisterId, AX, "ax");
 310     RETURN_CASE(RegisterId, CX, "cx");
 311     RETURN_CASE(RegisterId, DX, "dx");
 312     RETURN_CASE(RegisterId, BX, "bx");
 313     RETURN_CASE(RegisterId, SP, "sp");
 314     RETURN_CASE(RegisterId, BP, "bp");
 315     RETURN_CASE(RegisterId, SI, "si");
 316     RETURN_CASE(RegisterId, DI, "di");
 317     RETURN_CASE(RegisterId, EAX, "eax");
 318     RETURN_CASE(RegisterId, ECX, "ecx");
 319     RETURN_CASE(RegisterId, EDX, "edx");
 320     RETURN_CASE(RegisterId, EBX, "ebx");
 321     RETURN_CASE(RegisterId, ESP, "esp");
 322     RETURN_CASE(RegisterId, EBP, "ebp");
 323     RETURN_CASE(RegisterId, ESI, "esi");
 324     RETURN_CASE(RegisterId, EDI, "edi");
 325     RETURN_CASE(RegisterId, ES, "es");
 326     RETURN_CASE(RegisterId, CS, "cs");
 327     RETURN_CASE(RegisterId, SS, "ss");
 328     RETURN_CASE(RegisterId, DS, "ds");
 329     RETURN_CASE(RegisterId, FS, "fs");
 330     RETURN_CASE(RegisterId, GS, "gs");
 331     RETURN_CASE(RegisterId, IP, "ip");
 332     RETURN_CASE(RegisterId, RAX, "rax");
 333     RETURN_CASE(RegisterId, RBX, "rbx");
 334     RETURN_CASE(RegisterId, RCX, "rcx");
 335     RETURN_CASE(RegisterId, RDX, "rdx");
 336     RETURN_CASE(RegisterId, RSI, "rsi");
 337     RETURN_CASE(RegisterId, RDI, "rdi");
 338     RETURN_CASE(RegisterId, RBP, "rbp");
 339     RETURN_CASE(RegisterId, RSP, "rsp");
 340     RETURN_CASE(RegisterId, R8, "r8");
 341     RETURN_CASE(RegisterId, R9, "r9");
 342     RETURN_CASE(RegisterId, R10, "r10");
 343     RETURN_CASE(RegisterId, R11, "r11");
 344     RETURN_CASE(RegisterId, R12, "r12");
 345     RETURN_CASE(RegisterId, R13, "r13");
 346     RETURN_CASE(RegisterId, R14, "r14");
 347     RETURN_CASE(RegisterId, R15, "r15");
 348   default:
 349     return formatUnknownEnum(Id);
 350   }
 351 }
 352
 353 static std::string formatRange(LocalVariableAddrRange Range) {
 354   return formatv("[{0},+{1})",
 355                  formatSegmentOffset(Range.ISectStart, Range.OffsetStart),
 356                  Range.Range)
 357       .str();
 358 }
 359
 360 static std::string formatGaps(uint32_t IndentLevel,
 361                               ArrayRef<LocalVariableAddrGap> Gaps) {
 362   std::vector<std::string> GapStrs;
 363   for (const auto &G : Gaps) {
 364     GapStrs.push_back(formatv("({0},{1})", G.GapStartOffset, G.Range).str());
 365   }
 366   return typesetItemList(GapStrs, 7, IndentLevel, ", ");
 367 }
 368
 369 Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record) {
 370   return visitSymbolBegin(Record, 0);
 371 }
 372
 373 Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record,
 374                                             uint32_t Offset) {
 375   // formatLine puts the newline at the beginning, so we use formatLine here
 376   // to start a new line, and then individual visit methods use format to
 377   // append to the existing line.
 378   P.formatLine("{0} | {1} [size = {2}]",
 379                fmt_align(Offset, AlignStyle::Right, 6),
 380                getSymbolKindName(Record.Type), Record.length());
 381   P.Indent();
 382   return Error::success();
 383 }
 384
 385 Error MinimalSymbolDumper::visitSymbolEnd(CVSymbol &Record) {
 386   P.Unindent();
 387   return Error::success();
 388 }
 389
 390 std::string MinimalSymbolDumper::typeIndex(TypeIndex TI) const {
 391   if (TI.isSimple())
 392     return formatv("{0}", TI).str();
 393   StringRef Name = Types.getTypeName(TI);
 394   if (Name.size() > 32) {
 395     Name = Name.take_front(32);
 396     return formatv("{0} ({1}...)", TI, Name);
 397   } else
 398     return formatv("{0} ({1})", TI, Name);
 399 }
 400
 401 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, BlockSym &Block) {
 402   P.format(" `{0}`", Block.Name);
 403   AutoIndent Indent(P, 7);
 404   P.formatLine("parent = {0}, end = {1}", Block.Parent, Block.End);
 405   P.formatLine("code size = {0}, addr = {1}", Block.CodeSize,
 406                formatSegmentOffset(Block.Segment, Block.CodeOffset));
 407   return Error::success();
 408 }
 409
 410 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, Thunk32Sym &Thunk) {
 411   P.format(" `{0}`", Thunk.Name);
 412   AutoIndent Indent(P, 7);
 413   P.formatLine("parent = {0}, end = {1}, next = {2}", Thunk.Parent, Thunk.End,
 414                Thunk.Next);
 415   P.formatLine("kind = {0}, size = {1}, addr = {2}",
 416                formatThunkOrdinal(Thunk.Thunk), Thunk.Length,
 417                formatSegmentOffset(Thunk.Segment, Thunk.Offset));
 418
 419   return Error::success();
 420 }
 421
 422 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 423                                             TrampolineSym &Tramp) {
 424   AutoIndent Indent(P, 7);
 425   P.formatLine("type = {0}, size = {1}, source = {2}, target = {3}",
 426                formatTrampolineType(Tramp.Type), Tramp.Size,
 427                formatSegmentOffset(Tramp.ThunkSection, Tramp.ThunkOffset),
 428                formatSegmentOffset(Tramp.TargetSection, Tramp.ThunkOffset));
 429
 430   return Error::success();
 431 }
 432
 433 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 434                                             SectionSym &Section) {
 435   P.format(" `{0}`", Section.Name);
 436   AutoIndent Indent(P, 7);
 437   P.formatLine("length = {0}, alignment = {1}, rva = {2}, section # = {3}, "
 438                "characteristics = {4}",
 439                Section.Length, Section.Alignment, Section.Rva,
 440                Section.SectionNumber, Section.Characteristics);
 441   return Error::success();
 442 }
 443
 444 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CoffGroupSym &CG) {
 445   P.format(" `{0}`", CG.Name);
 446   AutoIndent Indent(P, 7);
 447   P.formatLine("length = {0}, addr = {1}, characteristics = {2}", CG.Size,
 448                formatSegmentOffset(CG.Segment, CG.Offset), CG.Characteristics);
 449   return Error::success();
 450 }
 451
 452 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 453                                             BPRelativeSym &BPRel) {
 454   P.format(" `{0}`", BPRel.Name);
 455   AutoIndent Indent(P, 7);
 456   P.formatLine("type = {0}, offset = {1}", typeIndex(BPRel.Type), BPRel.Offset);
 457   return Error::success();
 458 }
 459
 460 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 461                                             BuildInfoSym &BuildInfo) {
 462   P.format(" BuildId = `{0}`", BuildInfo.BuildId);
 463   return Error::success();
 464 }
 465
 466 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 467                                             CallSiteInfoSym &CSI) {
 468   AutoIndent Indent(P, 7);
 469   P.formatLine("type = {0}, addr = {1}", typeIndex(CSI.Type),
 470                formatSegmentOffset(CSI.Segment, CSI.CodeOffset));
 471   return Error::success();
 472 }
 473
 474 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 475                                             EnvBlockSym &EnvBlock) {
 476   AutoIndent Indent(P, 7);
 477   for (const auto &Entry : EnvBlock.Fields) {
 478     P.formatLine("- {0}", Entry);
 479   }
 480   return Error::success();
 481 }
 482
 483 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FileStaticSym &FS) {
 484   P.format(" `{0}`", FS.Name);
 485   AutoIndent Indent(P, 7);
 486   P.formatLine("type = {0}, file name offset = {1}, flags = {2}",
 487                typeIndex(FS.Index), FS.ModFilenameOffset,
 488                formatLocalSymFlags(P.getIndentLevel() + 9, FS.Flags));
 489   return Error::success();
 490 }
 491
 492 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
 493   P.format(" `{0}`", Export.Name);
 494   AutoIndent Indent(P, 7);
 495   P.formatLine("ordinal = {0}, flags = {1}", Export.Ordinal,
 496                formatExportFlags(P.getIndentLevel() + 9, Export.Flags));
 497   return Error::success();
 498 }
 499
 500 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 501                                             Compile2Sym &Compile2) {
 502   AutoIndent Indent(P, 7);
 503   SourceLanguage Lang = static_cast<SourceLanguage>(
 504       Compile2.Flags & CompileSym2Flags::SourceLanguageMask);
 505   P.formatLine("machine = {0}, ver = {1}, language = {2}",
 506                formatMachineType(Compile2.Machine), Compile2.Version,
 507                formatSourceLanguage(Lang));
 508   P.formatLine("frontend = {0}.{1}.{2}, backend = {3}.{4}.{5}",
 509                Compile2.VersionFrontendMajor, Compile2.VersionFrontendMinor,
 510                Compile2.VersionFrontendBuild, Compile2.VersionBackendMajor,
 511                Compile2.VersionBackendMinor, Compile2.VersionBackendBuild);
 512   P.formatLine("flags = {0}",
 513                formatCompileSym2Flags(P.getIndentLevel() + 9, Compile2.Flags));
 514   P.formatLine(
 515       "extra strings = {0}",
 516       typesetStringList(P.getIndentLevel() + 9 + 2, Compile2.ExtraStrings));
 517   return Error::success();
 518 }
 519
 520 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 521                                             Compile3Sym &Compile3) {
 522   AutoIndent Indent(P, 7);
 523   SourceLanguage Lang = static_cast<SourceLanguage>(
 524       Compile3.Flags & CompileSym3Flags::SourceLanguageMask);
 525   P.formatLine("machine = {0}, Ver = {1}, language = {2}",
 526                formatMachineType(Compile3.Machine), Compile3.Version,
 527                formatSourceLanguage(Lang));
 528   P.formatLine("frontend = {0}.{1}.{2}.{3}, backend = {4}.{5}.{6}.{7}",
 529                Compile3.VersionFrontendMajor, Compile3.VersionFrontendMinor,
 530                Compile3.VersionFrontendBuild, Compile3.VersionFrontendQFE,
 531                Compile3.VersionBackendMajor, Compile3.VersionBackendMinor,
 532                Compile3.VersionBackendBuild, Compile3.VersionBackendQFE);
 533   P.formatLine("flags = {0}",
 534                formatCompileSym3Flags(P.getIndentLevel() + 9, Compile3.Flags));
 535   return Error::success();
 536 }
 537
 538 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 539                                             ConstantSym &Constant) {
 540   P.format(" `{0}`", Constant.Name);
 541   AutoIndent Indent(P, 7);
 542   P.formatLine("type = {0}, value = {1}", typeIndex(Constant.Type),
 543                Constant.Value.toString(10));
 544   return Error::success();
 545 }
 546
 547 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
 548   P.format(" `{0}`", Data.Name);
 549   AutoIndent Indent(P, 7);
 550   P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
 551                formatSegmentOffset(Data.Segment, Data.DataOffset));
 552   return Error::success();
 553 }
 554
 555 Error MinimalSymbolDumper::visitKnownRecord(
 556     CVSymbol &CVR, DefRangeFramePointerRelFullScopeSym &Def) {
 557   P.format(" offset = {0}", Def.Offset);
 558   return Error::success();
 559 }
 560
 561 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 562                                             DefRangeFramePointerRelSym &Def) {
 563   AutoIndent Indent(P, 7);
 564   P.formatLine("offset = {0}, range = {1}", Def.Offset, formatRange(Def.Range));
 565   P.formatLine("gaps = {2}", Def.Offset,
 566                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 567   return Error::success();
 568 }
 569
 570 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 571                                             DefRangeRegisterRelSym &Def) {
 572   AutoIndent Indent(P, 7);
 573   P.formatLine("register = {0}, base ptr = {1}, offset in parent = {2}, has "
 574                "spilled udt = {3}",
 575                uint16_t(Def.Hdr.Register), int32_t(Def.Hdr.BasePointerOffset),
 576                Def.offsetInParent(), Def.hasSpilledUDTMember());
 577   P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
 578                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 579   return Error::success();
 580 }
 581
 582 Error MinimalSymbolDumper::visitKnownRecord(
 583     CVSymbol &CVR, DefRangeRegisterSym &DefRangeRegister) {
 584   AutoIndent Indent(P, 7);
 585   P.formatLine("register = {0}, may have no name = {1}, range start = "
 586                "{2}, length = {3}",
 587                uint16_t(DefRangeRegister.Hdr.Register),
 588                uint16_t(DefRangeRegister.Hdr.MayHaveNoName),
 589                formatSegmentOffset(DefRangeRegister.Range.ISectStart,
 590                                    DefRangeRegister.Range.OffsetStart),
 591                DefRangeRegister.Range.Range);
 592   P.formatLine("gaps = [{0}]",
 593                formatGaps(P.getIndentLevel() + 9, DefRangeRegister.Gaps));
 594   return Error::success();
 595 }
 596
 597 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 598                                             DefRangeSubfieldRegisterSym &Def) {
 599   AutoIndent Indent(P, 7);
 600   bool NoName = !!(Def.Hdr.MayHaveNoName == 0);
 601   P.formatLine("register = {0}, may have no name = {1}, offset in parent = {2}",
 602                uint16_t(Def.Hdr.Register), NoName,
 603                uint32_t(Def.Hdr.OffsetInParent));
 604   P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
 605                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 606   return Error::success();
 607 }
 608
 609 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 610                                             DefRangeSubfieldSym &Def) {
 611   AutoIndent Indent(P, 7);
 612   P.formatLine("program = {0}, offset in parent = {1}, range = {2}",
 613                Def.Program, Def.OffsetInParent, formatRange(Def.Range));
 614   P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 615   return Error::success();
 616 }
 617
 618 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DefRangeSym &Def) {
 619   AutoIndent Indent(P, 7);
 620   P.formatLine("program = {0}, range = {1}", Def.Program,
 621                formatRange(Def.Range));
 622   P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
 623   return Error::success();
 624 }
 625
 626 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameCookieSym &FC) {
 627   AutoIndent Indent(P, 7);
 628   P.formatLine("code offset = {0}, Register = {1}, kind = {2}, flags = {3}",
 629                FC.CodeOffset, FC.Register, formatCookieKind(FC.CookieKind),
 630                FC.Flags);
 631   return Error::success();
 632 }
 633
 634 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameProcSym &FP) {
 635   AutoIndent Indent(P, 7);
 636   P.formatLine("size = {0}, padding size = {1}, offset to padding = {2}",
 637                FP.TotalFrameBytes, FP.PaddingFrameBytes, FP.OffsetToPadding);
 638   P.formatLine("bytes of callee saved registers = {0}, exception handler addr "
 639                "= {1}",
 640                FP.BytesOfCalleeSavedRegisters,
 641                formatSegmentOffset(FP.SectionIdOfExceptionHandler,
 642                                    FP.OffsetOfExceptionHandler));
 643   P.formatLine("flags = {0}",
 644                formatFrameProcedureOptions(P.getIndentLevel() + 9, FP.Flags));
 645   return Error::success();
 646 }
 647
 648 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 649                                             HeapAllocationSiteSym &HAS) {
 650   AutoIndent Indent(P, 7);
 651   P.formatLine("type = {0}, addr = {1} call size = {2}", typeIndex(HAS.Type),
 652                formatSegmentOffset(HAS.Segment, HAS.CodeOffset),
 653                HAS.CallInstructionSize);
 654   return Error::success();
 655 }
 656
 657 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, InlineSiteSym &IS) {
 658   AutoIndent Indent(P, 7);
 659   auto Bytes = makeArrayRef(IS.AnnotationData);
 660   StringRef Annotations(reinterpret_cast<const char *>(Bytes.begin()),
 661                         Bytes.size());
 662
 663   P.formatLine("inlinee = {0}, parent = {1}, end = {2}", typeIndex(IS.Inlinee),
 664                IS.Parent, IS.End);
 665   P.formatLine("annotations = {0}", toHex(Annotations));
 666   return Error::success();
 667 }
 668
 669 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 670                                             RegisterSym &Register) {
 671   P.format(" `{0}`", Register.Name);
 672   AutoIndent Indent(P, 7);
 673   P.formatLine("register = {0}, type = {1}",
 674                formatRegisterId(Register.Register), typeIndex(Register.Index));
 675   return Error::success();
 676 }
 677
 678 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 679                                             PublicSym32 &Public) {
 680   P.format(" `{0}`", Public.Name);
 681   AutoIndent Indent(P, 7);
 682   P.formatLine("flags = {0}, addr = {1}",
 683                formatPublicSymFlags(P.getIndentLevel() + 9, Public.Flags),
 684                formatSegmentOffset(Public.Segment, Public.Offset));
 685   return Error::success();
 686 }
 687
 688 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcRefSym &PR) {
 689   P.format(" `{0}`", PR.Name);
 690   AutoIndent Indent(P, 7);
 691   P.formatLine("module = {0}, sum name = {1}, offset = {2}", PR.Module,
 692                PR.SumName, PR.SymOffset);
 693   return Error::success();
 694 }
 695
 696 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LabelSym &Label) {
 697   P.format(" `{0}` (addr = {1})", Label.Name,
 698            formatSegmentOffset(Label.Segment, Label.CodeOffset));
 699   AutoIndent Indent(P, 7);
 700   P.formatLine("flags = {0}",
 701                formatProcSymFlags(P.getIndentLevel() + 9, Label.Flags));
 702   return Error::success();
 703 }
 704
 705 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LocalSym &Local) {
 706   P.format(" `{0}`", Local.Name);
 707   AutoIndent Indent(P, 7);
 708
 709   std::string FlagStr =
 710       formatLocalSymFlags(P.getIndentLevel() + 9, Local.Flags);
 711   P.formatLine("type={0}, flags = {1}", typeIndex(Local.Type), FlagStr);
 712   return Error::success();
 713 }
 714
 715 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 716                                             ObjNameSym &ObjName) {
 717   P.format(" sig={0}, `{1}`", ObjName.Signature, ObjName.Name);
 718   return Error::success();
 719 }
 720
 721 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcSym &Proc) {
 722   P.format(" `{0}`", Proc.Name);
 723   AutoIndent Indent(P, 7);
 724   P.formatLine("parent = {0}, end = {1}, addr = {2}, code size = {3}",
 725                Proc.Parent, Proc.End,
 726                formatSegmentOffset(Proc.Segment, Proc.CodeOffset),
 727                Proc.CodeSize);
 728   // FIXME: It seems FunctionType is sometimes an id and sometimes a type.
 729   P.formatLine("type = `{0}`, debug start = {1}, debug end = {2}, flags = {3}",
 730                typeIndex(Proc.FunctionType), Proc.DbgStart, Proc.DbgEnd,
 731                formatProcSymFlags(P.getIndentLevel() + 9, Proc.Flags));
 732   return Error::success();
 733 }
 734
 735 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 736                                             ScopeEndSym &ScopeEnd) {
 737   return Error::success();
 738 }
 739
 740 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CallerSym &Caller) {
 741   AutoIndent Indent(P, 7);
 742   for (const auto &I : Caller.Indices) {
 743     P.formatLine("callee: {0}", typeIndex(I));
 744   }
 745   return Error::success();
 746 }
 747
 748 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 749                                             RegRelativeSym &RegRel) {
 750   P.format(" `{0}`", RegRel.Name);
 751   AutoIndent Indent(P, 7);
 752   P.formatLine("type = {0}, register = {1}, offset = {2}",
 753                typeIndex(RegRel.Type), formatRegisterId(RegRel.Register),
 754                RegRel.Offset);
 755   return Error::success();
 756 }
 757
 758 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
 759                                             ThreadLocalDataSym &Data) {
 760   P.format(" `{0}`", Data.Name);
 761   AutoIndent Indent(P, 7);
 762   P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
 763                formatSegmentOffset(Data.Segment, Data.DataOffset));
 764   return Error::success();
 765 }
 766
 767 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, UDTSym &UDT) {
 768   P.format(" `{0}`", UDT.Name);
 769   AutoIndent Indent(P, 7);
 770   P.formatLine("original type = {0}", UDT.Type);
 771   return Error::success();
 772 }