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 "llvm/ADT/StringExtras.h"
12#include "llvm/DebugInfo/CodeView/CVRecord.h"
13#include "llvm/DebugInfo/CodeView/CodeView.h"
14#include "llvm/DebugInfo/CodeView/Formatters.h"
15#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
16#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
17#include "llvm/DebugInfo/CodeView/TypeRecord.h"
18#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
19#include "llvm/DebugInfo/PDB/Native/InputFile.h"
20#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
21#include "llvm/Object/COFF.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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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, IndentLevel: 4, GroupSize: IndentLevel, Sep: " | ");
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(Value: 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(Value: 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 RETURN_CASE(SourceLanguage, Rust, "rust");
211 RETURN_CASE(SourceLanguage, ObjC, "objc");
212 RETURN_CASE(SourceLanguage, ObjCpp, "objc++");
213 RETURN_CASE(SourceLanguage, AliasObj, "aliasobj");
214 RETURN_CASE(SourceLanguage, Go, "go");
215 RETURN_CASE(SourceLanguage, OldSwift, "swift");
216 }
217 return formatUnknownEnum(Value: Lang);
218}
219
220static std::string formatMachineType(CPUType Cpu) {
221 switch (Cpu) {
222 RETURN_CASE(CPUType, Intel8080, "intel 8080");
223 RETURN_CASE(CPUType, Intel8086, "intel 8086");
224 RETURN_CASE(CPUType, Intel80286, "intel 80286");
225 RETURN_CASE(CPUType, Intel80386, "intel 80386");
226 RETURN_CASE(CPUType, Intel80486, "intel 80486");
227 RETURN_CASE(CPUType, Pentium, "intel pentium");
228 RETURN_CASE(CPUType, PentiumPro, "intel pentium pro");
229 RETURN_CASE(CPUType, Pentium3, "intel pentium 3");
230 RETURN_CASE(CPUType, MIPS, "mips");
231 RETURN_CASE(CPUType, MIPS16, "mips-16");
232 RETURN_CASE(CPUType, MIPS32, "mips-32");
233 RETURN_CASE(CPUType, MIPS64, "mips-64");
234 RETURN_CASE(CPUType, MIPSI, "mips i");
235 RETURN_CASE(CPUType, MIPSII, "mips ii");
236 RETURN_CASE(CPUType, MIPSIII, "mips iii");
237 RETURN_CASE(CPUType, MIPSIV, "mips iv");
238 RETURN_CASE(CPUType, MIPSV, "mips v");
239 RETURN_CASE(CPUType, M68000, "motorola 68000");
240 RETURN_CASE(CPUType, M68010, "motorola 68010");
241 RETURN_CASE(CPUType, M68020, "motorola 68020");
242 RETURN_CASE(CPUType, M68030, "motorola 68030");
243 RETURN_CASE(CPUType, M68040, "motorola 68040");
244 RETURN_CASE(CPUType, Alpha, "alpha");
245 RETURN_CASE(CPUType, Alpha21164, "alpha 21164");
246 RETURN_CASE(CPUType, Alpha21164A, "alpha 21164a");
247 RETURN_CASE(CPUType, Alpha21264, "alpha 21264");
248 RETURN_CASE(CPUType, Alpha21364, "alpha 21364");
249 RETURN_CASE(CPUType, PPC601, "powerpc 601");
250 RETURN_CASE(CPUType, PPC603, "powerpc 603");
251 RETURN_CASE(CPUType, PPC604, "powerpc 604");
252 RETURN_CASE(CPUType, PPC620, "powerpc 620");
253 RETURN_CASE(CPUType, PPCFP, "powerpc fp");
254 RETURN_CASE(CPUType, PPCBE, "powerpc be");
255 RETURN_CASE(CPUType, SH3, "sh3");
256 RETURN_CASE(CPUType, SH3E, "sh3e");
257 RETURN_CASE(CPUType, SH3DSP, "sh3 dsp");
258 RETURN_CASE(CPUType, SH4, "sh4");
259 RETURN_CASE(CPUType, SHMedia, "shmedia");
260 RETURN_CASE(CPUType, ARM3, "arm 3");
261 RETURN_CASE(CPUType, ARM4, "arm 4");
262 RETURN_CASE(CPUType, ARM4T, "arm 4t");
263 RETURN_CASE(CPUType, ARM5, "arm 5");
264 RETURN_CASE(CPUType, ARM5T, "arm 5t");
265 RETURN_CASE(CPUType, ARM6, "arm 6");
266 RETURN_CASE(CPUType, ARM_XMAC, "arm xmac");
267 RETURN_CASE(CPUType, ARM_WMMX, "arm wmmx");
268 RETURN_CASE(CPUType, ARM7, "arm 7");
269 RETURN_CASE(CPUType, ARM64, "arm64");
270 RETURN_CASE(CPUType, ARM64EC, "arm64ec");
271 RETURN_CASE(CPUType, ARM64X, "arm64x");
272 RETURN_CASE(CPUType, HybridX86ARM64, "hybrid x86 arm64");
273 RETURN_CASE(CPUType, Omni, "omni");
274 RETURN_CASE(CPUType, Ia64, "intel itanium ia64");
275 RETURN_CASE(CPUType, Ia64_2, "intel itanium ia64 2");
276 RETURN_CASE(CPUType, CEE, "cee");
277 RETURN_CASE(CPUType, AM33, "am33");
278 RETURN_CASE(CPUType, M32R, "m32r");
279 RETURN_CASE(CPUType, TriCore, "tri-core");
280 RETURN_CASE(CPUType, X64, "intel x86-x64");
281 RETURN_CASE(CPUType, EBC, "ebc");
282 RETURN_CASE(CPUType, Thumb, "thumb");
283 RETURN_CASE(CPUType, ARMNT, "arm nt");
284 RETURN_CASE(CPUType, D3D11_Shader, "d3d11 shader");
285 RETURN_CASE(CPUType, Unknown, "unknown");
286 }
287 return formatUnknownEnum(Value: Cpu);
288}
289
290static std::string formatCookieKind(FrameCookieKind Kind) {
291 switch (Kind) {
292 RETURN_CASE(FrameCookieKind, Copy, "copy");
293 RETURN_CASE(FrameCookieKind, XorStackPointer, "xor stack ptr");
294 RETURN_CASE(FrameCookieKind, XorFramePointer, "xor frame ptr");
295 RETURN_CASE(FrameCookieKind, XorR13, "xor rot13");
296 }
297 return formatUnknownEnum(Value: Kind);
298}
299
300static std::string formatRegisterId(RegisterId Id, CPUType Cpu) {
301 if (Cpu == CPUType::ARMNT) {
302 switch (Id) {
303#define CV_REGISTERS_ARM
304#define CV_REGISTER(name, val) RETURN_CASE(RegisterId, name, #name)
305#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
306#undef CV_REGISTER
307#undef CV_REGISTERS_ARM
308
309 default:
310 break;
311 }
312 } else if (Cpu == CPUType::ARM64) {
313 switch (Id) {
314#define CV_REGISTERS_ARM64
315#define CV_REGISTER(name, val) RETURN_CASE(RegisterId, name, #name)
316#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
317#undef CV_REGISTER
318#undef CV_REGISTERS_ARM64
319
320 default:
321 break;
322 }
323 } else {
324 switch (Id) {
325#define CV_REGISTERS_X86
326#define CV_REGISTER(name, val) RETURN_CASE(RegisterId, name, #name)
327#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
328#undef CV_REGISTER
329#undef CV_REGISTERS_X86
330
331 default:
332 break;
333 }
334 }
335 return formatUnknownEnum(Value: Id);
336}
337
338static std::string formatRegisterId(uint16_t Reg16, CPUType Cpu) {
339 return formatRegisterId(Id: RegisterId(Reg16), Cpu);
340}
341
342static std::string formatRegisterId(ulittle16_t &Reg16, CPUType Cpu) {
343 return formatRegisterId(Reg16: uint16_t(Reg16), Cpu);
344}
345
346static std::string formatRange(LocalVariableAddrRange Range) {
347 return formatv(Fmt: "[{0},+{1})",
348 Vals: formatSegmentOffset(Segment: Range.ISectStart, Offset: Range.OffsetStart),
349 Vals&: Range.Range)
350 .str();
351}
352
353static std::string formatGaps(uint32_t IndentLevel,
354 ArrayRef<LocalVariableAddrGap> Gaps) {
355 std::vector<std::string> GapStrs;
356 for (const auto &G : Gaps) {
357 GapStrs.push_back(x: formatv(Fmt: "({0},{1})", Vals: G.GapStartOffset, Vals: G.Range).str());
358 }
359 return typesetItemList(Opts: GapStrs, IndentLevel: 7, GroupSize: IndentLevel, Sep: ", ");
360}
361
362static std::string formatJumpTableEntrySize(JumpTableEntrySize EntrySize) {
363 switch (EntrySize) {
364 RETURN_CASE(JumpTableEntrySize, Int8, "int8");
365 RETURN_CASE(JumpTableEntrySize, UInt8, "uin8");
366 RETURN_CASE(JumpTableEntrySize, Int16, "int16");
367 RETURN_CASE(JumpTableEntrySize, UInt16, "uint16");
368 RETURN_CASE(JumpTableEntrySize, Int32, "int32");
369 RETURN_CASE(JumpTableEntrySize, UInt32, "uint32");
370 RETURN_CASE(JumpTableEntrySize, Pointer, "pointer");
371 RETURN_CASE(JumpTableEntrySize, UInt8ShiftLeft, "uint8shl");
372 RETURN_CASE(JumpTableEntrySize, UInt16ShiftLeft, "uint16shl");
373 RETURN_CASE(JumpTableEntrySize, Int8ShiftLeft, "int8shl");
374 RETURN_CASE(JumpTableEntrySize, Int16ShiftLeft, "int16shl");
375 }
376 return formatUnknownEnum(Value: EntrySize);
377}
378
379static std::string formatAssociationKind(AssociationKind Kind) {
380 switch (Kind) {
381 RETURN_CASE(AssociationKind, None, "none");
382 RETURN_CASE(AssociationKind, Coroutine, "coroutine");
383 }
384 return formatUnknownEnum(Value: Kind);
385}
386
387Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record) {
388 return visitSymbolBegin(Record, Offset: 0);
389}
390
391Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record,
392 uint32_t Offset) {
393 // formatLine puts the newline at the beginning, so we use formatLine here
394 // to start a new line, and then individual visit methods use format to
395 // append to the existing line.
396 P.formatLine(Fmt: "{0} | {1} [size = {2}]",
397 Items: fmt_align(Item&: Offset, Where: AlignStyle::Right, Amount: 6),
398 Items: formatSymbolKind(K: Record.kind()), Items: Record.length());
399 P.Indent();
400 return Error::success();
401}
402
403Error MinimalSymbolDumper::visitSymbolEnd(CVSymbol &Record) {
404 if (RecordBytes)
405 printSymbolBytes(Record);
406 P.Unindent();
407 return Error::success();
408}
409
410Error MinimalSymbolDumper::visitUnknownSymbol(CVSymbol &Record) {
411 if (!RecordBytes)
412 printSymbolBytes(Record);
413 return Error::success();
414}
415
416void MinimalSymbolDumper::printSymbolBytes(CVSymbol &Record) const {
417 AutoIndent Indent(P, 7);
418 P.formatBinary(Label: "bytes", Data: Record.content(), StartOffset: 0);
419}
420
421std::string MinimalSymbolDumper::typeOrIdIndex(codeview::TypeIndex TI,
422 bool IsType) const {
423 if (TI.isSimple() || TI.isDecoratedItemId())
424 return formatv(Fmt: "{0}", Vals&: TI).str();
425 auto &Container = IsType ? Types : Ids;
426 StringRef Name = Container.getTypeName(Index: TI);
427 if (Name.size() > 32) {
428 Name = Name.take_front(N: 32);
429 return std::string(formatv(Fmt: "{0} ({1}...)", Vals&: TI, Vals&: Name));
430 } else
431 return std::string(formatv(Fmt: "{0} ({1})", Vals&: TI, Vals&: Name));
432}
433
434std::string MinimalSymbolDumper::idIndex(codeview::TypeIndex TI) const {
435 return typeOrIdIndex(TI, IsType: false);
436}
437
438std::string MinimalSymbolDumper::typeIndex(TypeIndex TI) const {
439 return typeOrIdIndex(TI, IsType: true);
440}
441
442Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, BlockSym &Block) {
443 P.format(Fmt: " `{0}`", Items&: Block.Name);
444 AutoIndent Indent(P, 7);
445 P.formatLine(Fmt: "parent = {0}, end = {1}", Items&: Block.Parent, Items&: Block.End);
446 P.formatLine(Fmt: "code size = {0}, addr = {1}", Items&: Block.CodeSize,
447 Items: formatSegmentOffset(Segment: Block.Segment, Offset: Block.CodeOffset));
448 return Error::success();
449}
450
451Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, Thunk32Sym &Thunk) {
452 P.format(Fmt: " `{0}`", Items&: Thunk.Name);
453 AutoIndent Indent(P, 7);
454 P.formatLine(Fmt: "parent = {0}, end = {1}, next = {2}", Items&: Thunk.Parent, Items&: Thunk.End,
455 Items&: Thunk.Next);
456 P.formatLine(Fmt: "kind = {0}, size = {1}, addr = {2}",
457 Items: formatThunkOrdinal(Ordinal: Thunk.Thunk), Items&: Thunk.Length,
458 Items: formatSegmentOffset(Segment: Thunk.Segment, Offset: Thunk.Offset));
459
460 return Error::success();
461}
462
463Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
464 TrampolineSym &Tramp) {
465 AutoIndent Indent(P, 7);
466 P.formatLine(Fmt: "type = {0}, size = {1}, source = {2}, target = {3}",
467 Items: formatTrampolineType(Tramp: Tramp.Type), Items&: Tramp.Size,
468 Items: formatSegmentOffset(Segment: Tramp.ThunkSection, Offset: Tramp.ThunkOffset),
469 Items: formatSegmentOffset(Segment: Tramp.TargetSection, Offset: Tramp.ThunkOffset));
470
471 return Error::success();
472}
473
474Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
475 SectionSym &Section) {
476 P.format(Fmt: " `{0}`", Items&: Section.Name);
477 AutoIndent Indent(P, 7);
478 P.formatLine(Fmt: "length = {0}, alignment = {1}, rva = {2}, section # = {3}",
479 Items&: Section.Length, Items&: Section.Alignment, Items&: Section.Rva,
480 Items&: Section.SectionNumber);
481 P.printLine(T: "characteristics =");
482 AutoIndent Indent2(P, 2);
483 P.printLine(T: formatSectionCharacteristics(IndentLevel: P.getIndentLevel(),
484 C: Section.Characteristics, FlagsPerLine: 1, Separator: "",
485 Style: CharacteristicStyle::Descriptive));
486 return Error::success();
487}
488
489Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CoffGroupSym &CG) {
490 P.format(Fmt: " `{0}`", Items&: CG.Name);
491 AutoIndent Indent(P, 7);
492 P.formatLine(Fmt: "length = {0}, addr = {1}", Items&: CG.Size,
493 Items: formatSegmentOffset(Segment: CG.Segment, Offset: CG.Offset));
494 P.printLine(T: "characteristics =");
495 AutoIndent Indent2(P, 2);
496 P.printLine(T: formatSectionCharacteristics(IndentLevel: P.getIndentLevel(),
497 C: CG.Characteristics, FlagsPerLine: 1, Separator: "",
498 Style: CharacteristicStyle::Descriptive));
499 return Error::success();
500}
501
502Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
503 BPRelativeSym &BPRel) {
504 P.format(Fmt: " `{0}`", Items&: BPRel.Name);
505 AutoIndent Indent(P, 7);
506 P.formatLine(Fmt: "type = {0}, offset = {1}", Items: typeIndex(TI: BPRel.Type), Items&: BPRel.Offset);
507 return Error::success();
508}
509
510Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
511 BuildInfoSym &BuildInfo) {
512 P.format(Fmt: " BuildId = `{0}`", Items&: BuildInfo.BuildId);
513 return Error::success();
514}
515
516Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
517 CallSiteInfoSym &CSI) {
518 AutoIndent Indent(P, 7);
519 P.formatLine(Fmt: "type = {0}, addr = {1}", Items: typeIndex(TI: CSI.Type),
520 Items: formatSegmentOffset(Segment: CSI.Segment, Offset: CSI.CodeOffset));
521 return Error::success();
522}
523
524Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
525 EnvBlockSym &EnvBlock) {
526 AutoIndent Indent(P, 7);
527 for (const auto &Entry : EnvBlock.Fields) {
528 P.formatLine(Fmt: "- {0}", Items: Entry);
529 }
530 return Error::success();
531}
532
533Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FileStaticSym &FS) {
534 P.format(Fmt: " `{0}`", Items&: FS.Name);
535 AutoIndent Indent(P, 7);
536 if (SymGroup) {
537 Expected<StringRef> FileName =
538 SymGroup->getNameFromStringTable(Offset: FS.ModFilenameOffset);
539 if (FileName) {
540 P.formatLine(Fmt: "type = {0}, file name = {1} ({2}), flags = {3}",
541 Items: typeIndex(TI: FS.Index), Items&: FS.ModFilenameOffset, Items&: *FileName,
542 Items: formatLocalSymFlags(IndentLevel: P.getIndentLevel() + 9, Flags: FS.Flags));
543 }
544 return Error::success();
545 }
546
547 P.formatLine(Fmt: "type = {0}, file name offset = {1}, flags = {2}",
548 Items: typeIndex(TI: FS.Index), Items&: FS.ModFilenameOffset,
549 Items: formatLocalSymFlags(IndentLevel: P.getIndentLevel() + 9, Flags: FS.Flags));
550 return Error::success();
551}
552
553Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
554 P.format(Fmt: " `{0}`", Items&: Export.Name);
555 AutoIndent Indent(P, 7);
556 P.formatLine(Fmt: "ordinal = {0}, flags = {1}", Items&: Export.Ordinal,
557 Items: formatExportFlags(IndentLevel: P.getIndentLevel() + 9, Flags: Export.Flags));
558 return Error::success();
559}
560
561Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
562 Compile2Sym &Compile2) {
563 AutoIndent Indent(P, 7);
564 SourceLanguage Lang = static_cast<SourceLanguage>(
565 Compile2.Flags & CompileSym2Flags::SourceLanguageMask);
566 CompilationCPU = Compile2.Machine;
567 P.formatLine(Fmt: "machine = {0}, ver = {1}, language = {2}",
568 Items: formatMachineType(Cpu: Compile2.Machine), Items&: Compile2.Version,
569 Items: formatSourceLanguage(Lang));
570 P.formatLine(Fmt: "frontend = {0}.{1}.{2}, backend = {3}.{4}.{5}",
571 Items&: Compile2.VersionFrontendMajor, Items&: Compile2.VersionFrontendMinor,
572 Items&: Compile2.VersionFrontendBuild, Items&: Compile2.VersionBackendMajor,
573 Items&: Compile2.VersionBackendMinor, Items&: Compile2.VersionBackendBuild);
574 P.formatLine(Fmt: "flags = {0}",
575 Items: formatCompileSym2Flags(IndentLevel: P.getIndentLevel() + 9, Flags: Compile2.Flags));
576 P.formatLine(
577 Fmt: "extra strings = {0}",
578 Items: typesetStringList(IndentLevel: P.getIndentLevel() + 9 + 2, Strings: Compile2.ExtraStrings));
579 return Error::success();
580}
581
582Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
583 Compile3Sym &Compile3) {
584 AutoIndent Indent(P, 7);
585 SourceLanguage Lang = static_cast<SourceLanguage>(
586 Compile3.Flags & CompileSym3Flags::SourceLanguageMask);
587 CompilationCPU = Compile3.Machine;
588 P.formatLine(Fmt: "machine = {0}, Ver = {1}, language = {2}",
589 Items: formatMachineType(Cpu: Compile3.Machine), Items&: Compile3.Version,
590 Items: formatSourceLanguage(Lang));
591 P.formatLine(Fmt: "frontend = {0}.{1}.{2}.{3}, backend = {4}.{5}.{6}.{7}",
592 Items&: Compile3.VersionFrontendMajor, Items&: Compile3.VersionFrontendMinor,
593 Items&: Compile3.VersionFrontendBuild, Items&: Compile3.VersionFrontendQFE,
594 Items&: Compile3.VersionBackendMajor, Items&: Compile3.VersionBackendMinor,
595 Items&: Compile3.VersionBackendBuild, Items&: Compile3.VersionBackendQFE);
596 P.formatLine(Fmt: "flags = {0}",
597 Items: formatCompileSym3Flags(IndentLevel: P.getIndentLevel() + 9, Flags: Compile3.Flags));
598 return Error::success();
599}
600
601Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
602 ConstantSym &Constant) {
603 P.format(Fmt: " `{0}`", Items&: Constant.Name);
604 AutoIndent Indent(P, 7);
605 P.formatLine(Fmt: "type = {0}, value = {1}", Items: typeIndex(TI: Constant.Type),
606 Items: toString(I: Constant.Value, Radix: 10));
607 return Error::success();
608}
609
610Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
611 P.format(Fmt: " `{0}`", Items&: Data.Name);
612 AutoIndent Indent(P, 7);
613 P.formatLine(Fmt: "type = {0}, addr = {1}", Items: typeIndex(TI: Data.Type),
614 Items: formatSegmentOffset(Segment: Data.Segment, Offset: Data.DataOffset));
615 return Error::success();
616}
617
618Error MinimalSymbolDumper::visitKnownRecord(
619 CVSymbol &CVR, DefRangeFramePointerRelFullScopeSym &Def) {
620 P.format(Fmt: " offset = {0}", Items&: Def.Offset);
621 return Error::success();
622}
623
624Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
625 DefRangeFramePointerRelSym &Def) {
626 AutoIndent Indent(P, 7);
627 P.formatLine(Fmt: "offset = {0}, range = {1}", Items&: Def.Hdr.Offset,
628 Items: formatRange(Range: Def.Range));
629 P.formatLine(Fmt: "gaps = [{0}]", Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: Def.Gaps));
630 return Error::success();
631}
632
633Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
634 DefRangeRegisterRelSym &Def) {
635 AutoIndent Indent(P, 7);
636 P.formatLine(Fmt: "register = {0}, offset = {1}, offset in parent = {2}, has "
637 "spilled udt = {3}",
638 Items: formatRegisterId(Reg16&: Def.Hdr.Register, Cpu: CompilationCPU),
639 Items: int32_t(Def.Hdr.BasePointerOffset), Items: Def.offsetInParent(),
640 Items: Def.hasSpilledUDTMember());
641 P.formatLine(Fmt: "range = {0}, gaps = [{1}]", Items: formatRange(Range: Def.Range),
642 Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: Def.Gaps));
643 return Error::success();
644}
645
646Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
647 DefRangeRegisterRelIndirSym &Def) {
648 AutoIndent Indent(P, 7);
649 P.formatLine(Fmt: "register = {0}, offset = {1}, offset in udt = {2}, offset in "
650 "parent = {3}, has "
651 "spilled udt = {4}",
652 Items: formatRegisterId(Reg16&: Def.Hdr.Register, Cpu: CompilationCPU),
653 Items: int32_t(Def.Hdr.BasePointerOffset), Items: int32_t(Def.Hdr.OffsetInUdt),
654 Items: Def.offsetInParent(), Items: Def.hasSpilledUDTMember());
655 P.formatLine(Fmt: "range = {0}, gaps = [{1}]", Items: formatRange(Range: Def.Range),
656 Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: Def.Gaps));
657 return Error::success();
658}
659
660Error MinimalSymbolDumper::visitKnownRecord(
661 CVSymbol &CVR, DefRangeRegisterSym &DefRangeRegister) {
662 AutoIndent Indent(P, 7);
663 P.formatLine(Fmt: "register = {0}, may have no name = {1}, range start = "
664 "{2}, length = {3}",
665 Items: formatRegisterId(Reg16&: DefRangeRegister.Hdr.Register, Cpu: CompilationCPU),
666 Items: bool(DefRangeRegister.Hdr.MayHaveNoName),
667 Items: formatSegmentOffset(Segment: DefRangeRegister.Range.ISectStart,
668 Offset: DefRangeRegister.Range.OffsetStart),
669 Items&: DefRangeRegister.Range.Range);
670 P.formatLine(Fmt: "gaps = [{0}]",
671 Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: DefRangeRegister.Gaps));
672 return Error::success();
673}
674
675Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
676 DefRangeSubfieldRegisterSym &Def) {
677 AutoIndent Indent(P, 7);
678 bool NoName = !!(Def.Hdr.MayHaveNoName == 0);
679 P.formatLine(Fmt: "register = {0}, may have no name = {1}, offset in parent = {2}",
680 Items: formatRegisterId(Reg16&: Def.Hdr.Register, Cpu: CompilationCPU), Items&: NoName,
681 Items: uint32_t(Def.Hdr.OffsetInParent));
682 P.formatLine(Fmt: "range = {0}, gaps = [{1}]", Items: formatRange(Range: Def.Range),
683 Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: Def.Gaps));
684 return Error::success();
685}
686
687Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
688 DefRangeSubfieldSym &Def) {
689 AutoIndent Indent(P, 7);
690 P.formatLine(Fmt: "program = {0}, offset in parent = {1}, range = {2}",
691 Items&: Def.Program, Items&: Def.OffsetInParent, Items: formatRange(Range: Def.Range));
692 P.formatLine(Fmt: "gaps = [{0}]", Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: Def.Gaps));
693 return Error::success();
694}
695
696Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DefRangeSym &Def) {
697 AutoIndent Indent(P, 7);
698 P.formatLine(Fmt: "program = {0}, range = {1}", Items&: Def.Program,
699 Items: formatRange(Range: Def.Range));
700 P.formatLine(Fmt: "gaps = [{0}]", Items: formatGaps(IndentLevel: P.getIndentLevel() + 9, Gaps: Def.Gaps));
701 return Error::success();
702}
703
704Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameCookieSym &FC) {
705 AutoIndent Indent(P, 7);
706 P.formatLine(Fmt: "code offset = {0}, Register = {1}, kind = {2}, flags = {3}",
707 Items&: FC.CodeOffset, Items: formatRegisterId(Reg16: FC.Register, Cpu: CompilationCPU),
708 Items: formatCookieKind(Kind: FC.CookieKind), Items&: FC.Flags);
709 return Error::success();
710}
711
712Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameProcSym &FP) {
713 AutoIndent Indent(P, 7);
714 P.formatLine(Fmt: "size = {0}, padding size = {1}, offset to padding = {2}",
715 Items&: FP.TotalFrameBytes, Items&: FP.PaddingFrameBytes, Items&: FP.OffsetToPadding);
716 P.formatLine(Fmt: "bytes of callee saved registers = {0}, exception handler addr "
717 "= {1}",
718 Items&: FP.BytesOfCalleeSavedRegisters,
719 Items: formatSegmentOffset(Segment: FP.SectionIdOfExceptionHandler,
720 Offset: FP.OffsetOfExceptionHandler));
721 P.formatLine(
722 Fmt: "local fp reg = {0}, param fp reg = {1}",
723 Items: formatRegisterId(Id: FP.getLocalFramePtrReg(CPU: CompilationCPU), Cpu: CompilationCPU),
724 Items: formatRegisterId(Id: FP.getParamFramePtrReg(CPU: CompilationCPU), Cpu: CompilationCPU));
725 P.formatLine(Fmt: "flags = {0}",
726 Items: formatFrameProcedureOptions(IndentLevel: P.getIndentLevel() + 9, FPO: FP.Flags));
727 return Error::success();
728}
729
730Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
731 HeapAllocationSiteSym &HAS) {
732 AutoIndent Indent(P, 7);
733 P.formatLine(Fmt: "type = {0}, addr = {1} call size = {2}", Items: typeIndex(TI: HAS.Type),
734 Items: formatSegmentOffset(Segment: HAS.Segment, Offset: HAS.CodeOffset),
735 Items&: HAS.CallInstructionSize);
736 return Error::success();
737}
738
739Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, InlineSiteSym &IS) {
740 AutoIndent Indent(P, 7);
741 P.formatLine(Fmt: "inlinee = {0}, parent = {1}, end = {2}", Items: idIndex(TI: IS.Inlinee),
742 Items&: IS.Parent, Items&: IS.End);
743
744 // Break down the annotation byte code and calculate code and line offsets.
745 // FIXME: It would be helpful if we could look up the initial file and inlinee
746 // lines offset using the inlinee index above.
747 uint32_t CodeOffset = 0;
748 int32_t LineOffset = 0;
749 for (auto &Annot : IS.annotations()) {
750 P.formatLine(Fmt: " {0}", Items: fmt_align(Item: toHex(Input: Annot.Bytes), Where: AlignStyle::Left, Amount: 9));
751
752 auto formatCodeOffset = [&](uint32_t Delta) {
753 CodeOffset += Delta;
754 P.format(Fmt: " code 0x{0} (+0x{1})", Items: utohexstr(X: CodeOffset), Items: utohexstr(X: Delta));
755 };
756 auto formatCodeLength = [&](uint32_t Length) {
757 // Notably, changing the code length does not affect the code offset.
758 P.format(Fmt: " code end 0x{0} (+0x{1})", Items: utohexstr(X: CodeOffset + Length),
759 Items: utohexstr(X: Length));
760 };
761 auto formatLineOffset = [&](int32_t Delta) {
762 LineOffset += Delta;
763 char Sign = Delta > 0 ? '+' : '-';
764 P.format(Fmt: " line {0} ({1}{2})", Items&: LineOffset, Items&: Sign, Items: std::abs(x: Delta));
765 };
766
767 // Use the opcode to interpret the integer values.
768 switch (Annot.OpCode) {
769 case BinaryAnnotationsOpCode::Invalid:
770 break;
771 case BinaryAnnotationsOpCode::CodeOffset:
772 case BinaryAnnotationsOpCode::ChangeCodeOffset:
773 formatCodeOffset(Annot.U1);
774 break;
775 case BinaryAnnotationsOpCode::ChangeLineOffset:
776 formatLineOffset(Annot.S1);
777 break;
778 case BinaryAnnotationsOpCode::ChangeCodeLength:
779 formatCodeLength(Annot.U1);
780 // Apparently this annotation updates the code offset. It's hard to make
781 // MSVC produce this opcode, but clang uses it, and debuggers seem to use
782 // this interpretation.
783 CodeOffset += Annot.U1;
784 break;
785 case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset:
786 formatCodeOffset(Annot.U1);
787 formatLineOffset(Annot.S1);
788 break;
789 case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset:
790 formatCodeOffset(Annot.U2);
791 formatCodeLength(Annot.U1);
792 break;
793
794 case BinaryAnnotationsOpCode::ChangeFile: {
795 uint32_t FileOffset = Annot.U1;
796 StringRef Filename = "<unknown>";
797 if (SymGroup) {
798 if (Expected<StringRef> MaybeFile =
799 SymGroup->getNameFromStringTable(Offset: FileOffset))
800 Filename = *MaybeFile;
801 else
802 return MaybeFile.takeError();
803 }
804 P.format(Fmt: " setfile {0} 0x{1}", Items&: Filename, Items: utohexstr(X: FileOffset));
805 break;
806 }
807
808 // The rest of these are hard to convince MSVC to emit, so they are not as
809 // well understood.
810 case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
811 formatCodeOffset(Annot.U1);
812 break;
813 case BinaryAnnotationsOpCode::ChangeLineEndDelta:
814 case BinaryAnnotationsOpCode::ChangeRangeKind:
815 case BinaryAnnotationsOpCode::ChangeColumnStart:
816 case BinaryAnnotationsOpCode::ChangeColumnEnd:
817 P.format(Fmt: " {0} {1}", Items: Annot.Name, Items: Annot.U1);
818 break;
819 case BinaryAnnotationsOpCode::ChangeColumnEndDelta:
820 P.format(Fmt: " {0} {1}", Items: Annot.Name, Items: Annot.S1);
821 break;
822 }
823 }
824 return Error::success();
825}
826
827Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
828 RegisterSym &Register) {
829 P.format(Fmt: " `{0}`", Items&: Register.Name);
830 AutoIndent Indent(P, 7);
831 P.formatLine(Fmt: "register = {0}, type = {1}",
832 Items: formatRegisterId(Id: Register.Register, Cpu: CompilationCPU),
833 Items: typeIndex(TI: Register.Index));
834 return Error::success();
835}
836
837Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
838 PublicSym32 &Public) {
839 P.format(Fmt: " `{0}`", Items&: Public.Name);
840 AutoIndent Indent(P, 7);
841 P.formatLine(Fmt: "flags = {0}, addr = {1}",
842 Items: formatPublicSymFlags(IndentLevel: P.getIndentLevel() + 9, Flags: Public.Flags),
843 Items: formatSegmentOffset(Segment: Public.Segment, Offset: Public.Offset));
844 return Error::success();
845}
846
847Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcRefSym &PR) {
848 P.format(Fmt: " `{0}`", Items&: PR.Name);
849 AutoIndent Indent(P, 7);
850 P.formatLine(Fmt: "module = {0}, sum name = {1}, offset = {2}", Items&: PR.Module,
851 Items&: PR.SumName, Items&: PR.SymOffset);
852 return Error::success();
853}
854
855Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LabelSym &Label) {
856 P.format(Fmt: " `{0}` (addr = {1})", Items&: Label.Name,
857 Items: formatSegmentOffset(Segment: Label.Segment, Offset: Label.CodeOffset));
858 AutoIndent Indent(P, 7);
859 P.formatLine(Fmt: "flags = {0}",
860 Items: formatProcSymFlags(IndentLevel: P.getIndentLevel() + 9, Flags: Label.Flags));
861 return Error::success();
862}
863
864Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LocalSym &Local) {
865 P.format(Fmt: " `{0}`", Items&: Local.Name);
866 AutoIndent Indent(P, 7);
867
868 std::string FlagStr =
869 formatLocalSymFlags(IndentLevel: P.getIndentLevel() + 9, Flags: Local.Flags);
870 P.formatLine(Fmt: "type={0}, flags = {1}", Items: typeIndex(TI: Local.Type), Items&: FlagStr);
871 return Error::success();
872}
873
874Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
875 ObjNameSym &ObjName) {
876 P.format(Fmt: " sig={0}, `{1}`", Items&: ObjName.Signature, Items&: ObjName.Name);
877 return Error::success();
878}
879
880Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcSym &Proc) {
881 P.format(Fmt: " `{0}`", Items&: Proc.Name);
882 AutoIndent Indent(P, 7);
883 P.formatLine(Fmt: "parent = {0}, end = {1}, addr = {2}, code size = {3}",
884 Items&: Proc.Parent, Items&: Proc.End,
885 Items: formatSegmentOffset(Segment: Proc.Segment, Offset: Proc.CodeOffset),
886 Items&: Proc.CodeSize);
887 bool IsType = true;
888 switch (Proc.getKind()) {
889 case SymbolRecordKind::GlobalProcIdSym:
890 case SymbolRecordKind::ProcIdSym:
891 case SymbolRecordKind::DPCProcIdSym:
892 IsType = false;
893 break;
894 default:
895 break;
896 }
897 P.formatLine(Fmt: "type = `{0}`, debug start = {1}, debug end = {2}, flags = {3}",
898 Items: typeOrIdIndex(TI: Proc.FunctionType, IsType), Items&: Proc.DbgStart,
899 Items&: Proc.DbgEnd,
900 Items: formatProcSymFlags(IndentLevel: P.getIndentLevel() + 9, Flags: Proc.Flags));
901 return Error::success();
902}
903
904Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
905 ScopeEndSym &ScopeEnd) {
906 return Error::success();
907}
908
909Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CallerSym &Caller) {
910 const char *Format;
911 switch (CVR.kind()) {
912 case S_CALLEES:
913 Format = "callee: {0}";
914 break;
915 case S_CALLERS:
916 Format = "caller: {0}";
917 break;
918 case S_INLINEES:
919 Format = "inlinee: {0}";
920 break;
921 default:
922 return llvm::make_error<CodeViewError>(
923 Args: "Unknown CV Record type for a CallerSym object!");
924 }
925 AutoIndent Indent(P, 7);
926 for (const auto &I : Caller.Indices) {
927 P.formatLine(Fmt: Format, Items: idIndex(TI: I));
928 }
929 return Error::success();
930}
931
932Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
933 RegRelativeSym &RegRel) {
934 P.format(Fmt: " `{0}`", Items&: RegRel.Name);
935 AutoIndent Indent(P, 7);
936 P.formatLine(
937 Fmt: "type = {0}, register = {1}, offset = {2}", Items: typeIndex(TI: RegRel.Type),
938 Items: formatRegisterId(Id: RegRel.Register, Cpu: CompilationCPU), Items&: RegRel.Offset);
939 return Error::success();
940}
941
942Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
943 RegRelativeIndirSym &RegRelIndir) {
944 P.format(Fmt: " `{0}`", Items&: RegRelIndir.Name);
945 AutoIndent Indent(P, 7);
946 P.formatLine(Fmt: "type = {0}, register = {1}, offset = {2}, offset-in-udt = {3}",
947 Items: typeIndex(TI: RegRelIndir.Type),
948 Items: formatRegisterId(Id: RegRelIndir.Register, Cpu: CompilationCPU),
949 Items&: RegRelIndir.Offset, Items&: RegRelIndir.OffsetInUdt);
950 return Error::success();
951}
952
953Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
954 ThreadLocalDataSym &Data) {
955 P.format(Fmt: " `{0}`", Items&: Data.Name);
956 AutoIndent Indent(P, 7);
957 P.formatLine(Fmt: "type = {0}, addr = {1}", Items: typeIndex(TI: Data.Type),
958 Items: formatSegmentOffset(Segment: Data.Segment, Offset: Data.DataOffset));
959 return Error::success();
960}
961
962Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, UDTSym &UDT) {
963 P.format(Fmt: " `{0}`", Items&: UDT.Name);
964 AutoIndent Indent(P, 7);
965 P.formatLine(Fmt: "original type = {0}", Items&: UDT.Type);
966 return Error::success();
967}
968
969Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
970 UsingNamespaceSym &UN) {
971 P.format(Fmt: " `{0}`", Items&: UN.Name);
972 return Error::success();
973}
974
975Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
976 AnnotationSym &Annot) {
977 AutoIndent Indent(P, 7);
978 P.formatLine(Fmt: "addr = {0}", Items: formatSegmentOffset(Segment: Annot.Segment, Offset: Annot.CodeOffset));
979 P.formatLine(Fmt: "strings = {0}", Items: typesetStringList(IndentLevel: P.getIndentLevel() + 9 + 2,
980 Strings: Annot.Strings));
981 return Error::success();
982}
983
984Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
985 JumpTableSym &JumpTable) {
986 AutoIndent Indent(P, 7);
987 P.formatLine(
988 Fmt: "base = {0}, switchtype = {1}, branch = {2}, table = {3}, entriescount = "
989 "{4}",
990 Items: formatSegmentOffset(Segment: JumpTable.BaseSegment, Offset: JumpTable.BaseOffset),
991 Items: formatJumpTableEntrySize(EntrySize: JumpTable.SwitchType),
992 Items: formatSegmentOffset(Segment: JumpTable.BranchSegment, Offset: JumpTable.BranchOffset),
993 Items: formatSegmentOffset(Segment: JumpTable.TableSegment, Offset: JumpTable.TableOffset),
994 Items&: JumpTable.EntriesCount);
995 return Error::success();
996}
997
998Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
999 HotPatchFuncSym &JumpTable) {
1000 AutoIndent Indent(P, 7);
1001 P.formatLine(Fmt: "function = {0}, name = {1}", Items: typeIndex(TI: JumpTable.Function),
1002 Items&: JumpTable.Name);
1003 return Error::success();
1004}
1005
1006Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
1007 AssociationSym &Assoc) {
1008 AutoIndent Indent(P, 7);
1009 P.formatLine(Fmt: "kind = {0}, addr = {1}", Items: formatAssociationKind(Kind: Assoc.AssocKind),
1010 Items: formatSegmentOffset(Segment: Assoc.Segment, Offset: Assoc.CodeOffset));
1011 return Error::success();
1012}
1013