MinimalSymbolDumper.cpp revision 360784 
1//===- MinimalSymbolDumper.cpp -------------------------------- *- C++ --*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "MinimalSymbolDumper.h"
10
11#include "FormatUtil.h"
12#include "InputFile.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/DebugInfo/PDB/Native/PDBStringTable.h"
22#include "llvm/Support/FormatVariadic.h"
23
24using namespace llvm;
25using namespace llvm::codeview;
26using namespace llvm::pdb;
27
28static std::string formatLocalSymFlags(uint32_t IndentLevel,
29                                       LocalSymFlags Flags) {
30  std::vector<std::string> Opts;
31  if (Flags == LocalSymFlags::None)
32    return "none";
33
34  PUSH_FLAG(LocalSymFlags, IsParameter, Flags, "param");
35  PUSH_FLAG(LocalSymFlags, IsAddressTaken, Flags, "address is taken");
36  PUSH_FLAG(LocalSymFlags, IsCompilerGenerated, Flags, "compiler generated");
37  PUSH_FLAG(LocalSymFlags, IsAggregate, Flags, "aggregate");
38  PUSH_FLAG(LocalSymFlags, IsAggregated, Flags, "aggregated");
39  PUSH_FLAG(LocalSymFlags, IsAliased, Flags, "aliased");
40  PUSH_FLAG(LocalSymFlags, IsAlias, Flags, "alias");
41  PUSH_FLAG(LocalSymFlags, IsReturnValue, Flags, "return val");
42  PUSH_FLAG(LocalSymFlags, IsOptimizedOut, Flags, "optimized away");
43  PUSH_FLAG(LocalSymFlags, IsEnregisteredGlobal, Flags, "enreg global");
44  PUSH_FLAG(LocalSymFlags, IsEnregisteredStatic, Flags, "enreg static");
45  return typesetItemList(Opts, 4, IndentLevel, " | ");
46}
47
48static std::string formatExportFlags(uint32_t IndentLevel, ExportFlags Flags) {
49  std::vector<std::string> Opts;
50  if (Flags == ExportFlags::None)
51    return "none";
52
53  PUSH_FLAG(ExportFlags, IsConstant, Flags, "constant");
54  PUSH_FLAG(ExportFlags, IsData, Flags, "data");
55  PUSH_FLAG(ExportFlags, IsPrivate, Flags, "private");
56  PUSH_FLAG(ExportFlags, HasNoName, Flags, "no name");
57  PUSH_FLAG(ExportFlags, HasExplicitOrdinal, Flags, "explicit ord");
58  PUSH_FLAG(ExportFlags, IsForwarder, Flags, "forwarder");
59
60  return typesetItemList(Opts, 4, IndentLevel, " | ");
61}
62
63static std::string formatCompileSym2Flags(uint32_t IndentLevel,
64                                          CompileSym2Flags Flags) {
65  std::vector<std::string> Opts;
66  Flags &= ~CompileSym2Flags::SourceLanguageMask;
67  if (Flags == CompileSym2Flags::None)
68    return "none";
69
70  PUSH_FLAG(CompileSym2Flags, EC, Flags, "edit and continue");
71  PUSH_FLAG(CompileSym2Flags, NoDbgInfo, Flags, "no dbg info");
72  PUSH_FLAG(CompileSym2Flags, LTCG, Flags, "ltcg");
73  PUSH_FLAG(CompileSym2Flags, NoDataAlign, Flags, "no data align");
74  PUSH_FLAG(CompileSym2Flags, ManagedPresent, Flags, "has managed code");
75  PUSH_FLAG(CompileSym2Flags, SecurityChecks, Flags, "security checks");
76  PUSH_FLAG(CompileSym2Flags, HotPatch, Flags, "hot patchable");
77  PUSH_FLAG(CompileSym2Flags, CVTCIL, Flags, "cvtcil");
78  PUSH_FLAG(CompileSym2Flags, MSILModule, Flags, "msil module");
79  return typesetItemList(Opts, 4, IndentLevel, " | ");
80}
81
82static std::string formatCompileSym3Flags(uint32_t IndentLevel,
83                                          CompileSym3Flags Flags) {
84  std::vector<std::string> Opts;
85  Flags &= ~CompileSym3Flags::SourceLanguageMask;
86
87  if (Flags == CompileSym3Flags::None)
88    return "none";
89
90  PUSH_FLAG(CompileSym3Flags, EC, Flags, "edit and continue");
91  PUSH_FLAG(CompileSym3Flags, NoDbgInfo, Flags, "no dbg info");
92  PUSH_FLAG(CompileSym3Flags, LTCG, Flags, "ltcg");
93  PUSH_FLAG(CompileSym3Flags, NoDataAlign, Flags, "no data align");
94  PUSH_FLAG(CompileSym3Flags, ManagedPresent, Flags, "has managed code");
95  PUSH_FLAG(CompileSym3Flags, SecurityChecks, Flags, "security checks");
96  PUSH_FLAG(CompileSym3Flags, HotPatch, Flags, "hot patchable");
97  PUSH_FLAG(CompileSym3Flags, CVTCIL, Flags, "cvtcil");
98  PUSH_FLAG(CompileSym3Flags, MSILModule, Flags, "msil module");
99  PUSH_FLAG(CompileSym3Flags, Sdl, Flags, "sdl");
100  PUSH_FLAG(CompileSym3Flags, PGO, Flags, "pgo");
101  PUSH_FLAG(CompileSym3Flags, Exp, Flags, "exp");
102  return typesetItemList(Opts, 4, IndentLevel, " | ");
103}
104
105static std::string formatFrameProcedureOptions(uint32_t IndentLevel,
106                                               FrameProcedureOptions FPO) {
107  std::vector<std::string> Opts;
108  if (FPO == FrameProcedureOptions::None)
109    return "none";
110
111  PUSH_FLAG(FrameProcedureOptions, HasAlloca, FPO, "has alloca");
112  PUSH_FLAG(FrameProcedureOptions, HasSetJmp, FPO, "has setjmp");
113  PUSH_FLAG(FrameProcedureOptions, HasLongJmp, FPO, "has longjmp");
114  PUSH_FLAG(FrameProcedureOptions, HasInlineAssembly, FPO, "has inline asm");
115  PUSH_FLAG(FrameProcedureOptions, HasExceptionHandling, FPO, "has eh");
116  PUSH_FLAG(FrameProcedureOptions, MarkedInline, FPO, "marked inline");
117  PUSH_FLAG(FrameProcedureOptions, HasStructuredExceptionHandling, FPO,
118            "has seh");
119  PUSH_FLAG(FrameProcedureOptions, Naked, FPO, "naked");
120  PUSH_FLAG(FrameProcedureOptions, SecurityChecks, FPO, "secure checks");
121  PUSH_FLAG(FrameProcedureOptions, AsynchronousExceptionHandling, FPO,
122            "has async eh");
123  PUSH_FLAG(FrameProcedureOptions, NoStackOrderingForSecurityChecks, FPO,
124            "no stack order");
125  PUSH_FLAG(FrameProcedureOptions, Inlined, FPO, "inlined");
126  PUSH_FLAG(FrameProcedureOptions, StrictSecurityChecks, FPO,
127            "strict secure checks");
128  PUSH_FLAG(FrameProcedureOptions, SafeBuffers, FPO, "safe buffers");
129  PUSH_FLAG(FrameProcedureOptions, ProfileGuidedOptimization, FPO, "pgo");
130  PUSH_FLAG(FrameProcedureOptions, ValidProfileCounts, FPO,
131            "has profile counts");
132  PUSH_FLAG(FrameProcedureOptions, OptimizedForSpeed, FPO, "opt speed");
133  PUSH_FLAG(FrameProcedureOptions, GuardCfg, FPO, "guard cfg");
134  PUSH_FLAG(FrameProcedureOptions, GuardCfw, FPO, "guard cfw");
135  return typesetItemList(Opts, 4, IndentLevel, " | ");
136}
137
138static std::string formatPublicSymFlags(uint32_t IndentLevel,
139                                        PublicSymFlags Flags) {
140  std::vector<std::string> Opts;
141  if (Flags == PublicSymFlags::None)
142    return "none";
143
144  PUSH_FLAG(PublicSymFlags, Code, Flags, "code");
145  PUSH_FLAG(PublicSymFlags, Function, Flags, "function");
146  PUSH_FLAG(PublicSymFlags, Managed, Flags, "managed");
147  PUSH_FLAG(PublicSymFlags, MSIL, Flags, "msil");
148  return typesetItemList(Opts, 4, IndentLevel, " | ");
149}
150
151static std::string formatProcSymFlags(uint32_t IndentLevel,
152                                      ProcSymFlags Flags) {
153  std::vector<std::string> Opts;
154  if (Flags == ProcSymFlags::None)
155    return "none";
156
157  PUSH_FLAG(ProcSymFlags, HasFP, Flags, "has fp");
158  PUSH_FLAG(ProcSymFlags, HasIRET, Flags, "has iret");
159  PUSH_FLAG(ProcSymFlags, HasFRET, Flags, "has fret");
160  PUSH_FLAG(ProcSymFlags, IsNoReturn, Flags, "noreturn");
161  PUSH_FLAG(ProcSymFlags, IsUnreachable, Flags, "unreachable");
162  PUSH_FLAG(ProcSymFlags, HasCustomCallingConv, Flags, "custom calling conv");
163  PUSH_FLAG(ProcSymFlags, IsNoInline, Flags, "noinline");
164  PUSH_FLAG(ProcSymFlags, HasOptimizedDebugInfo, Flags, "opt debuginfo");
165  return typesetItemList(Opts, 4, IndentLevel, " | ");
166}
167
168static std::string formatThunkOrdinal(ThunkOrdinal Ordinal) {
169  switch (Ordinal) {
170    RETURN_CASE(ThunkOrdinal, Standard, "thunk");
171    RETURN_CASE(ThunkOrdinal, ThisAdjustor, "this adjustor");
172    RETURN_CASE(ThunkOrdinal, Vcall, "vcall");
173    RETURN_CASE(ThunkOrdinal, Pcode, "pcode");
174    RETURN_CASE(ThunkOrdinal, UnknownLoad, "unknown load");
175    RETURN_CASE(ThunkOrdinal, TrampIncremental, "tramp incremental");
176    RETURN_CASE(ThunkOrdinal, BranchIsland, "branch island");
177  }
178  return formatUnknownEnum(Ordinal);
179}
180
181static std::string formatTrampolineType(TrampolineType Tramp) {
182  switch (Tramp) {
183    RETURN_CASE(TrampolineType, TrampIncremental, "tramp incremental");
184    RETURN_CASE(TrampolineType, BranchIsland, "branch island");
185  }
186  return formatUnknownEnum(Tramp);
187}
188
189static std::string formatSourceLanguage(SourceLanguage Lang) {
190  switch (Lang) {
191    RETURN_CASE(SourceLanguage, C, "c");
192    RETURN_CASE(SourceLanguage, Cpp, "c++");
193    RETURN_CASE(SourceLanguage, Fortran, "fortran");
194    RETURN_CASE(SourceLanguage, Masm, "masm");
195    RETURN_CASE(SourceLanguage, Pascal, "pascal");
196    RETURN_CASE(SourceLanguage, Basic, "basic");
197    RETURN_CASE(SourceLanguage, Cobol, "cobol");
198    RETURN_CASE(SourceLanguage, Link, "link");
199    RETURN_CASE(SourceLanguage, VB, "vb");
200    RETURN_CASE(SourceLanguage, Cvtres, "cvtres");
201    RETURN_CASE(SourceLanguage, Cvtpgd, "cvtpgd");
202    RETURN_CASE(SourceLanguage, CSharp, "c#");
203    RETURN_CASE(SourceLanguage, ILAsm, "il asm");
204    RETURN_CASE(SourceLanguage, Java, "java");
205    RETURN_CASE(SourceLanguage, JScript, "javascript");
206    RETURN_CASE(SourceLanguage, MSIL, "msil");
207    RETURN_CASE(SourceLanguage, HLSL, "hlsl");
208    RETURN_CASE(SourceLanguage, D, "d");
209    RETURN_CASE(SourceLanguage, Swift, "swift");
210  }
211  return formatUnknownEnum(Lang);
212}
213
214static std::string formatMachineType(CPUType Cpu) {
215  switch (Cpu) {
216    RETURN_CASE(CPUType, Intel8080, "intel 8080");
217    RETURN_CASE(CPUType, Intel8086, "intel 8086");
218    RETURN_CASE(CPUType, Intel80286, "intel 80286");
219    RETURN_CASE(CPUType, Intel80386, "intel 80386");
220    RETURN_CASE(CPUType, Intel80486, "intel 80486");
221    RETURN_CASE(CPUType, Pentium, "intel pentium");
222    RETURN_CASE(CPUType, PentiumPro, "intel pentium pro");
223    RETURN_CASE(CPUType, Pentium3, "intel pentium 3");
224    RETURN_CASE(CPUType, MIPS, "mips");
225    RETURN_CASE(CPUType, MIPS16, "mips-16");
226    RETURN_CASE(CPUType, MIPS32, "mips-32");
227    RETURN_CASE(CPUType, MIPS64, "mips-64");
228    RETURN_CASE(CPUType, MIPSI, "mips i");
229    RETURN_CASE(CPUType, MIPSII, "mips ii");
230    RETURN_CASE(CPUType, MIPSIII, "mips iii");
231    RETURN_CASE(CPUType, MIPSIV, "mips iv");
232    RETURN_CASE(CPUType, MIPSV, "mips v");
233    RETURN_CASE(CPUType, M68000, "motorola 68000");
234    RETURN_CASE(CPUType, M68010, "motorola 68010");
235    RETURN_CASE(CPUType, M68020, "motorola 68020");
236    RETURN_CASE(CPUType, M68030, "motorola 68030");
237    RETURN_CASE(CPUType, M68040, "motorola 68040");
238    RETURN_CASE(CPUType, Alpha, "alpha");
239    RETURN_CASE(CPUType, Alpha21164, "alpha 21164");
240    RETURN_CASE(CPUType, Alpha21164A, "alpha 21164a");
241    RETURN_CASE(CPUType, Alpha21264, "alpha 21264");
242    RETURN_CASE(CPUType, Alpha21364, "alpha 21364");
243    RETURN_CASE(CPUType, PPC601, "powerpc 601");
244    RETURN_CASE(CPUType, PPC603, "powerpc 603");
245    RETURN_CASE(CPUType, PPC604, "powerpc 604");
246    RETURN_CASE(CPUType, PPC620, "powerpc 620");
247    RETURN_CASE(CPUType, PPCFP, "powerpc fp");
248    RETURN_CASE(CPUType, PPCBE, "powerpc be");
249    RETURN_CASE(CPUType, SH3, "sh3");
250    RETURN_CASE(CPUType, SH3E, "sh3e");
251    RETURN_CASE(CPUType, SH3DSP, "sh3 dsp");
252    RETURN_CASE(CPUType, SH4, "sh4");
253    RETURN_CASE(CPUType, SHMedia, "shmedia");
254    RETURN_CASE(CPUType, ARM3, "arm 3");
255    RETURN_CASE(CPUType, ARM4, "arm 4");
256    RETURN_CASE(CPUType, ARM4T, "arm 4t");
257    RETURN_CASE(CPUType, ARM5, "arm 5");
258    RETURN_CASE(CPUType, ARM5T, "arm 5t");
259    RETURN_CASE(CPUType, ARM6, "arm 6");
260    RETURN_CASE(CPUType, ARM_XMAC, "arm xmac");
261    RETURN_CASE(CPUType, ARM_WMMX, "arm wmmx");
262    RETURN_CASE(CPUType, ARM7, "arm 7");
263    RETURN_CASE(CPUType, ARM64, "arm64");
264    RETURN_CASE(CPUType, Omni, "omni");
265    RETURN_CASE(CPUType, Ia64, "intel itanium ia64");
266    RETURN_CASE(CPUType, Ia64_2, "intel itanium ia64 2");
267    RETURN_CASE(CPUType, CEE, "cee");
268    RETURN_CASE(CPUType, AM33, "am33");
269    RETURN_CASE(CPUType, M32R, "m32r");
270    RETURN_CASE(CPUType, TriCore, "tri-core");
271    RETURN_CASE(CPUType, X64, "intel x86-x64");
272    RETURN_CASE(CPUType, EBC, "ebc");
273    RETURN_CASE(CPUType, Thumb, "thumb");
274    RETURN_CASE(CPUType, ARMNT, "arm nt");
275    RETURN_CASE(CPUType, D3D11_Shader, "d3d11 shader");
276  }
277  return formatUnknownEnum(Cpu);
278}
279
280static std::string formatCookieKind(FrameCookieKind Kind) {
281  switch (Kind) {
282    RETURN_CASE(FrameCookieKind, Copy, "copy");
283    RETURN_CASE(FrameCookieKind, XorStackPointer, "xor stack ptr");
284    RETURN_CASE(FrameCookieKind, XorFramePointer, "xor frame ptr");
285    RETURN_CASE(FrameCookieKind, XorR13, "xor rot13");
286  }
287  return formatUnknownEnum(Kind);
288}
289
290static std::string formatRegisterId(RegisterId Id, CPUType Cpu) {
291  if (Cpu == CPUType::ARM64) {
292    switch (Id) {
293#define CV_REGISTERS_ARM64
294#define CV_REGISTER(name, val) RETURN_CASE(RegisterId, name, #name)
295#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
296#undef CV_REGISTER
297#undef CV_REGISTERS_ARM64
298
299    default:
300      break;
301    }
302  } else {
303    switch (Id) {
304#define CV_REGISTERS_X86
305#define CV_REGISTER(name, val) RETURN_CASE(RegisterId, name, #name)
306#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
307#undef CV_REGISTER
308#undef CV_REGISTERS_X86
309
310    default:
311      break;
312    }
313  }
314  return formatUnknownEnum(Id);
315}
316
317static std::string formatRegisterId(uint16_t Reg16, CPUType Cpu) {
318  return formatRegisterId(RegisterId(Reg16), Cpu);
319}
320
321static std::string formatRegisterId(ulittle16_t &Reg16, CPUType Cpu) {
322  return formatRegisterId(uint16_t(Reg16), Cpu);
323}
324
325static std::string formatRange(LocalVariableAddrRange Range) {
326  return formatv("[{0},+{1})",
327                 formatSegmentOffset(Range.ISectStart, Range.OffsetStart),
328                 Range.Range)
329      .str();
330}
331
332static std::string formatGaps(uint32_t IndentLevel,
333                              ArrayRef<LocalVariableAddrGap> Gaps) {
334  std::vector<std::string> GapStrs;
335  for (const auto &G : Gaps) {
336    GapStrs.push_back(formatv("({0},{1})", G.GapStartOffset, G.Range).str());
337  }
338  return typesetItemList(GapStrs, 7, IndentLevel, ", ");
339}
340
341Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record) {
342  return visitSymbolBegin(Record, 0);
343}
344
345Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record,
346                                            uint32_t Offset) {
347  // formatLine puts the newline at the beginning, so we use formatLine here
348  // to start a new line, and then individual visit methods use format to
349  // append to the existing line.
350  P.formatLine("{0} | {1} [size = {2}]",
351               fmt_align(Offset, AlignStyle::Right, 6),
352               formatSymbolKind(Record.kind()), Record.length());
353  P.Indent();
354  return Error::success();
355}
356
357Error MinimalSymbolDumper::visitSymbolEnd(CVSymbol &Record) {
358  if (RecordBytes) {
359    AutoIndent Indent(P, 7);
360    P.formatBinary("bytes", Record.content(), 0);
361  }
362  P.Unindent();
363  return Error::success();
364}
365
366std::string MinimalSymbolDumper::typeOrIdIndex(codeview::TypeIndex TI,
367                                               bool IsType) const {
368  if (TI.isSimple() || TI.isDecoratedItemId())
369    return formatv("{0}", TI).str();
370  auto &Container = IsType ? Types : Ids;
371  StringRef Name = Container.getTypeName(TI);
372  if (Name.size() > 32) {
373    Name = Name.take_front(32);
374    return formatv("{0} ({1}...)", TI, Name);
375  } else
376    return formatv("{0} ({1})", TI, Name);
377}
378
379std::string MinimalSymbolDumper::idIndex(codeview::TypeIndex TI) const {
380  return typeOrIdIndex(TI, false);
381}
382
383std::string MinimalSymbolDumper::typeIndex(TypeIndex TI) const {
384  return typeOrIdIndex(TI, true);
385}
386
387Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, BlockSym &Block) {
388  P.format(" `{0}`", Block.Name);
389  AutoIndent Indent(P, 7);
390  P.formatLine("parent = {0}, end = {1}", Block.Parent, Block.End);
391  P.formatLine("code size = {0}, addr = {1}", Block.CodeSize,
392               formatSegmentOffset(Block.Segment, Block.CodeOffset));
393  return Error::success();
394}
395
396Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, Thunk32Sym &Thunk) {
397  P.format(" `{0}`", Thunk.Name);
398  AutoIndent Indent(P, 7);
399  P.formatLine("parent = {0}, end = {1}, next = {2}", Thunk.Parent, Thunk.End,
400               Thunk.Next);
401  P.formatLine("kind = {0}, size = {1}, addr = {2}",
402               formatThunkOrdinal(Thunk.Thunk), Thunk.Length,
403               formatSegmentOffset(Thunk.Segment, Thunk.Offset));
404
405  return Error::success();
406}
407
408Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
409                                            TrampolineSym &Tramp) {
410  AutoIndent Indent(P, 7);
411  P.formatLine("type = {0}, size = {1}, source = {2}, target = {3}",
412               formatTrampolineType(Tramp.Type), Tramp.Size,
413               formatSegmentOffset(Tramp.ThunkSection, Tramp.ThunkOffset),
414               formatSegmentOffset(Tramp.TargetSection, Tramp.ThunkOffset));
415
416  return Error::success();
417}
418
419Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
420                                            SectionSym &Section) {
421  P.format(" `{0}`", Section.Name);
422  AutoIndent Indent(P, 7);
423  P.formatLine("length = {0}, alignment = {1}, rva = {2}, section # = {3}",
424               Section.Length, Section.Alignment, Section.Rva,
425               Section.SectionNumber);
426  P.printLine("characteristics =");
427  AutoIndent Indent2(P, 2);
428  P.printLine(formatSectionCharacteristics(P.getIndentLevel(),
429                                           Section.Characteristics, 1, "",
430                                           CharacteristicStyle::Descriptive));
431  return Error::success();
432}
433
434Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CoffGroupSym &CG) {
435  P.format(" `{0}`", CG.Name);
436  AutoIndent Indent(P, 7);
437  P.formatLine("length = {0}, addr = {1}", CG.Size,
438               formatSegmentOffset(CG.Segment, CG.Offset));
439  P.printLine("characteristics =");
440  AutoIndent Indent2(P, 2);
441  P.printLine(formatSectionCharacteristics(P.getIndentLevel(),
442                                           CG.Characteristics, 1, "",
443                                           CharacteristicStyle::Descriptive));
444  return Error::success();
445}
446
447Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
448                                            BPRelativeSym &BPRel) {
449  P.format(" `{0}`", BPRel.Name);
450  AutoIndent Indent(P, 7);
451  P.formatLine("type = {0}, offset = {1}", typeIndex(BPRel.Type), BPRel.Offset);
452  return Error::success();
453}
454
455Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
456                                            BuildInfoSym &BuildInfo) {
457  P.format(" BuildId = `{0}`", BuildInfo.BuildId);
458  return Error::success();
459}
460
461Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
462                                            CallSiteInfoSym &CSI) {
463  AutoIndent Indent(P, 7);
464  P.formatLine("type = {0}, addr = {1}", typeIndex(CSI.Type),
465               formatSegmentOffset(CSI.Segment, CSI.CodeOffset));
466  return Error::success();
467}
468
469Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
470                                            EnvBlockSym &EnvBlock) {
471  AutoIndent Indent(P, 7);
472  for (const auto &Entry : EnvBlock.Fields) {
473    P.formatLine("- {0}", Entry);
474  }
475  return Error::success();
476}
477
478Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FileStaticSym &FS) {
479  P.format(" `{0}`", FS.Name);
480  AutoIndent Indent(P, 7);
481  if (SymGroup) {
482    Expected<StringRef> FileName =
483        SymGroup->getNameFromStringTable(FS.ModFilenameOffset);
484    if (FileName) {
485      P.formatLine("type = {0}, file name = {1} ({2}), flags = {3}",
486                   typeIndex(FS.Index), FS.ModFilenameOffset, *FileName,
487                   formatLocalSymFlags(P.getIndentLevel() + 9, FS.Flags));
488    }
489    return Error::success();
490  }
491
492  P.formatLine("type = {0}, file name offset = {1}, flags = {2}",
493               typeIndex(FS.Index), FS.ModFilenameOffset,
494               formatLocalSymFlags(P.getIndentLevel() + 9, FS.Flags));
495  return Error::success();
496}
497
498Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
499  P.format(" `{0}`", Export.Name);
500  AutoIndent Indent(P, 7);
501  P.formatLine("ordinal = {0}, flags = {1}", Export.Ordinal,
502               formatExportFlags(P.getIndentLevel() + 9, Export.Flags));
503  return Error::success();
504}
505
506Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
507                                            Compile2Sym &Compile2) {
508  AutoIndent Indent(P, 7);
509  SourceLanguage Lang = static_cast<SourceLanguage>(
510      Compile2.Flags & CompileSym2Flags::SourceLanguageMask);
511  CompilationCPU = Compile2.Machine;
512  P.formatLine("machine = {0}, ver = {1}, language = {2}",
513               formatMachineType(Compile2.Machine), Compile2.Version,
514               formatSourceLanguage(Lang));
515  P.formatLine("frontend = {0}.{1}.{2}, backend = {3}.{4}.{5}",
516               Compile2.VersionFrontendMajor, Compile2.VersionFrontendMinor,
517               Compile2.VersionFrontendBuild, Compile2.VersionBackendMajor,
518               Compile2.VersionBackendMinor, Compile2.VersionBackendBuild);
519  P.formatLine("flags = {0}",
520               formatCompileSym2Flags(P.getIndentLevel() + 9, Compile2.Flags));
521  P.formatLine(
522      "extra strings = {0}",
523      typesetStringList(P.getIndentLevel() + 9 + 2, Compile2.ExtraStrings));
524  return Error::success();
525}
526
527Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
528                                            Compile3Sym &Compile3) {
529  AutoIndent Indent(P, 7);
530  SourceLanguage Lang = static_cast<SourceLanguage>(
531      Compile3.Flags & CompileSym3Flags::SourceLanguageMask);
532  CompilationCPU = Compile3.Machine;
533  P.formatLine("machine = {0}, Ver = {1}, language = {2}",
534               formatMachineType(Compile3.Machine), Compile3.Version,
535               formatSourceLanguage(Lang));
536  P.formatLine("frontend = {0}.{1}.{2}.{3}, backend = {4}.{5}.{6}.{7}",
537               Compile3.VersionFrontendMajor, Compile3.VersionFrontendMinor,
538               Compile3.VersionFrontendBuild, Compile3.VersionFrontendQFE,
539               Compile3.VersionBackendMajor, Compile3.VersionBackendMinor,
540               Compile3.VersionBackendBuild, Compile3.VersionBackendQFE);
541  P.formatLine("flags = {0}",
542               formatCompileSym3Flags(P.getIndentLevel() + 9, Compile3.Flags));
543  return Error::success();
544}
545
546Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
547                                            ConstantSym &Constant) {
548  P.format(" `{0}`", Constant.Name);
549  AutoIndent Indent(P, 7);
550  P.formatLine("type = {0}, value = {1}", typeIndex(Constant.Type),
551               Constant.Value.toString(10));
552  return Error::success();
553}
554
555Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
556  P.format(" `{0}`", Data.Name);
557  AutoIndent Indent(P, 7);
558  P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
559               formatSegmentOffset(Data.Segment, Data.DataOffset));
560  return Error::success();
561}
562
563Error MinimalSymbolDumper::visitKnownRecord(
564    CVSymbol &CVR, DefRangeFramePointerRelFullScopeSym &Def) {
565  P.format(" offset = {0}", Def.Offset);
566  return Error::success();
567}
568
569Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
570                                            DefRangeFramePointerRelSym &Def) {
571  AutoIndent Indent(P, 7);
572  P.formatLine("offset = {0}, range = {1}", Def.Hdr.Offset,
573               formatRange(Def.Range));
574  P.formatLine("gaps = {2}", Def.Hdr.Offset,
575               formatGaps(P.getIndentLevel() + 9, Def.Gaps));
576  return Error::success();
577}
578
579Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
580                                            DefRangeRegisterRelSym &Def) {
581  AutoIndent Indent(P, 7);
582  P.formatLine("register = {0}, offset = {1}, offset in parent = {2}, has "
583               "spilled udt = {3}",
584               formatRegisterId(Def.Hdr.Register, CompilationCPU),
585               int32_t(Def.Hdr.BasePointerOffset), Def.offsetInParent(),
586               Def.hasSpilledUDTMember());
587  P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
588               formatGaps(P.getIndentLevel() + 9, Def.Gaps));
589  return Error::success();
590}
591
592Error MinimalSymbolDumper::visitKnownRecord(
593    CVSymbol &CVR, DefRangeRegisterSym &DefRangeRegister) {
594  AutoIndent Indent(P, 7);
595  P.formatLine("register = {0}, may have no name = {1}, range start = "
596               "{2}, length = {3}",
597               formatRegisterId(DefRangeRegister.Hdr.Register, CompilationCPU),
598               bool(DefRangeRegister.Hdr.MayHaveNoName),
599               formatSegmentOffset(DefRangeRegister.Range.ISectStart,
600                                   DefRangeRegister.Range.OffsetStart),
601               DefRangeRegister.Range.Range);
602  P.formatLine("gaps = [{0}]",
603               formatGaps(P.getIndentLevel() + 9, DefRangeRegister.Gaps));
604  return Error::success();
605}
606
607Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
608                                            DefRangeSubfieldRegisterSym &Def) {
609  AutoIndent Indent(P, 7);
610  bool NoName = !!(Def.Hdr.MayHaveNoName == 0);
611  P.formatLine("register = {0}, may have no name = {1}, offset in parent = {2}",
612               formatRegisterId(Def.Hdr.Register, CompilationCPU), NoName,
613               uint32_t(Def.Hdr.OffsetInParent));
614  P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
615               formatGaps(P.getIndentLevel() + 9, Def.Gaps));
616  return Error::success();
617}
618
619Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
620                                            DefRangeSubfieldSym &Def) {
621  AutoIndent Indent(P, 7);
622  P.formatLine("program = {0}, offset in parent = {1}, range = {2}",
623               Def.Program, Def.OffsetInParent, formatRange(Def.Range));
624  P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
625  return Error::success();
626}
627
628Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DefRangeSym &Def) {
629  AutoIndent Indent(P, 7);
630  P.formatLine("program = {0}, range = {1}", Def.Program,
631               formatRange(Def.Range));
632  P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
633  return Error::success();
634}
635
636Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameCookieSym &FC) {
637  AutoIndent Indent(P, 7);
638  P.formatLine("code offset = {0}, Register = {1}, kind = {2}, flags = {3}",
639               FC.CodeOffset, formatRegisterId(FC.Register, CompilationCPU),
640               formatCookieKind(FC.CookieKind), FC.Flags);
641  return Error::success();
642}
643
644Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameProcSym &FP) {
645  AutoIndent Indent(P, 7);
646  P.formatLine("size = {0}, padding size = {1}, offset to padding = {2}",
647               FP.TotalFrameBytes, FP.PaddingFrameBytes, FP.OffsetToPadding);
648  P.formatLine("bytes of callee saved registers = {0}, exception handler addr "
649               "= {1}",
650               FP.BytesOfCalleeSavedRegisters,
651               formatSegmentOffset(FP.SectionIdOfExceptionHandler,
652                                   FP.OffsetOfExceptionHandler));
653  P.formatLine(
654      "local fp reg = {0}, param fp reg = {1}",
655      formatRegisterId(FP.getLocalFramePtrReg(CompilationCPU), CompilationCPU),
656      formatRegisterId(FP.getParamFramePtrReg(CompilationCPU), CompilationCPU));
657  P.formatLine("flags = {0}",
658               formatFrameProcedureOptions(P.getIndentLevel() + 9, FP.Flags));
659  return Error::success();
660}
661
662Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
663                                            HeapAllocationSiteSym &HAS) {
664  AutoIndent Indent(P, 7);
665  P.formatLine("type = {0}, addr = {1} call size = {2}", typeIndex(HAS.Type),
666               formatSegmentOffset(HAS.Segment, HAS.CodeOffset),
667               HAS.CallInstructionSize);
668  return Error::success();
669}
670
671Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, InlineSiteSym &IS) {
672  AutoIndent Indent(P, 7);
673  P.formatLine("inlinee = {0}, parent = {1}, end = {2}", idIndex(IS.Inlinee),
674               IS.Parent, IS.End);
675
676  // Break down the annotation byte code and calculate code and line offsets.
677  // FIXME: It would be helpful if we could look up the initial file and inlinee
678  // lines offset using the inlinee index above.
679  uint32_t CodeOffset = 0;
680  int32_t LineOffset = 0;
681  for (auto &Annot : IS.annotations()) {
682    P.formatLine("  {0}", fmt_align(toHex(Annot.Bytes), AlignStyle::Left, 9));
683
684    auto formatCodeOffset = [&](uint32_t Delta) {
685      CodeOffset += Delta;
686      P.format(" code 0x{0} (+0x{1})", utohexstr(CodeOffset), utohexstr(Delta));
687    };
688    auto formatCodeLength = [&](uint32_t Length) {
689      // Notably, changing the code length does not affect the code offset.
690      P.format(" code end 0x{0} (+0x{1})", utohexstr(CodeOffset + Length),
691               utohexstr(Length));
692    };
693    auto formatLineOffset = [&](int32_t Delta) {
694      LineOffset += Delta;
695      char Sign = Delta > 0 ? '+' : '-';
696      P.format(" line {0} ({1}{2})", LineOffset, Sign, std::abs(Delta));
697    };
698
699    // Use the opcode to interpret the integer values.
700    switch (Annot.OpCode) {
701    case BinaryAnnotationsOpCode::Invalid:
702      break;
703    case BinaryAnnotationsOpCode::CodeOffset:
704    case BinaryAnnotationsOpCode::ChangeCodeOffset:
705      formatCodeOffset(Annot.U1);
706      break;
707    case BinaryAnnotationsOpCode::ChangeLineOffset:
708      formatLineOffset(Annot.S1);
709      break;
710    case BinaryAnnotationsOpCode::ChangeCodeLength:
711      formatCodeLength(Annot.U1);
712      // Apparently this annotation updates the code offset. It's hard to make
713      // MSVC produce this opcode, but clang uses it, and debuggers seem to use
714      // this interpretation.
715      CodeOffset += Annot.U1;
716      break;
717    case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset:
718      formatCodeOffset(Annot.U1);
719      formatLineOffset(Annot.S1);
720      break;
721    case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset:
722      formatCodeOffset(Annot.U2);
723      formatCodeLength(Annot.U1);
724      break;
725
726    case BinaryAnnotationsOpCode::ChangeFile: {
727      uint32_t FileOffset = Annot.U1;
728      StringRef Filename = "<unknown>";
729      if (SymGroup) {
730        if (Expected<StringRef> MaybeFile =
731                SymGroup->getNameFromStringTable(FileOffset))
732          Filename = *MaybeFile;
733        else
734          return MaybeFile.takeError();
735      }
736      P.format(" setfile {0} 0x{1}", utohexstr(FileOffset));
737      break;
738    }
739
740    // The rest of these are hard to convince MSVC to emit, so they are not as
741    // well understood.
742    case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
743      formatCodeOffset(Annot.U1);
744      break;
745    case BinaryAnnotationsOpCode::ChangeLineEndDelta:
746    case BinaryAnnotationsOpCode::ChangeRangeKind:
747    case BinaryAnnotationsOpCode::ChangeColumnStart:
748    case BinaryAnnotationsOpCode::ChangeColumnEnd:
749      P.format(" {0} {1}", Annot.Name, Annot.U1);
750      break;
751    case BinaryAnnotationsOpCode::ChangeColumnEndDelta:
752      P.format(" {0} {1}", Annot.Name, Annot.S1);
753      break;
754    }
755  }
756  return Error::success();
757}
758
759Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
760                                            RegisterSym &Register) {
761  P.format(" `{0}`", Register.Name);
762  AutoIndent Indent(P, 7);
763  P.formatLine("register = {0}, type = {1}",
764               formatRegisterId(Register.Register, CompilationCPU),
765               typeIndex(Register.Index));
766  return Error::success();
767}
768
769Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
770                                            PublicSym32 &Public) {
771  P.format(" `{0}`", Public.Name);
772  AutoIndent Indent(P, 7);
773  P.formatLine("flags = {0}, addr = {1}",
774               formatPublicSymFlags(P.getIndentLevel() + 9, Public.Flags),
775               formatSegmentOffset(Public.Segment, Public.Offset));
776  return Error::success();
777}
778
779Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcRefSym &PR) {
780  P.format(" `{0}`", PR.Name);
781  AutoIndent Indent(P, 7);
782  P.formatLine("module = {0}, sum name = {1}, offset = {2}", PR.Module,
783               PR.SumName, PR.SymOffset);
784  return Error::success();
785}
786
787Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LabelSym &Label) {
788  P.format(" `{0}` (addr = {1})", Label.Name,
789           formatSegmentOffset(Label.Segment, Label.CodeOffset));
790  AutoIndent Indent(P, 7);
791  P.formatLine("flags = {0}",
792               formatProcSymFlags(P.getIndentLevel() + 9, Label.Flags));
793  return Error::success();
794}
795
796Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LocalSym &Local) {
797  P.format(" `{0}`", Local.Name);
798  AutoIndent Indent(P, 7);
799
800  std::string FlagStr =
801      formatLocalSymFlags(P.getIndentLevel() + 9, Local.Flags);
802  P.formatLine("type={0}, flags = {1}", typeIndex(Local.Type), FlagStr);
803  return Error::success();
804}
805
806Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
807                                            ObjNameSym &ObjName) {
808  P.format(" sig={0}, `{1}`", ObjName.Signature, ObjName.Name);
809  return Error::success();
810}
811
812Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcSym &Proc) {
813  P.format(" `{0}`", Proc.Name);
814  AutoIndent Indent(P, 7);
815  P.formatLine("parent = {0}, end = {1}, addr = {2}, code size = {3}",
816               Proc.Parent, Proc.End,
817               formatSegmentOffset(Proc.Segment, Proc.CodeOffset),
818               Proc.CodeSize);
819  bool IsType = true;
820  switch (Proc.getKind()) {
821  case SymbolRecordKind::GlobalProcIdSym:
822  case SymbolRecordKind::ProcIdSym:
823  case SymbolRecordKind::DPCProcIdSym:
824    IsType = false;
825    break;
826  default:
827    break;
828  }
829  P.formatLine("type = `{0}`, debug start = {1}, debug end = {2}, flags = {3}",
830               typeOrIdIndex(Proc.FunctionType, IsType), Proc.DbgStart,
831               Proc.DbgEnd,
832               formatProcSymFlags(P.getIndentLevel() + 9, Proc.Flags));
833  return Error::success();
834}
835
836Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
837                                            ScopeEndSym &ScopeEnd) {
838  return Error::success();
839}
840
841Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CallerSym &Caller) {
842  AutoIndent Indent(P, 7);
843  for (const auto &I : Caller.Indices) {
844    P.formatLine("callee: {0}", idIndex(I));
845  }
846  return Error::success();
847}
848
849Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
850                                            RegRelativeSym &RegRel) {
851  P.format(" `{0}`", RegRel.Name);
852  AutoIndent Indent(P, 7);
853  P.formatLine(
854      "type = {0}, register = {1}, offset = {2}", typeIndex(RegRel.Type),
855      formatRegisterId(RegRel.Register, CompilationCPU), RegRel.Offset);
856  return Error::success();
857}
858
859Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
860                                            ThreadLocalDataSym &Data) {
861  P.format(" `{0}`", Data.Name);
862  AutoIndent Indent(P, 7);
863  P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
864               formatSegmentOffset(Data.Segment, Data.DataOffset));
865  return Error::success();
866}
867
868Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, UDTSym &UDT) {
869  P.format(" `{0}`", UDT.Name);
870  AutoIndent Indent(P, 7);
871  P.formatLine("original type = {0}", UDT.Type);
872  return Error::success();
873}
874
875Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
876                                            UsingNamespaceSym &UN) {
877  P.format(" `{0}`", UN.Name);
878  return Error::success();
879}
880
881Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
882                                            AnnotationSym &Annot) {
883  AutoIndent Indent(P, 7);
884  P.formatLine("addr = {0}", formatSegmentOffset(Annot.Segment, Annot.CodeOffset));
885  P.formatLine("strings = {0}", typesetStringList(P.getIndentLevel() + 9 + 2,
886                                                   Annot.Strings));
887  return Error::success();
888}
889