Line data Source code
1 : //===-- TypeDumpVisitor.cpp - CodeView type info dumper ----------*- 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 "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
11 :
12 : #include "llvm/ADT/SmallString.h"
13 : #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
14 : #include "llvm/DebugInfo/CodeView/Formatters.h"
15 : #include "llvm/DebugInfo/CodeView/TypeCollection.h"
16 : #include "llvm/DebugInfo/CodeView/TypeIndex.h"
17 : #include "llvm/DebugInfo/CodeView/TypeRecord.h"
18 : #include "llvm/Support/FormatVariadic.h"
19 : #include "llvm/Support/ScopedPrinter.h"
20 :
21 : using namespace llvm;
22 : using namespace llvm::codeview;
23 :
24 : static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
25 : #define CV_TYPE(enum, val) {#enum, enum},
26 : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
27 : };
28 :
29 : #define ENUM_ENTRY(enum_class, enum) \
30 : { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
31 :
32 : static const EnumEntry<uint16_t> ClassOptionNames[] = {
33 : ENUM_ENTRY(ClassOptions, Packed),
34 : ENUM_ENTRY(ClassOptions, HasConstructorOrDestructor),
35 : ENUM_ENTRY(ClassOptions, HasOverloadedOperator),
36 : ENUM_ENTRY(ClassOptions, Nested),
37 : ENUM_ENTRY(ClassOptions, ContainsNestedClass),
38 : ENUM_ENTRY(ClassOptions, HasOverloadedAssignmentOperator),
39 : ENUM_ENTRY(ClassOptions, HasConversionOperator),
40 : ENUM_ENTRY(ClassOptions, ForwardReference),
41 : ENUM_ENTRY(ClassOptions, Scoped),
42 : ENUM_ENTRY(ClassOptions, HasUniqueName),
43 : ENUM_ENTRY(ClassOptions, Sealed),
44 : ENUM_ENTRY(ClassOptions, Intrinsic),
45 : };
46 :
47 : static const EnumEntry<uint8_t> MemberAccessNames[] = {
48 : ENUM_ENTRY(MemberAccess, None), ENUM_ENTRY(MemberAccess, Private),
49 : ENUM_ENTRY(MemberAccess, Protected), ENUM_ENTRY(MemberAccess, Public),
50 : };
51 :
52 : static const EnumEntry<uint16_t> MethodOptionNames[] = {
53 : ENUM_ENTRY(MethodOptions, Pseudo),
54 : ENUM_ENTRY(MethodOptions, NoInherit),
55 : ENUM_ENTRY(MethodOptions, NoConstruct),
56 : ENUM_ENTRY(MethodOptions, CompilerGenerated),
57 : ENUM_ENTRY(MethodOptions, Sealed),
58 : };
59 :
60 : static const EnumEntry<uint16_t> MemberKindNames[] = {
61 : ENUM_ENTRY(MethodKind, Vanilla),
62 : ENUM_ENTRY(MethodKind, Virtual),
63 : ENUM_ENTRY(MethodKind, Static),
64 : ENUM_ENTRY(MethodKind, Friend),
65 : ENUM_ENTRY(MethodKind, IntroducingVirtual),
66 : ENUM_ENTRY(MethodKind, PureVirtual),
67 : ENUM_ENTRY(MethodKind, PureIntroducingVirtual),
68 : };
69 :
70 : static const EnumEntry<uint8_t> PtrKindNames[] = {
71 : ENUM_ENTRY(PointerKind, Near16),
72 : ENUM_ENTRY(PointerKind, Far16),
73 : ENUM_ENTRY(PointerKind, Huge16),
74 : ENUM_ENTRY(PointerKind, BasedOnSegment),
75 : ENUM_ENTRY(PointerKind, BasedOnValue),
76 : ENUM_ENTRY(PointerKind, BasedOnSegmentValue),
77 : ENUM_ENTRY(PointerKind, BasedOnAddress),
78 : ENUM_ENTRY(PointerKind, BasedOnSegmentAddress),
79 : ENUM_ENTRY(PointerKind, BasedOnType),
80 : ENUM_ENTRY(PointerKind, BasedOnSelf),
81 : ENUM_ENTRY(PointerKind, Near32),
82 : ENUM_ENTRY(PointerKind, Far32),
83 : ENUM_ENTRY(PointerKind, Near64),
84 : };
85 :
86 : static const EnumEntry<uint8_t> PtrModeNames[] = {
87 : ENUM_ENTRY(PointerMode, Pointer),
88 : ENUM_ENTRY(PointerMode, LValueReference),
89 : ENUM_ENTRY(PointerMode, PointerToDataMember),
90 : ENUM_ENTRY(PointerMode, PointerToMemberFunction),
91 : ENUM_ENTRY(PointerMode, RValueReference),
92 : };
93 :
94 : static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
95 : ENUM_ENTRY(PointerToMemberRepresentation, Unknown),
96 : ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceData),
97 : ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceData),
98 : ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceData),
99 : ENUM_ENTRY(PointerToMemberRepresentation, GeneralData),
100 : ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceFunction),
101 : ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceFunction),
102 : ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceFunction),
103 : ENUM_ENTRY(PointerToMemberRepresentation, GeneralFunction),
104 : };
105 :
106 : static const EnumEntry<uint16_t> TypeModifierNames[] = {
107 : ENUM_ENTRY(ModifierOptions, Const), ENUM_ENTRY(ModifierOptions, Volatile),
108 : ENUM_ENTRY(ModifierOptions, Unaligned),
109 : };
110 :
111 : static const EnumEntry<uint8_t> CallingConventions[] = {
112 : ENUM_ENTRY(CallingConvention, NearC),
113 : ENUM_ENTRY(CallingConvention, FarC),
114 : ENUM_ENTRY(CallingConvention, NearPascal),
115 : ENUM_ENTRY(CallingConvention, FarPascal),
116 : ENUM_ENTRY(CallingConvention, NearFast),
117 : ENUM_ENTRY(CallingConvention, FarFast),
118 : ENUM_ENTRY(CallingConvention, NearStdCall),
119 : ENUM_ENTRY(CallingConvention, FarStdCall),
120 : ENUM_ENTRY(CallingConvention, NearSysCall),
121 : ENUM_ENTRY(CallingConvention, FarSysCall),
122 : ENUM_ENTRY(CallingConvention, ThisCall),
123 : ENUM_ENTRY(CallingConvention, MipsCall),
124 : ENUM_ENTRY(CallingConvention, Generic),
125 : ENUM_ENTRY(CallingConvention, AlphaCall),
126 : ENUM_ENTRY(CallingConvention, PpcCall),
127 : ENUM_ENTRY(CallingConvention, SHCall),
128 : ENUM_ENTRY(CallingConvention, ArmCall),
129 : ENUM_ENTRY(CallingConvention, AM33Call),
130 : ENUM_ENTRY(CallingConvention, TriCall),
131 : ENUM_ENTRY(CallingConvention, SH5Call),
132 : ENUM_ENTRY(CallingConvention, M32RCall),
133 : ENUM_ENTRY(CallingConvention, ClrCall),
134 : ENUM_ENTRY(CallingConvention, Inline),
135 : ENUM_ENTRY(CallingConvention, NearVector),
136 : };
137 :
138 : static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
139 : ENUM_ENTRY(FunctionOptions, CxxReturnUdt),
140 : ENUM_ENTRY(FunctionOptions, Constructor),
141 : ENUM_ENTRY(FunctionOptions, ConstructorWithVirtualBases),
142 : };
143 :
144 : static const EnumEntry<uint16_t> LabelTypeEnum[] = {
145 : ENUM_ENTRY(LabelType, Near), ENUM_ENTRY(LabelType, Far),
146 : };
147 :
148 : #undef ENUM_ENTRY
149 :
150 11108 : static StringRef getLeafTypeName(TypeLeafKind LT) {
151 11108 : switch (LT) {
152 : #define TYPE_RECORD(ename, value, name) \
153 : case ename: \
154 : return #name;
155 : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
156 : default:
157 : break;
158 : }
159 0 : return "UnknownLeaf";
160 : }
161 :
162 7062 : void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {
163 7062 : codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);
164 7062 : }
165 :
166 1958 : void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {
167 3839 : codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());
168 1958 : }
169 :
170 0 : Error TypeDumpVisitor::visitTypeBegin(CVType &Record) {
171 0 : return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));
172 : }
173 :
174 4055 : Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
175 4055 : W->startLine() << getLeafTypeName(Record.Type);
176 4055 : W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";
177 4055 : W->getOStream() << " {\n";
178 4055 : W->indent();
179 8110 : W->printEnum("TypeLeafKind", unsigned(Record.Type),
180 : makeArrayRef(LeafTypeNames));
181 4055 : return Error::success();
182 : }
183 :
184 4055 : Error TypeDumpVisitor::visitTypeEnd(CVType &Record) {
185 4055 : if (PrintRecordBytes)
186 42 : W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));
187 :
188 4055 : W->unindent();
189 4055 : W->startLine() << "}\n";
190 4055 : return Error::success();
191 : }
192 :
193 7053 : Error TypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
194 7053 : W->startLine() << getLeafTypeName(Record.Kind);
195 7053 : W->getOStream() << " {\n";
196 7053 : W->indent();
197 14106 : W->printEnum("TypeLeafKind", unsigned(Record.Kind),
198 : makeArrayRef(LeafTypeNames));
199 7053 : return Error::success();
200 : }
201 :
202 7053 : Error TypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
203 7053 : if (PrintRecordBytes)
204 0 : W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
205 :
206 7053 : W->unindent();
207 7053 : W->startLine() << "}\n";
208 7053 : return Error::success();
209 : }
210 :
211 388 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
212 : FieldListRecord &FieldList) {
213 776 : if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
214 : return EC;
215 :
216 : return Error::success();
217 : }
218 :
219 473 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {
220 946 : printItemIndex("Id", String.getId());
221 946 : W->printString("StringData", String.getString());
222 473 : return Error::success();
223 : }
224 :
225 303 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
226 : auto Indices = Args.getIndices();
227 303 : uint32_t Size = Indices.size();
228 606 : W->printNumber("NumArgs", Size);
229 606 : ListScope Arguments(*W, "Arguments");
230 680 : for (uint32_t I = 0; I < Size; ++I) {
231 754 : printTypeIndex("ArgType", Indices[I]);
232 : }
233 303 : return Error::success();
234 : }
235 :
236 21 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringListRecord &Strs) {
237 : auto Indices = Strs.getIndices();
238 21 : uint32_t Size = Indices.size();
239 42 : W->printNumber("NumStrings", Size);
240 42 : ListScope Arguments(*W, "Strings");
241 44 : for (uint32_t I = 0; I < Size; ++I) {
242 69 : printItemIndex("String", Indices[I]);
243 : }
244 21 : return Error::success();
245 : }
246 :
247 628 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
248 628 : uint16_t Props = static_cast<uint16_t>(Class.getOptions());
249 1256 : W->printNumber("MemberCount", Class.getMemberCount());
250 1256 : W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
251 1256 : printTypeIndex("FieldList", Class.getFieldList());
252 1256 : printTypeIndex("DerivedFrom", Class.getDerivationList());
253 1256 : printTypeIndex("VShape", Class.getVTableShape());
254 1256 : W->printNumber("SizeOf", Class.getSize());
255 1256 : W->printString("Name", Class.getName());
256 628 : if (Props & uint16_t(ClassOptions::HasUniqueName))
257 1158 : W->printString("LinkageName", Class.getUniqueName());
258 628 : return Error::success();
259 : }
260 :
261 19 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
262 19 : uint16_t Props = static_cast<uint16_t>(Union.getOptions());
263 38 : W->printNumber("MemberCount", Union.getMemberCount());
264 38 : W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
265 38 : printTypeIndex("FieldList", Union.getFieldList());
266 38 : W->printNumber("SizeOf", Union.getSize());
267 38 : W->printString("Name", Union.getName());
268 19 : if (Props & uint16_t(ClassOptions::HasUniqueName))
269 32 : W->printString("LinkageName", Union.getUniqueName());
270 19 : return Error::success();
271 : }
272 :
273 67 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
274 67 : uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
275 134 : W->printNumber("NumEnumerators", Enum.getMemberCount());
276 134 : W->printFlags("Properties", uint16_t(Enum.getOptions()),
277 : makeArrayRef(ClassOptionNames));
278 134 : printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
279 134 : printTypeIndex("FieldListType", Enum.getFieldList());
280 134 : W->printString("Name", Enum.getName());
281 67 : if (Props & uint16_t(ClassOptions::HasUniqueName))
282 132 : W->printString("LinkageName", Enum.getUniqueName());
283 67 : return Error::success();
284 : }
285 :
286 37 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
287 74 : printTypeIndex("ElementType", AT.getElementType());
288 74 : printTypeIndex("IndexType", AT.getIndexType());
289 74 : W->printNumber("SizeOf", AT.getSize());
290 74 : W->printString("Name", AT.getName());
291 37 : return Error::success();
292 : }
293 :
294 7 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {
295 14 : printTypeIndex("CompleteClass", VFT.getCompleteClass());
296 14 : printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
297 14 : W->printHex("VFPtrOffset", VFT.getVFPtrOffset());
298 14 : W->printString("VFTableName", VFT.getName());
299 19 : for (auto N : VFT.getMethodNames())
300 24 : W->printString("MethodName", N);
301 7 : return Error::success();
302 : }
303 :
304 65 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {
305 130 : printTypeIndex("ClassType", Id.getClassType());
306 130 : printTypeIndex("FunctionType", Id.getFunctionType());
307 130 : W->printString("Name", Id.getName());
308 65 : return Error::success();
309 : }
310 :
311 200 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
312 400 : printTypeIndex("ReturnType", Proc.getReturnType());
313 400 : W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
314 : makeArrayRef(CallingConventions));
315 400 : W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
316 : makeArrayRef(FunctionOptionEnum));
317 400 : W->printNumber("NumParameters", Proc.getParameterCount());
318 400 : printTypeIndex("ArgListType", Proc.getArgumentList());
319 200 : return Error::success();
320 : }
321 :
322 419 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {
323 838 : printTypeIndex("ReturnType", MF.getReturnType());
324 838 : printTypeIndex("ClassType", MF.getClassType());
325 838 : printTypeIndex("ThisType", MF.getThisType());
326 838 : W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
327 : makeArrayRef(CallingConventions));
328 838 : W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
329 : makeArrayRef(FunctionOptionEnum));
330 838 : W->printNumber("NumParameters", MF.getParameterCount());
331 838 : printTypeIndex("ArgListType", MF.getArgumentList());
332 838 : W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
333 419 : return Error::success();
334 : }
335 :
336 87 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
337 : MethodOverloadListRecord &MethodList) {
338 299 : for (auto &M : MethodList.getMethods()) {
339 424 : ListScope S(*W, "Method");
340 212 : printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());
341 424 : printTypeIndex("Type", M.getType());
342 : if (M.isIntroducingVirtual())
343 0 : W->printHex("VFTableOffset", M.getVFTableOffset());
344 : }
345 87 : return Error::success();
346 : }
347 :
348 277 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
349 554 : printItemIndex("ParentScope", Func.getParentScope());
350 554 : printTypeIndex("FunctionType", Func.getFunctionType());
351 554 : W->printString("Name", Func.getName());
352 277 : return Error::success();
353 : }
354 :
355 0 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
356 0 : W->printString("Guid", formatv("{0}", TS.getGuid()).str());
357 0 : W->printNumber("Age", TS.getAge());
358 0 : W->printString("Name", TS.getName());
359 0 : return Error::success();
360 : }
361 :
362 419 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
363 838 : printTypeIndex("PointeeType", Ptr.getReferentType());
364 838 : W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
365 1257 : W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
366 : makeArrayRef(PtrKindNames));
367 1257 : W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
368 :
369 1257 : W->printNumber("IsFlat", Ptr.isFlat());
370 1257 : W->printNumber("IsConst", Ptr.isConst());
371 1257 : W->printNumber("IsVolatile", Ptr.isVolatile());
372 1257 : W->printNumber("IsUnaligned", Ptr.isUnaligned());
373 1257 : W->printNumber("IsRestrict", Ptr.isRestrict());
374 1257 : W->printNumber("SizeOf", Ptr.getSize());
375 :
376 : if (Ptr.isPointerToMember()) {
377 16 : const MemberPointerInfo &MI = Ptr.getMemberInfo();
378 :
379 32 : printTypeIndex("ClassType", MI.getContainingType());
380 32 : W->printEnum("Representation", uint16_t(MI.getRepresentation()),
381 : makeArrayRef(PtrMemberRepNames));
382 : }
383 :
384 419 : return Error::success();
385 : }
386 :
387 72 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
388 72 : uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
389 144 : printTypeIndex("ModifiedType", Mod.getModifiedType());
390 144 : W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));
391 :
392 72 : return Error::success();
393 : }
394 :
395 7 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BitFieldRecord &BitField) {
396 14 : printTypeIndex("Type", BitField.getType());
397 14 : W->printNumber("BitSize", BitField.getBitSize());
398 14 : W->printNumber("BitOffset", BitField.getBitOffset());
399 7 : return Error::success();
400 : }
401 :
402 18 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
403 : VFTableShapeRecord &Shape) {
404 36 : W->printNumber("VFEntryCount", Shape.getEntryCount());
405 18 : return Error::success();
406 : }
407 :
408 385 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
409 : UdtSourceLineRecord &Line) {
410 770 : printTypeIndex("UDT", Line.getUDT());
411 770 : printItemIndex("SourceFile", Line.getSourceFile());
412 770 : W->printNumber("LineNumber", Line.getLineNumber());
413 385 : return Error::success();
414 : }
415 :
416 0 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
417 : UdtModSourceLineRecord &Line) {
418 0 : printTypeIndex("UDT", Line.getUDT());
419 0 : printItemIndex("SourceFile", Line.getSourceFile());
420 0 : W->printNumber("LineNumber", Line.getLineNumber());
421 0 : W->printNumber("Module", Line.getModule());
422 0 : return Error::success();
423 : }
424 :
425 160 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {
426 320 : W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
427 :
428 320 : ListScope Arguments(*W, "Arguments");
429 960 : for (auto Arg : Args.getArgs()) {
430 800 : printItemIndex("ArgType", Arg);
431 : }
432 160 : return Error::success();
433 : }
434 :
435 0 : void TypeDumpVisitor::printMemberAttributes(MemberAttributes Attrs) {
436 0 : return printMemberAttributes(Attrs.getAccess(), Attrs.getMethodKind(),
437 0 : Attrs.getFlags());
438 : }
439 :
440 7087 : void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,
441 : MethodKind Kind,
442 : MethodOptions Options) {
443 14174 : W->printEnum("AccessSpecifier", uint8_t(Access),
444 : makeArrayRef(MemberAccessNames));
445 : // Data members will be vanilla. Don't try to print a method kind for them.
446 7087 : if (Kind != MethodKind::Vanilla)
447 80 : W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));
448 7087 : if (Options != MethodOptions::None) {
449 90 : W->printFlags("MethodOptions", unsigned(Options),
450 : makeArrayRef(MethodOptionNames));
451 : }
452 7087 : }
453 :
454 0 : Error TypeDumpVisitor::visitUnknownMember(CVMemberRecord &Record) {
455 0 : W->printHex("UnknownMember", unsigned(Record.Kind));
456 0 : return Error::success();
457 : }
458 :
459 0 : Error TypeDumpVisitor::visitUnknownType(CVType &Record) {
460 0 : W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames));
461 0 : W->printNumber("Length", uint32_t(Record.content().size()));
462 0 : return Error::success();
463 : }
464 :
465 71 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
466 : NestedTypeRecord &Nested) {
467 142 : printTypeIndex("Type", Nested.getNestedType());
468 142 : W->printString("Name", Nested.getName());
469 71 : return Error::success();
470 : }
471 :
472 189 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
473 : OneMethodRecord &Method) {
474 : MethodKind K = Method.getMethodKind();
475 189 : printMemberAttributes(Method.getAccess(), K, Method.getOptions());
476 378 : printTypeIndex("Type", Method.getType());
477 : // If virtual, then read the vftable offset.
478 : if (Method.isIntroducingVirtual())
479 42 : W->printHex("VFTableOffset", Method.getVFTableOffset());
480 378 : W->printString("Name", Method.getName());
481 189 : return Error::success();
482 : }
483 :
484 87 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
485 : OverloadedMethodRecord &Method) {
486 174 : W->printHex("MethodCount", Method.getNumOverloads());
487 174 : printTypeIndex("MethodListIndex", Method.getMethodList());
488 174 : W->printString("Name", Method.getName());
489 87 : return Error::success();
490 : }
491 :
492 505 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
493 : DataMemberRecord &Field) {
494 505 : printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
495 : MethodOptions::None);
496 1010 : printTypeIndex("Type", Field.getType());
497 1010 : W->printHex("FieldOffset", Field.getFieldOffset());
498 1010 : W->printString("Name", Field.getName());
499 505 : return Error::success();
500 : }
501 :
502 43 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
503 : StaticDataMemberRecord &Field) {
504 43 : printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
505 : MethodOptions::None);
506 86 : printTypeIndex("Type", Field.getType());
507 86 : W->printString("Name", Field.getName());
508 43 : return Error::success();
509 : }
510 :
511 16 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
512 : VFPtrRecord &VFTable) {
513 32 : printTypeIndex("Type", VFTable.getType());
514 16 : return Error::success();
515 : }
516 :
517 6102 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
518 : EnumeratorRecord &Enum) {
519 6102 : printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
520 : MethodOptions::None);
521 12204 : W->printNumber("EnumValue", Enum.getValue());
522 12204 : W->printString("Name", Enum.getName());
523 6102 : return Error::success();
524 : }
525 :
526 21 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
527 : BaseClassRecord &Base) {
528 21 : printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
529 : MethodOptions::None);
530 42 : printTypeIndex("BaseType", Base.getBaseType());
531 42 : W->printHex("BaseOffset", Base.getBaseOffset());
532 21 : return Error::success();
533 : }
534 :
535 15 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
536 : VirtualBaseClassRecord &Base) {
537 15 : printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
538 : MethodOptions::None);
539 30 : printTypeIndex("BaseType", Base.getBaseType());
540 30 : printTypeIndex("VBPtrType", Base.getVBPtrType());
541 30 : W->printHex("VBPtrOffset", Base.getVBPtrOffset());
542 30 : W->printHex("VBTableIndex", Base.getVTableIndex());
543 15 : return Error::success();
544 : }
545 :
546 4 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
547 : ListContinuationRecord &Cont) {
548 8 : printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
549 4 : return Error::success();
550 : }
551 :
552 1 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {
553 2 : W->printEnum("Mode", uint16_t(LR.Mode), makeArrayRef(LabelTypeEnum));
554 1 : return Error::success();
555 : }
556 :
557 1 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
558 : PrecompRecord &Precomp) {
559 2 : W->printHex("StartIndex", Precomp.getStartTypeIndex());
560 2 : W->printHex("Count", Precomp.getTypesCount());
561 2 : W->printHex("Signature", Precomp.getSignature());
562 2 : W->printString("PrecompFile", Precomp.getPrecompFilePath());
563 1 : return Error::success();
564 : }
565 :
566 1 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
567 : EndPrecompRecord &EndPrecomp) {
568 2 : W->printHex("Signature", EndPrecomp.getSignature());
569 1 : return Error::success();
570 : }
|
