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
24 using namespace llvm;
25 using namespace llvm::codeview;
26 using namespace llvm::pdb;
27
formatLocalSymFlags(uint32_t IndentLevel,LocalSymFlags Flags)28 static 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
formatExportFlags(uint32_t IndentLevel,ExportFlags Flags)48 static 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
formatCompileSym2Flags(uint32_t IndentLevel,CompileSym2Flags Flags)63 static 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
formatCompileSym3Flags(uint32_t IndentLevel,CompileSym3Flags Flags)82 static 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
formatFrameProcedureOptions(uint32_t IndentLevel,FrameProcedureOptions FPO)105 static 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
formatPublicSymFlags(uint32_t IndentLevel,PublicSymFlags Flags)138 static 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
formatProcSymFlags(uint32_t IndentLevel,ProcSymFlags Flags)151 static 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
formatThunkOrdinal(ThunkOrdinal Ordinal)168 static 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
formatTrampolineType(TrampolineType Tramp)181 static 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
formatSourceLanguage(SourceLanguage Lang)189 static 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
formatMachineType(CPUType Cpu)214 static 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
formatCookieKind(FrameCookieKind Kind)280 static 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
formatRegisterId(RegisterId Id,CPUType Cpu)290 static std::string formatRegisterId(RegisterId Id, CPUType Cpu) {
291 if (Cpu == CPUType::ARMNT) {
292 switch (Id) {
293 #define CV_REGISTERS_ARM
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_ARM
298
299 default:
300 break;
301 }
302 } else if (Cpu == CPUType::ARM64) {
303 switch (Id) {
304 #define CV_REGISTERS_ARM64
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_ARM64
309
310 default:
311 break;
312 }
313 } else {
314 switch (Id) {
315 #define CV_REGISTERS_X86
316 #define CV_REGISTER(name, val) RETURN_CASE(RegisterId, name, #name)
317 #include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
318 #undef CV_REGISTER
319 #undef CV_REGISTERS_X86
320
321 default:
322 break;
323 }
324 }
325 return formatUnknownEnum(Id);
326 }
327
formatRegisterId(uint16_t Reg16,CPUType Cpu)328 static std::string formatRegisterId(uint16_t Reg16, CPUType Cpu) {
329 return formatRegisterId(RegisterId(Reg16), Cpu);
330 }
331
formatRegisterId(ulittle16_t & Reg16,CPUType Cpu)332 static std::string formatRegisterId(ulittle16_t &Reg16, CPUType Cpu) {
333 return formatRegisterId(uint16_t(Reg16), Cpu);
334 }
335
formatRange(LocalVariableAddrRange Range)336 static std::string formatRange(LocalVariableAddrRange Range) {
337 return formatv("[{0},+{1})",
338 formatSegmentOffset(Range.ISectStart, Range.OffsetStart),
339 Range.Range)
340 .str();
341 }
342
formatGaps(uint32_t IndentLevel,ArrayRef<LocalVariableAddrGap> Gaps)343 static std::string formatGaps(uint32_t IndentLevel,
344 ArrayRef<LocalVariableAddrGap> Gaps) {
345 std::vector<std::string> GapStrs;
346 for (const auto &G : Gaps) {
347 GapStrs.push_back(formatv("({0},{1})", G.GapStartOffset, G.Range).str());
348 }
349 return typesetItemList(GapStrs, 7, IndentLevel, ", ");
350 }
351
visitSymbolBegin(codeview::CVSymbol & Record)352 Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record) {
353 return visitSymbolBegin(Record, 0);
354 }
355
visitSymbolBegin(codeview::CVSymbol & Record,uint32_t Offset)356 Error MinimalSymbolDumper::visitSymbolBegin(codeview::CVSymbol &Record,
357 uint32_t Offset) {
358 // formatLine puts the newline at the beginning, so we use formatLine here
359 // to start a new line, and then individual visit methods use format to
360 // append to the existing line.
361 P.formatLine("{0} | {1} [size = {2}]",
362 fmt_align(Offset, AlignStyle::Right, 6),
363 formatSymbolKind(Record.kind()), Record.length());
364 P.Indent();
365 return Error::success();
366 }
367
visitSymbolEnd(CVSymbol & Record)368 Error MinimalSymbolDumper::visitSymbolEnd(CVSymbol &Record) {
369 if (RecordBytes) {
370 AutoIndent Indent(P, 7);
371 P.formatBinary("bytes", Record.content(), 0);
372 }
373 P.Unindent();
374 return Error::success();
375 }
376
typeOrIdIndex(codeview::TypeIndex TI,bool IsType) const377 std::string MinimalSymbolDumper::typeOrIdIndex(codeview::TypeIndex TI,
378 bool IsType) const {
379 if (TI.isSimple() || TI.isDecoratedItemId())
380 return formatv("{0}", TI).str();
381 auto &Container = IsType ? Types : Ids;
382 StringRef Name = Container.getTypeName(TI);
383 if (Name.size() > 32) {
384 Name = Name.take_front(32);
385 return std::string(formatv("{0} ({1}...)", TI, Name));
386 } else
387 return std::string(formatv("{0} ({1})", TI, Name));
388 }
389
idIndex(codeview::TypeIndex TI) const390 std::string MinimalSymbolDumper::idIndex(codeview::TypeIndex TI) const {
391 return typeOrIdIndex(TI, false);
392 }
393
typeIndex(TypeIndex TI) const394 std::string MinimalSymbolDumper::typeIndex(TypeIndex TI) const {
395 return typeOrIdIndex(TI, true);
396 }
397
visitKnownRecord(CVSymbol & CVR,BlockSym & Block)398 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, BlockSym &Block) {
399 P.format(" `{0}`", Block.Name);
400 AutoIndent Indent(P, 7);
401 P.formatLine("parent = {0}, end = {1}", Block.Parent, Block.End);
402 P.formatLine("code size = {0}, addr = {1}", Block.CodeSize,
403 formatSegmentOffset(Block.Segment, Block.CodeOffset));
404 return Error::success();
405 }
406
visitKnownRecord(CVSymbol & CVR,Thunk32Sym & Thunk)407 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, Thunk32Sym &Thunk) {
408 P.format(" `{0}`", Thunk.Name);
409 AutoIndent Indent(P, 7);
410 P.formatLine("parent = {0}, end = {1}, next = {2}", Thunk.Parent, Thunk.End,
411 Thunk.Next);
412 P.formatLine("kind = {0}, size = {1}, addr = {2}",
413 formatThunkOrdinal(Thunk.Thunk), Thunk.Length,
414 formatSegmentOffset(Thunk.Segment, Thunk.Offset));
415
416 return Error::success();
417 }
418
visitKnownRecord(CVSymbol & CVR,TrampolineSym & Tramp)419 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
420 TrampolineSym &Tramp) {
421 AutoIndent Indent(P, 7);
422 P.formatLine("type = {0}, size = {1}, source = {2}, target = {3}",
423 formatTrampolineType(Tramp.Type), Tramp.Size,
424 formatSegmentOffset(Tramp.ThunkSection, Tramp.ThunkOffset),
425 formatSegmentOffset(Tramp.TargetSection, Tramp.ThunkOffset));
426
427 return Error::success();
428 }
429
visitKnownRecord(CVSymbol & CVR,SectionSym & Section)430 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
431 SectionSym &Section) {
432 P.format(" `{0}`", Section.Name);
433 AutoIndent Indent(P, 7);
434 P.formatLine("length = {0}, alignment = {1}, rva = {2}, section # = {3}",
435 Section.Length, Section.Alignment, Section.Rva,
436 Section.SectionNumber);
437 P.printLine("characteristics =");
438 AutoIndent Indent2(P, 2);
439 P.printLine(formatSectionCharacteristics(P.getIndentLevel(),
440 Section.Characteristics, 1, "",
441 CharacteristicStyle::Descriptive));
442 return Error::success();
443 }
444
visitKnownRecord(CVSymbol & CVR,CoffGroupSym & CG)445 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CoffGroupSym &CG) {
446 P.format(" `{0}`", CG.Name);
447 AutoIndent Indent(P, 7);
448 P.formatLine("length = {0}, addr = {1}", CG.Size,
449 formatSegmentOffset(CG.Segment, CG.Offset));
450 P.printLine("characteristics =");
451 AutoIndent Indent2(P, 2);
452 P.printLine(formatSectionCharacteristics(P.getIndentLevel(),
453 CG.Characteristics, 1, "",
454 CharacteristicStyle::Descriptive));
455 return Error::success();
456 }
457
visitKnownRecord(CVSymbol & CVR,BPRelativeSym & BPRel)458 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
459 BPRelativeSym &BPRel) {
460 P.format(" `{0}`", BPRel.Name);
461 AutoIndent Indent(P, 7);
462 P.formatLine("type = {0}, offset = {1}", typeIndex(BPRel.Type), BPRel.Offset);
463 return Error::success();
464 }
465
visitKnownRecord(CVSymbol & CVR,BuildInfoSym & BuildInfo)466 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
467 BuildInfoSym &BuildInfo) {
468 P.format(" BuildId = `{0}`", BuildInfo.BuildId);
469 return Error::success();
470 }
471
visitKnownRecord(CVSymbol & CVR,CallSiteInfoSym & CSI)472 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
473 CallSiteInfoSym &CSI) {
474 AutoIndent Indent(P, 7);
475 P.formatLine("type = {0}, addr = {1}", typeIndex(CSI.Type),
476 formatSegmentOffset(CSI.Segment, CSI.CodeOffset));
477 return Error::success();
478 }
479
visitKnownRecord(CVSymbol & CVR,EnvBlockSym & EnvBlock)480 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
481 EnvBlockSym &EnvBlock) {
482 AutoIndent Indent(P, 7);
483 for (const auto &Entry : EnvBlock.Fields) {
484 P.formatLine("- {0}", Entry);
485 }
486 return Error::success();
487 }
488
visitKnownRecord(CVSymbol & CVR,FileStaticSym & FS)489 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FileStaticSym &FS) {
490 P.format(" `{0}`", FS.Name);
491 AutoIndent Indent(P, 7);
492 if (SymGroup) {
493 Expected<StringRef> FileName =
494 SymGroup->getNameFromStringTable(FS.ModFilenameOffset);
495 if (FileName) {
496 P.formatLine("type = {0}, file name = {1} ({2}), flags = {3}",
497 typeIndex(FS.Index), FS.ModFilenameOffset, *FileName,
498 formatLocalSymFlags(P.getIndentLevel() + 9, FS.Flags));
499 }
500 return Error::success();
501 }
502
503 P.formatLine("type = {0}, file name offset = {1}, flags = {2}",
504 typeIndex(FS.Index), FS.ModFilenameOffset,
505 formatLocalSymFlags(P.getIndentLevel() + 9, FS.Flags));
506 return Error::success();
507 }
508
visitKnownRecord(CVSymbol & CVR,ExportSym & Export)509 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
510 P.format(" `{0}`", Export.Name);
511 AutoIndent Indent(P, 7);
512 P.formatLine("ordinal = {0}, flags = {1}", Export.Ordinal,
513 formatExportFlags(P.getIndentLevel() + 9, Export.Flags));
514 return Error::success();
515 }
516
visitKnownRecord(CVSymbol & CVR,Compile2Sym & Compile2)517 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
518 Compile2Sym &Compile2) {
519 AutoIndent Indent(P, 7);
520 SourceLanguage Lang = static_cast<SourceLanguage>(
521 Compile2.Flags & CompileSym2Flags::SourceLanguageMask);
522 CompilationCPU = Compile2.Machine;
523 P.formatLine("machine = {0}, ver = {1}, language = {2}",
524 formatMachineType(Compile2.Machine), Compile2.Version,
525 formatSourceLanguage(Lang));
526 P.formatLine("frontend = {0}.{1}.{2}, backend = {3}.{4}.{5}",
527 Compile2.VersionFrontendMajor, Compile2.VersionFrontendMinor,
528 Compile2.VersionFrontendBuild, Compile2.VersionBackendMajor,
529 Compile2.VersionBackendMinor, Compile2.VersionBackendBuild);
530 P.formatLine("flags = {0}",
531 formatCompileSym2Flags(P.getIndentLevel() + 9, Compile2.Flags));
532 P.formatLine(
533 "extra strings = {0}",
534 typesetStringList(P.getIndentLevel() + 9 + 2, Compile2.ExtraStrings));
535 return Error::success();
536 }
537
visitKnownRecord(CVSymbol & CVR,Compile3Sym & Compile3)538 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
539 Compile3Sym &Compile3) {
540 AutoIndent Indent(P, 7);
541 SourceLanguage Lang = static_cast<SourceLanguage>(
542 Compile3.Flags & CompileSym3Flags::SourceLanguageMask);
543 CompilationCPU = Compile3.Machine;
544 P.formatLine("machine = {0}, Ver = {1}, language = {2}",
545 formatMachineType(Compile3.Machine), Compile3.Version,
546 formatSourceLanguage(Lang));
547 P.formatLine("frontend = {0}.{1}.{2}.{3}, backend = {4}.{5}.{6}.{7}",
548 Compile3.VersionFrontendMajor, Compile3.VersionFrontendMinor,
549 Compile3.VersionFrontendBuild, Compile3.VersionFrontendQFE,
550 Compile3.VersionBackendMajor, Compile3.VersionBackendMinor,
551 Compile3.VersionBackendBuild, Compile3.VersionBackendQFE);
552 P.formatLine("flags = {0}",
553 formatCompileSym3Flags(P.getIndentLevel() + 9, Compile3.Flags));
554 return Error::success();
555 }
556
visitKnownRecord(CVSymbol & CVR,ConstantSym & Constant)557 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
558 ConstantSym &Constant) {
559 P.format(" `{0}`", Constant.Name);
560 AutoIndent Indent(P, 7);
561 P.formatLine("type = {0}, value = {1}", typeIndex(Constant.Type),
562 Constant.Value.toString(10));
563 return Error::success();
564 }
565
visitKnownRecord(CVSymbol & CVR,DataSym & Data)566 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
567 P.format(" `{0}`", Data.Name);
568 AutoIndent Indent(P, 7);
569 P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
570 formatSegmentOffset(Data.Segment, Data.DataOffset));
571 return Error::success();
572 }
573
visitKnownRecord(CVSymbol & CVR,DefRangeFramePointerRelFullScopeSym & Def)574 Error MinimalSymbolDumper::visitKnownRecord(
575 CVSymbol &CVR, DefRangeFramePointerRelFullScopeSym &Def) {
576 P.format(" offset = {0}", Def.Offset);
577 return Error::success();
578 }
579
visitKnownRecord(CVSymbol & CVR,DefRangeFramePointerRelSym & Def)580 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
581 DefRangeFramePointerRelSym &Def) {
582 AutoIndent Indent(P, 7);
583 P.formatLine("offset = {0}, range = {1}", Def.Hdr.Offset,
584 formatRange(Def.Range));
585 P.formatLine("gaps = {2}", Def.Hdr.Offset,
586 formatGaps(P.getIndentLevel() + 9, Def.Gaps));
587 return Error::success();
588 }
589
visitKnownRecord(CVSymbol & CVR,DefRangeRegisterRelSym & Def)590 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
591 DefRangeRegisterRelSym &Def) {
592 AutoIndent Indent(P, 7);
593 P.formatLine("register = {0}, offset = {1}, offset in parent = {2}, has "
594 "spilled udt = {3}",
595 formatRegisterId(Def.Hdr.Register, CompilationCPU),
596 int32_t(Def.Hdr.BasePointerOffset), Def.offsetInParent(),
597 Def.hasSpilledUDTMember());
598 P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
599 formatGaps(P.getIndentLevel() + 9, Def.Gaps));
600 return Error::success();
601 }
602
visitKnownRecord(CVSymbol & CVR,DefRangeRegisterSym & DefRangeRegister)603 Error MinimalSymbolDumper::visitKnownRecord(
604 CVSymbol &CVR, DefRangeRegisterSym &DefRangeRegister) {
605 AutoIndent Indent(P, 7);
606 P.formatLine("register = {0}, may have no name = {1}, range start = "
607 "{2}, length = {3}",
608 formatRegisterId(DefRangeRegister.Hdr.Register, CompilationCPU),
609 bool(DefRangeRegister.Hdr.MayHaveNoName),
610 formatSegmentOffset(DefRangeRegister.Range.ISectStart,
611 DefRangeRegister.Range.OffsetStart),
612 DefRangeRegister.Range.Range);
613 P.formatLine("gaps = [{0}]",
614 formatGaps(P.getIndentLevel() + 9, DefRangeRegister.Gaps));
615 return Error::success();
616 }
617
visitKnownRecord(CVSymbol & CVR,DefRangeSubfieldRegisterSym & Def)618 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
619 DefRangeSubfieldRegisterSym &Def) {
620 AutoIndent Indent(P, 7);
621 bool NoName = !!(Def.Hdr.MayHaveNoName == 0);
622 P.formatLine("register = {0}, may have no name = {1}, offset in parent = {2}",
623 formatRegisterId(Def.Hdr.Register, CompilationCPU), NoName,
624 uint32_t(Def.Hdr.OffsetInParent));
625 P.formatLine("range = {0}, gaps = {1}", formatRange(Def.Range),
626 formatGaps(P.getIndentLevel() + 9, Def.Gaps));
627 return Error::success();
628 }
629
visitKnownRecord(CVSymbol & CVR,DefRangeSubfieldSym & Def)630 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
631 DefRangeSubfieldSym &Def) {
632 AutoIndent Indent(P, 7);
633 P.formatLine("program = {0}, offset in parent = {1}, range = {2}",
634 Def.Program, Def.OffsetInParent, formatRange(Def.Range));
635 P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
636 return Error::success();
637 }
638
visitKnownRecord(CVSymbol & CVR,DefRangeSym & Def)639 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, DefRangeSym &Def) {
640 AutoIndent Indent(P, 7);
641 P.formatLine("program = {0}, range = {1}", Def.Program,
642 formatRange(Def.Range));
643 P.formatLine("gaps = {0}", formatGaps(P.getIndentLevel() + 9, Def.Gaps));
644 return Error::success();
645 }
646
visitKnownRecord(CVSymbol & CVR,FrameCookieSym & FC)647 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameCookieSym &FC) {
648 AutoIndent Indent(P, 7);
649 P.formatLine("code offset = {0}, Register = {1}, kind = {2}, flags = {3}",
650 FC.CodeOffset, formatRegisterId(FC.Register, CompilationCPU),
651 formatCookieKind(FC.CookieKind), FC.Flags);
652 return Error::success();
653 }
654
visitKnownRecord(CVSymbol & CVR,FrameProcSym & FP)655 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameProcSym &FP) {
656 AutoIndent Indent(P, 7);
657 P.formatLine("size = {0}, padding size = {1}, offset to padding = {2}",
658 FP.TotalFrameBytes, FP.PaddingFrameBytes, FP.OffsetToPadding);
659 P.formatLine("bytes of callee saved registers = {0}, exception handler addr "
660 "= {1}",
661 FP.BytesOfCalleeSavedRegisters,
662 formatSegmentOffset(FP.SectionIdOfExceptionHandler,
663 FP.OffsetOfExceptionHandler));
664 P.formatLine(
665 "local fp reg = {0}, param fp reg = {1}",
666 formatRegisterId(FP.getLocalFramePtrReg(CompilationCPU), CompilationCPU),
667 formatRegisterId(FP.getParamFramePtrReg(CompilationCPU), CompilationCPU));
668 P.formatLine("flags = {0}",
669 formatFrameProcedureOptions(P.getIndentLevel() + 9, FP.Flags));
670 return Error::success();
671 }
672
visitKnownRecord(CVSymbol & CVR,HeapAllocationSiteSym & HAS)673 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
674 HeapAllocationSiteSym &HAS) {
675 AutoIndent Indent(P, 7);
676 P.formatLine("type = {0}, addr = {1} call size = {2}", typeIndex(HAS.Type),
677 formatSegmentOffset(HAS.Segment, HAS.CodeOffset),
678 HAS.CallInstructionSize);
679 return Error::success();
680 }
681
visitKnownRecord(CVSymbol & CVR,InlineSiteSym & IS)682 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, InlineSiteSym &IS) {
683 AutoIndent Indent(P, 7);
684 P.formatLine("inlinee = {0}, parent = {1}, end = {2}", idIndex(IS.Inlinee),
685 IS.Parent, IS.End);
686
687 // Break down the annotation byte code and calculate code and line offsets.
688 // FIXME: It would be helpful if we could look up the initial file and inlinee
689 // lines offset using the inlinee index above.
690 uint32_t CodeOffset = 0;
691 int32_t LineOffset = 0;
692 for (auto &Annot : IS.annotations()) {
693 P.formatLine(" {0}", fmt_align(toHex(Annot.Bytes), AlignStyle::Left, 9));
694
695 auto formatCodeOffset = [&](uint32_t Delta) {
696 CodeOffset += Delta;
697 P.format(" code 0x{0} (+0x{1})", utohexstr(CodeOffset), utohexstr(Delta));
698 };
699 auto formatCodeLength = [&](uint32_t Length) {
700 // Notably, changing the code length does not affect the code offset.
701 P.format(" code end 0x{0} (+0x{1})", utohexstr(CodeOffset + Length),
702 utohexstr(Length));
703 };
704 auto formatLineOffset = [&](int32_t Delta) {
705 LineOffset += Delta;
706 char Sign = Delta > 0 ? '+' : '-';
707 P.format(" line {0} ({1}{2})", LineOffset, Sign, std::abs(Delta));
708 };
709
710 // Use the opcode to interpret the integer values.
711 switch (Annot.OpCode) {
712 case BinaryAnnotationsOpCode::Invalid:
713 break;
714 case BinaryAnnotationsOpCode::CodeOffset:
715 case BinaryAnnotationsOpCode::ChangeCodeOffset:
716 formatCodeOffset(Annot.U1);
717 break;
718 case BinaryAnnotationsOpCode::ChangeLineOffset:
719 formatLineOffset(Annot.S1);
720 break;
721 case BinaryAnnotationsOpCode::ChangeCodeLength:
722 formatCodeLength(Annot.U1);
723 // Apparently this annotation updates the code offset. It's hard to make
724 // MSVC produce this opcode, but clang uses it, and debuggers seem to use
725 // this interpretation.
726 CodeOffset += Annot.U1;
727 break;
728 case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset:
729 formatCodeOffset(Annot.U1);
730 formatLineOffset(Annot.S1);
731 break;
732 case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset:
733 formatCodeOffset(Annot.U2);
734 formatCodeLength(Annot.U1);
735 break;
736
737 case BinaryAnnotationsOpCode::ChangeFile: {
738 uint32_t FileOffset = Annot.U1;
739 StringRef Filename = "<unknown>";
740 if (SymGroup) {
741 if (Expected<StringRef> MaybeFile =
742 SymGroup->getNameFromStringTable(FileOffset))
743 Filename = *MaybeFile;
744 else
745 return MaybeFile.takeError();
746 }
747 P.format(" setfile {0} 0x{1}", utohexstr(FileOffset));
748 break;
749 }
750
751 // The rest of these are hard to convince MSVC to emit, so they are not as
752 // well understood.
753 case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
754 formatCodeOffset(Annot.U1);
755 break;
756 case BinaryAnnotationsOpCode::ChangeLineEndDelta:
757 case BinaryAnnotationsOpCode::ChangeRangeKind:
758 case BinaryAnnotationsOpCode::ChangeColumnStart:
759 case BinaryAnnotationsOpCode::ChangeColumnEnd:
760 P.format(" {0} {1}", Annot.Name, Annot.U1);
761 break;
762 case BinaryAnnotationsOpCode::ChangeColumnEndDelta:
763 P.format(" {0} {1}", Annot.Name, Annot.S1);
764 break;
765 }
766 }
767 return Error::success();
768 }
769
visitKnownRecord(CVSymbol & CVR,RegisterSym & Register)770 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
771 RegisterSym &Register) {
772 P.format(" `{0}`", Register.Name);
773 AutoIndent Indent(P, 7);
774 P.formatLine("register = {0}, type = {1}",
775 formatRegisterId(Register.Register, CompilationCPU),
776 typeIndex(Register.Index));
777 return Error::success();
778 }
779
visitKnownRecord(CVSymbol & CVR,PublicSym32 & Public)780 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
781 PublicSym32 &Public) {
782 P.format(" `{0}`", Public.Name);
783 AutoIndent Indent(P, 7);
784 P.formatLine("flags = {0}, addr = {1}",
785 formatPublicSymFlags(P.getIndentLevel() + 9, Public.Flags),
786 formatSegmentOffset(Public.Segment, Public.Offset));
787 return Error::success();
788 }
789
visitKnownRecord(CVSymbol & CVR,ProcRefSym & PR)790 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcRefSym &PR) {
791 P.format(" `{0}`", PR.Name);
792 AutoIndent Indent(P, 7);
793 P.formatLine("module = {0}, sum name = {1}, offset = {2}", PR.Module,
794 PR.SumName, PR.SymOffset);
795 return Error::success();
796 }
797
visitKnownRecord(CVSymbol & CVR,LabelSym & Label)798 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LabelSym &Label) {
799 P.format(" `{0}` (addr = {1})", Label.Name,
800 formatSegmentOffset(Label.Segment, Label.CodeOffset));
801 AutoIndent Indent(P, 7);
802 P.formatLine("flags = {0}",
803 formatProcSymFlags(P.getIndentLevel() + 9, Label.Flags));
804 return Error::success();
805 }
806
visitKnownRecord(CVSymbol & CVR,LocalSym & Local)807 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, LocalSym &Local) {
808 P.format(" `{0}`", Local.Name);
809 AutoIndent Indent(P, 7);
810
811 std::string FlagStr =
812 formatLocalSymFlags(P.getIndentLevel() + 9, Local.Flags);
813 P.formatLine("type={0}, flags = {1}", typeIndex(Local.Type), FlagStr);
814 return Error::success();
815 }
816
visitKnownRecord(CVSymbol & CVR,ObjNameSym & ObjName)817 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
818 ObjNameSym &ObjName) {
819 P.format(" sig={0}, `{1}`", ObjName.Signature, ObjName.Name);
820 return Error::success();
821 }
822
visitKnownRecord(CVSymbol & CVR,ProcSym & Proc)823 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ProcSym &Proc) {
824 P.format(" `{0}`", Proc.Name);
825 AutoIndent Indent(P, 7);
826 P.formatLine("parent = {0}, end = {1}, addr = {2}, code size = {3}",
827 Proc.Parent, Proc.End,
828 formatSegmentOffset(Proc.Segment, Proc.CodeOffset),
829 Proc.CodeSize);
830 bool IsType = true;
831 switch (Proc.getKind()) {
832 case SymbolRecordKind::GlobalProcIdSym:
833 case SymbolRecordKind::ProcIdSym:
834 case SymbolRecordKind::DPCProcIdSym:
835 IsType = false;
836 break;
837 default:
838 break;
839 }
840 P.formatLine("type = `{0}`, debug start = {1}, debug end = {2}, flags = {3}",
841 typeOrIdIndex(Proc.FunctionType, IsType), Proc.DbgStart,
842 Proc.DbgEnd,
843 formatProcSymFlags(P.getIndentLevel() + 9, Proc.Flags));
844 return Error::success();
845 }
846
visitKnownRecord(CVSymbol & CVR,ScopeEndSym & ScopeEnd)847 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
848 ScopeEndSym &ScopeEnd) {
849 return Error::success();
850 }
851
visitKnownRecord(CVSymbol & CVR,CallerSym & Caller)852 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, CallerSym &Caller) {
853 AutoIndent Indent(P, 7);
854 for (const auto &I : Caller.Indices) {
855 P.formatLine("callee: {0}", idIndex(I));
856 }
857 return Error::success();
858 }
859
visitKnownRecord(CVSymbol & CVR,RegRelativeSym & RegRel)860 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
861 RegRelativeSym &RegRel) {
862 P.format(" `{0}`", RegRel.Name);
863 AutoIndent Indent(P, 7);
864 P.formatLine(
865 "type = {0}, register = {1}, offset = {2}", typeIndex(RegRel.Type),
866 formatRegisterId(RegRel.Register, CompilationCPU), RegRel.Offset);
867 return Error::success();
868 }
869
visitKnownRecord(CVSymbol & CVR,ThreadLocalDataSym & Data)870 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
871 ThreadLocalDataSym &Data) {
872 P.format(" `{0}`", Data.Name);
873 AutoIndent Indent(P, 7);
874 P.formatLine("type = {0}, addr = {1}", typeIndex(Data.Type),
875 formatSegmentOffset(Data.Segment, Data.DataOffset));
876 return Error::success();
877 }
878
visitKnownRecord(CVSymbol & CVR,UDTSym & UDT)879 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, UDTSym &UDT) {
880 P.format(" `{0}`", UDT.Name);
881 AutoIndent Indent(P, 7);
882 P.formatLine("original type = {0}", UDT.Type);
883 return Error::success();
884 }
885
visitKnownRecord(CVSymbol & CVR,UsingNamespaceSym & UN)886 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
887 UsingNamespaceSym &UN) {
888 P.format(" `{0}`", UN.Name);
889 return Error::success();
890 }
891
visitKnownRecord(CVSymbol & CVR,AnnotationSym & Annot)892 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
893 AnnotationSym &Annot) {
894 AutoIndent Indent(P, 7);
895 P.formatLine("addr = {0}", formatSegmentOffset(Annot.Segment, Annot.CodeOffset));
896 P.formatLine("strings = {0}", typesetStringList(P.getIndentLevel() + 9 + 2,
897 Annot.Strings));
898 return Error::success();
899 }
900