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