blob: 431bf404fb04016e943bc4cfb970277775bc5133 [file] [log] [blame]
Zachary Turner3b147642016-10-08 01:12:01 +00001//===- YamlSymbolDumper.cpp ----------------------------------- *- C++ --*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "YamlSymbolDumper.h"
11#include "PdbYaml.h"
12#include "YamlTypeDumper.h"
13
14#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
15#include "llvm/DebugInfo/CodeView/EnumTables.h"
16#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
17#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
18#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
19
20using namespace llvm;
21using namespace llvm::codeview;
22using namespace llvm::codeview::yaml;
23
24LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
25LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
26LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
27LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
28LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
29LLVM_YAML_IS_SEQUENCE_VECTOR(CVType)
30LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbTpiFieldListRecord)
31
32namespace llvm {
33namespace yaml {
34void ScalarEnumerationTraits<SymbolKind>::enumeration(IO &io,
35 SymbolKind &Value) {
36 auto SymbolNames = getSymbolTypeNames();
37 for (const auto &E : SymbolNames)
38 io.enumCase(Value, E.Name.str().c_str(), E.Value);
39}
40
Zachary Turner46225b12016-12-16 22:48:14 +000041template <> struct ScalarBitSetTraits<CompileSym2Flags> {
42 static void bitset(IO &io, CompileSym2Flags &Flags) {
43 auto FlagNames = getCompileSym2FlagNames();
44 for (const auto &E : FlagNames) {
45 io.bitSetCase(Flags, E.Name.str().c_str(),
46 static_cast<CompileSym2Flags>(E.Value));
47 }
48 }
49};
50
51template <> struct ScalarBitSetTraits<CompileSym3Flags> {
52 static void bitset(IO &io, CompileSym3Flags &Flags) {
53 auto FlagNames = getCompileSym3FlagNames();
54 for (const auto &E : FlagNames) {
55 io.bitSetCase(Flags, E.Name.str().c_str(),
56 static_cast<CompileSym3Flags>(E.Value));
57 }
58 }
59};
60
61template <> struct ScalarBitSetTraits<ExportFlags> {
62 static void bitset(IO &io, ExportFlags &Flags) {
63 auto FlagNames = getExportSymFlagNames();
64 for (const auto &E : FlagNames) {
65 io.bitSetCase(Flags, E.Name.str().c_str(),
66 static_cast<ExportFlags>(E.Value));
67 }
68 }
69};
70
71template <> struct ScalarBitSetTraits<LocalSymFlags> {
72 static void bitset(IO &io, LocalSymFlags &Flags) {
73 auto FlagNames = getLocalFlagNames();
74 for (const auto &E : FlagNames) {
75 io.bitSetCase(Flags, E.Name.str().c_str(),
76 static_cast<LocalSymFlags>(E.Value));
77 }
78 }
79};
80
81template <> struct ScalarBitSetTraits<ProcSymFlags> {
82 static void bitset(IO &io, ProcSymFlags &Flags) {
83 auto FlagNames = getProcSymFlagNames();
84 for (const auto &E : FlagNames) {
85 io.bitSetCase(Flags, E.Name.str().c_str(),
86 static_cast<ProcSymFlags>(E.Value));
87 }
88 }
89};
90
91template <> struct ScalarBitSetTraits<FrameProcedureOptions> {
92 static void bitset(IO &io, FrameProcedureOptions &Flags) {
93 auto FlagNames = getFrameProcSymFlagNames();
94 for (const auto &E : FlagNames) {
95 io.bitSetCase(Flags, E.Name.str().c_str(),
96 static_cast<FrameProcedureOptions>(E.Value));
97 }
98 }
99};
100
101template <> struct ScalarEnumerationTraits<CPUType> {
102 static void enumeration(IO &io, CPUType &Cpu) {
103 auto CpuNames = getCPUTypeNames();
104 for (const auto &E : CpuNames) {
105 io.enumCase(Cpu, E.Name.str().c_str(), static_cast<CPUType>(E.Value));
106 }
107 }
108};
109
110template <> struct ScalarEnumerationTraits<RegisterId> {
111 static void enumeration(IO &io, RegisterId &Reg) {
112 auto RegNames = getRegisterNames();
113 for (const auto &E : RegNames) {
114 io.enumCase(Reg, E.Name.str().c_str(), static_cast<RegisterId>(E.Value));
115 }
Zachary Turner407dec52017-03-13 14:57:45 +0000116 io.enumFallback<Hex16>(Reg);
Zachary Turner46225b12016-12-16 22:48:14 +0000117 }
118};
119
120template <> struct ScalarEnumerationTraits<TrampolineType> {
121 static void enumeration(IO &io, TrampolineType &Tramp) {
122 auto TrampNames = getTrampolineNames();
123 for (const auto &E : TrampNames) {
124 io.enumCase(Tramp, E.Name.str().c_str(),
125 static_cast<TrampolineType>(E.Value));
126 }
127 }
128};
129
Zachary Turner3b147642016-10-08 01:12:01 +0000130template <> struct ScalarEnumerationTraits<ThunkOrdinal> {
Zachary Turner46225b12016-12-16 22:48:14 +0000131 static void enumeration(IO &io, ThunkOrdinal &Ord) {
132 auto ThunkNames = getThunkOrdinalNames();
133 for (const auto &E : ThunkNames) {
134 io.enumCase(Ord, E.Name.str().c_str(),
135 static_cast<ThunkOrdinal>(E.Value));
136 }
137 }
Zachary Turner3b147642016-10-08 01:12:01 +0000138};
139
140void MappingTraits<ScopeEndSym>::mapping(IO &IO, ScopeEndSym &Obj) {}
141
142void MappingTraits<Thunk32Sym>::mapping(IO &IO, Thunk32Sym &Thunk) {
Zachary Turner46225b12016-12-16 22:48:14 +0000143 IO.mapRequired("Parent", Thunk.Parent);
144 IO.mapRequired("End", Thunk.End);
145 IO.mapRequired("Next", Thunk.Next);
146 IO.mapRequired("Off", Thunk.Offset);
147 IO.mapRequired("Seg", Thunk.Segment);
148 IO.mapRequired("Len", Thunk.Length);
149 IO.mapRequired("Ordinal", Thunk.Thunk);
Zachary Turner3b147642016-10-08 01:12:01 +0000150}
151
152void MappingTraits<TrampolineSym>::mapping(IO &IO, TrampolineSym &Tramp) {
Zachary Turner46225b12016-12-16 22:48:14 +0000153 IO.mapRequired("Type", Tramp.Type);
154 IO.mapRequired("Size", Tramp.Size);
155 IO.mapRequired("ThunkOff", Tramp.ThunkOffset);
156 IO.mapRequired("TargetOff", Tramp.TargetOffset);
157 IO.mapRequired("ThunkSection", Tramp.ThunkSection);
158 IO.mapRequired("TargetSection", Tramp.TargetSection);
Zachary Turner3b147642016-10-08 01:12:01 +0000159}
160
161void MappingTraits<SectionSym>::mapping(IO &IO, SectionSym &Section) {
Zachary Turner46225b12016-12-16 22:48:14 +0000162 IO.mapRequired("SectionNumber", Section.SectionNumber);
163 IO.mapRequired("Alignment", Section.Alignment);
164 IO.mapRequired("Rva", Section.Rva);
165 IO.mapRequired("Length", Section.Length);
166 IO.mapRequired("Characteristics", Section.Characteristics);
Zachary Turner3b147642016-10-08 01:12:01 +0000167 IO.mapRequired("Name", Section.Name);
168}
169
170void MappingTraits<CoffGroupSym>::mapping(IO &IO, CoffGroupSym &CoffGroup) {
Zachary Turner46225b12016-12-16 22:48:14 +0000171 IO.mapRequired("Size", CoffGroup.Size);
172 IO.mapRequired("Characteristics", CoffGroup.Characteristics);
173 IO.mapRequired("Offset", CoffGroup.Offset);
174 IO.mapRequired("Segment", CoffGroup.Segment);
Zachary Turner3b147642016-10-08 01:12:01 +0000175 IO.mapRequired("Name", CoffGroup.Name);
176}
177
178void MappingTraits<ExportSym>::mapping(IO &IO, ExportSym &Export) {
Zachary Turner46225b12016-12-16 22:48:14 +0000179 IO.mapRequired("Ordinal", Export.Ordinal);
180 IO.mapRequired("Flags", Export.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000181 IO.mapRequired("Name", Export.Name);
182}
183
184void MappingTraits<ProcSym>::mapping(IO &IO, ProcSym &Proc) {
185 // TODO: Print the linkage name
186
Zachary Turner46225b12016-12-16 22:48:14 +0000187 IO.mapRequired("PtrParent", Proc.Parent);
188 IO.mapRequired("PtrEnd", Proc.End);
189 IO.mapRequired("PtrNext", Proc.Next);
190 IO.mapRequired("CodeSize", Proc.CodeSize);
191 IO.mapRequired("DbgStart", Proc.DbgStart);
192 IO.mapRequired("DbgEnd", Proc.DbgEnd);
193 IO.mapRequired("FunctionType", Proc.FunctionType);
194 IO.mapRequired("Segment", Proc.Segment);
195 IO.mapRequired("Flags", Proc.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000196 IO.mapRequired("DisplayName", Proc.Name);
197}
198
199void MappingTraits<RegisterSym>::mapping(IO &IO, RegisterSym &Register) {
Zachary Turner46225b12016-12-16 22:48:14 +0000200 IO.mapRequired("Type", Register.Index);
201 IO.mapRequired("Seg", Register.Register);
Zachary Turner3b147642016-10-08 01:12:01 +0000202 IO.mapRequired("Name", Register.Name);
203}
204
205void MappingTraits<PublicSym32>::mapping(IO &IO, PublicSym32 &Public) {
Zachary Turner46225b12016-12-16 22:48:14 +0000206 IO.mapRequired("Type", Public.Index);
207 IO.mapRequired("Seg", Public.Segment);
208 IO.mapRequired("Off", Public.Offset);
Zachary Turner3b147642016-10-08 01:12:01 +0000209 IO.mapRequired("Name", Public.Name);
210}
211
212void MappingTraits<ProcRefSym>::mapping(IO &IO, ProcRefSym &ProcRef) {
Zachary Turner46225b12016-12-16 22:48:14 +0000213 IO.mapRequired("SumName", ProcRef.SumName);
214 IO.mapRequired("SymOffset", ProcRef.SymOffset);
215 IO.mapRequired("Mod", ProcRef.Module);
Zachary Turner3b147642016-10-08 01:12:01 +0000216 IO.mapRequired("Name", ProcRef.Name);
217}
218
219void MappingTraits<EnvBlockSym>::mapping(IO &IO, EnvBlockSym &EnvBlock) {
Zachary Turner3b147642016-10-08 01:12:01 +0000220 IO.mapRequired("Entries", EnvBlock.Fields);
221}
222
223void MappingTraits<InlineSiteSym>::mapping(IO &IO, InlineSiteSym &InlineSite) {
Zachary Turner46225b12016-12-16 22:48:14 +0000224 IO.mapRequired("PtrParent", InlineSite.Parent);
225 IO.mapRequired("PtrEnd", InlineSite.End);
226 IO.mapRequired("Inlinee", InlineSite.Inlinee);
Zachary Turner3b147642016-10-08 01:12:01 +0000227 // TODO: The binary annotations
228}
229
230void MappingTraits<LocalSym>::mapping(IO &IO, LocalSym &Local) {
Zachary Turner46225b12016-12-16 22:48:14 +0000231 IO.mapRequired("Type", Local.Type);
232 IO.mapRequired("Flags", Local.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000233 IO.mapRequired("VarName", Local.Name);
234}
235
236void MappingTraits<DefRangeSym>::mapping(IO &IO, DefRangeSym &Obj) {
237 // TODO: Print the subfields
238}
239
240void MappingTraits<DefRangeSubfieldSym>::mapping(IO &IO,
241 DefRangeSubfieldSym &Obj) {
242 // TODO: Print the subfields
243}
244
245void MappingTraits<DefRangeRegisterSym>::mapping(IO &IO,
246 DefRangeRegisterSym &Obj) {
247 // TODO: Print the subfields
248}
249
250void MappingTraits<DefRangeFramePointerRelSym>::mapping(
251 IO &IO, DefRangeFramePointerRelSym &Obj) {
252 // TODO: Print the subfields
253}
254
255void MappingTraits<DefRangeSubfieldRegisterSym>::mapping(
256 IO &IO, DefRangeSubfieldRegisterSym &Obj) {
257 // TODO: Print the subfields
258}
259
260void MappingTraits<DefRangeFramePointerRelFullScopeSym>::mapping(
261 IO &IO, DefRangeFramePointerRelFullScopeSym &Obj) {
262 // TODO: Print the subfields
263}
264
265void MappingTraits<DefRangeRegisterRelSym>::mapping(
266 IO &IO, DefRangeRegisterRelSym &Obj) {
267 // TODO: Print the subfields
268}
269
270void MappingTraits<BlockSym>::mapping(IO &IO, BlockSym &Block) {
271 // TODO: Print the linkage name
Zachary Turner46225b12016-12-16 22:48:14 +0000272 IO.mapRequired("PtrParent", Block.Parent);
273 IO.mapRequired("PtrEnd", Block.End);
274 IO.mapRequired("CodeSize", Block.CodeSize);
275 IO.mapRequired("Segment", Block.Segment);
Zachary Turner3b147642016-10-08 01:12:01 +0000276 IO.mapRequired("BlockName", Block.Name);
277}
278
279void MappingTraits<LabelSym>::mapping(IO &IO, LabelSym &Label) {
280 // TODO: Print the linkage name
Zachary Turner46225b12016-12-16 22:48:14 +0000281 IO.mapRequired("Segment", Label.Segment);
282 IO.mapRequired("Flags", Label.Flags);
283 IO.mapRequired("Flags", Label.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000284 IO.mapRequired("DisplayName", Label.Name);
285}
286
287void MappingTraits<ObjNameSym>::mapping(IO &IO, ObjNameSym &ObjName) {
Zachary Turner46225b12016-12-16 22:48:14 +0000288 IO.mapRequired("Signature", ObjName.Signature);
Zachary Turner3b147642016-10-08 01:12:01 +0000289 IO.mapRequired("ObjectName", ObjName.Name);
290}
291
292void MappingTraits<Compile2Sym>::mapping(IO &IO, Compile2Sym &Compile2) {
Zachary Turner46225b12016-12-16 22:48:14 +0000293 IO.mapRequired("Flags", Compile2.Flags);
294 IO.mapRequired("Machine", Compile2.Machine);
295 IO.mapRequired("FrontendMajor", Compile2.VersionFrontendMajor);
296 IO.mapRequired("FrontendMinor", Compile2.VersionFrontendMinor);
297 IO.mapRequired("FrontendBuild", Compile2.VersionFrontendBuild);
298 IO.mapRequired("BackendMajor", Compile2.VersionBackendMajor);
299 IO.mapRequired("BackendMinor", Compile2.VersionBackendMinor);
300 IO.mapRequired("BackendBuild", Compile2.VersionBackendBuild);
Zachary Turner3b147642016-10-08 01:12:01 +0000301 IO.mapRequired("Version", Compile2.Version);
302}
303
304void MappingTraits<Compile3Sym>::mapping(IO &IO, Compile3Sym &Compile3) {
Zachary Turner46225b12016-12-16 22:48:14 +0000305 IO.mapRequired("Flags", Compile3.Flags);
306 IO.mapRequired("Machine", Compile3.Machine);
307 IO.mapRequired("FrontendMajor", Compile3.VersionFrontendMajor);
308 IO.mapRequired("FrontendMinor", Compile3.VersionFrontendMinor);
309 IO.mapRequired("FrontendBuild", Compile3.VersionFrontendBuild);
310 IO.mapRequired("FrontendQFE", Compile3.VersionFrontendQFE);
311 IO.mapRequired("BackendMajor", Compile3.VersionBackendMajor);
312 IO.mapRequired("BackendMinor", Compile3.VersionBackendMinor);
313 IO.mapRequired("BackendBuild", Compile3.VersionBackendBuild);
314 IO.mapRequired("BackendQFE", Compile3.VersionBackendQFE);
Zachary Turner3b147642016-10-08 01:12:01 +0000315 IO.mapRequired("Version", Compile3.Version);
316}
317
318void MappingTraits<FrameProcSym>::mapping(IO &IO, FrameProcSym &FrameProc) {
Zachary Turner46225b12016-12-16 22:48:14 +0000319 IO.mapRequired("TotalFrameBytes", FrameProc.TotalFrameBytes);
320 IO.mapRequired("PaddingFrameBytes", FrameProc.PaddingFrameBytes);
321 IO.mapRequired("OffsetToPadding", FrameProc.OffsetToPadding);
Zachary Turner3b147642016-10-08 01:12:01 +0000322 IO.mapRequired("BytesOfCalleeSavedRegisters",
Zachary Turner46225b12016-12-16 22:48:14 +0000323 FrameProc.BytesOfCalleeSavedRegisters);
Zachary Turner3b147642016-10-08 01:12:01 +0000324 IO.mapRequired("OffsetOfExceptionHandler",
Zachary Turner46225b12016-12-16 22:48:14 +0000325 FrameProc.OffsetOfExceptionHandler);
Zachary Turner3b147642016-10-08 01:12:01 +0000326 IO.mapRequired("SectionIdOfExceptionHandler",
Zachary Turner46225b12016-12-16 22:48:14 +0000327 FrameProc.SectionIdOfExceptionHandler);
328 IO.mapRequired("Flags", FrameProc.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000329}
330
331void MappingTraits<CallSiteInfoSym>::mapping(IO &IO,
332 CallSiteInfoSym &CallSiteInfo) {
333 // TODO: Map Linkage Name
Zachary Turner46225b12016-12-16 22:48:14 +0000334 IO.mapRequired("Segment", CallSiteInfo.Segment);
335 IO.mapRequired("Type", CallSiteInfo.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000336}
337
338void MappingTraits<FileStaticSym>::mapping(IO &IO, FileStaticSym &FileStatic) {
Zachary Turner46225b12016-12-16 22:48:14 +0000339 IO.mapRequired("Index", FileStatic.Index);
340 IO.mapRequired("ModFilenameOffset", FileStatic.ModFilenameOffset);
341 IO.mapRequired("Flags", FileStatic.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000342 IO.mapRequired("Name", FileStatic.Name);
343}
344
345void MappingTraits<HeapAllocationSiteSym>::mapping(
346 IO &IO, HeapAllocationSiteSym &HeapAllocSite) {
347 // TODO: Map Linkage Name
Zachary Turner46225b12016-12-16 22:48:14 +0000348 IO.mapRequired("Segment", HeapAllocSite.Segment);
349 IO.mapRequired("CallInstructionSize", HeapAllocSite.CallInstructionSize);
350 IO.mapRequired("Type", HeapAllocSite.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000351}
352
353void MappingTraits<FrameCookieSym>::mapping(IO &IO,
354 FrameCookieSym &FrameCookie) {
355 // TODO: Map Linkage Name
Zachary Turner46225b12016-12-16 22:48:14 +0000356 IO.mapRequired("Register", FrameCookie.Register);
357 IO.mapRequired("CookieKind", FrameCookie.CookieKind);
358 IO.mapRequired("Flags", FrameCookie.Flags);
Zachary Turner3b147642016-10-08 01:12:01 +0000359}
360
361void MappingTraits<CallerSym>::mapping(IO &IO, CallerSym &Caller) {
362 // TODO: Correctly handle the ArrayRef in here.
363 std::vector<TypeIndex> Indices(Caller.Indices);
364 IO.mapRequired("FuncID", Indices);
365}
366
367void MappingTraits<UDTSym>::mapping(IO &IO, UDTSym &UDT) {
Zachary Turner46225b12016-12-16 22:48:14 +0000368 IO.mapRequired("Type", UDT.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000369 IO.mapRequired("UDTName", UDT.Name);
370}
371
372void MappingTraits<BuildInfoSym>::mapping(IO &IO, BuildInfoSym &BuildInfo) {
Zachary Turner46225b12016-12-16 22:48:14 +0000373 IO.mapRequired("BuildId", BuildInfo.BuildId);
Zachary Turner3b147642016-10-08 01:12:01 +0000374}
375
376void MappingTraits<BPRelativeSym>::mapping(IO &IO, BPRelativeSym &BPRel) {
Zachary Turner46225b12016-12-16 22:48:14 +0000377 IO.mapRequired("Offset", BPRel.Offset);
378 IO.mapRequired("Type", BPRel.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000379 IO.mapRequired("VarName", BPRel.Name);
380}
381
382void MappingTraits<RegRelativeSym>::mapping(IO &IO, RegRelativeSym &RegRel) {
Zachary Turner46225b12016-12-16 22:48:14 +0000383 IO.mapRequired("Offset", RegRel.Offset);
384 IO.mapRequired("Type", RegRel.Type);
385 IO.mapRequired("Register", RegRel.Register);
Zachary Turner3b147642016-10-08 01:12:01 +0000386 IO.mapRequired("VarName", RegRel.Name);
387}
388
389void MappingTraits<ConstantSym>::mapping(IO &IO, ConstantSym &Constant) {
Zachary Turner46225b12016-12-16 22:48:14 +0000390 IO.mapRequired("Type", Constant.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000391 IO.mapRequired("Value", Constant.Value);
392 IO.mapRequired("Name", Constant.Name);
393}
394
395void MappingTraits<DataSym>::mapping(IO &IO, DataSym &Data) {
396 // TODO: Map linkage name
Zachary Turner46225b12016-12-16 22:48:14 +0000397 IO.mapRequired("Type", Data.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000398 IO.mapRequired("DisplayName", Data.Name);
399}
400
401void MappingTraits<ThreadLocalDataSym>::mapping(IO &IO,
402 ThreadLocalDataSym &Data) {
403 // TODO: Map linkage name
Zachary Turner46225b12016-12-16 22:48:14 +0000404 IO.mapRequired("Type", Data.Type);
Zachary Turner3b147642016-10-08 01:12:01 +0000405 IO.mapRequired("DisplayName", Data.Name);
406}
407}
408}
409
410Error llvm::codeview::yaml::YamlSymbolDumper::visitSymbolBegin(CVSymbol &CVR) {
411 YamlIO.mapRequired("Kind", CVR.Type);
412 return Error::success();
413}