LCOV - code coverage report
Current view: top level - lib/DebugInfo/CodeView - TypeDumpVisitor.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 245 272 90.1 %
Date: 2017-09-14 15:23:50 Functions: 41 47 87.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13