LCOV - code coverage report
Current view: top level - lib/DebugInfo/CodeView - TypeDumpVisitor.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 239 265 90.2 %
Date: 2018-06-17 00:07:59 Functions: 43 49 87.8 %
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/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       10534 : static StringRef getLeafTypeName(TypeLeafKind LT) {
     151       10534 :   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        6818 : void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {
     163        6818 :   codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);
     164        6818 : }
     165             : 
     166         964 : void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {
     167        1928 :   codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());
     168         964 : }
     169             : 
     170           0 : Error TypeDumpVisitor::visitTypeBegin(CVType &Record) {
     171           0 :   return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));
     172             : }
     173             : 
     174        3498 : Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
     175        6996 :   W->startLine() << getLeafTypeName(Record.Type);
     176        6996 :   W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";
     177        3498 :   W->getOStream() << " {\n";
     178        3498 :   W->indent();
     179        6996 :   W->printEnum("TypeLeafKind", unsigned(Record.Type),
     180             :                makeArrayRef(LeafTypeNames));
     181        3498 :   return Error::success();
     182             : }
     183             : 
     184        3498 : Error TypeDumpVisitor::visitTypeEnd(CVType &Record) {
     185        3498 :   if (PrintRecordBytes)
     186          22 :     W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));
     187             : 
     188        3498 :   W->unindent();
     189        3498 :   W->startLine() << "}\n";
     190        3498 :   return Error::success();
     191             : }
     192             : 
     193        7036 : Error TypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
     194       14072 :   W->startLine() << getLeafTypeName(Record.Kind);
     195        7036 :   W->getOStream() << " {\n";
     196        7036 :   W->indent();
     197       14072 :   W->printEnum("TypeLeafKind", unsigned(Record.Kind),
     198             :                makeArrayRef(LeafTypeNames));
     199        7036 :   return Error::success();
     200             : }
     201             : 
     202        7036 : Error TypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
     203        7036 :   if (PrintRecordBytes)
     204           0 :     W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
     205             : 
     206        7036 :   W->unindent();
     207        7036 :   W->startLine() << "}\n";
     208        7036 :   return Error::success();
     209             : }
     210             : 
     211         375 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
     212             :                                         FieldListRecord &FieldList) {
     213         750 :   if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
     214             :     return EC;
     215             : 
     216             :   return Error::success();
     217             : }
     218             : 
     219         199 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {
     220         199 :   printItemIndex("Id", String.getId());
     221         398 :   W->printString("StringData", String.getString());
     222         199 :   return Error::success();
     223             : }
     224             : 
     225         284 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
     226             :   auto Indices = Args.getIndices();
     227         284 :   uint32_t Size = Indices.size();
     228         568 :   W->printNumber("NumArgs", Size);
     229         568 :   ListScope Arguments(*W, "Arguments");
     230        1010 :   for (uint32_t I = 0; I < Size; ++I) {
     231         726 :     printTypeIndex("ArgType", Indices[I]);
     232             :   }
     233         284 :   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          67 :   for (uint32_t I = 0; I < Size; ++I) {
     242          46 :     printItemIndex("String", Indices[I]);
     243             :   }
     244          21 :   return Error::success();
     245             : }
     246             : 
     247         610 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
     248         610 :   uint16_t Props = static_cast<uint16_t>(Class.getOptions());
     249        1220 :   W->printNumber("MemberCount", Class.getMemberCount());
     250        1220 :   W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
     251         610 :   printTypeIndex("FieldList", Class.getFieldList());
     252         610 :   printTypeIndex("DerivedFrom", Class.getDerivationList());
     253         610 :   printTypeIndex("VShape", Class.getVTableShape());
     254        1220 :   W->printNumber("SizeOf", Class.getSize());
     255        1220 :   W->printString("Name", Class.getName());
     256         610 :   if (Props & uint16_t(ClassOptions::HasUniqueName))
     257        1122 :     W->printString("LinkageName", Class.getUniqueName());
     258         610 :   return Error::success();
     259             : }
     260             : 
     261          13 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
     262          13 :   uint16_t Props = static_cast<uint16_t>(Union.getOptions());
     263          26 :   W->printNumber("MemberCount", Union.getMemberCount());
     264          26 :   W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
     265          13 :   printTypeIndex("FieldList", Union.getFieldList());
     266          26 :   W->printNumber("SizeOf", Union.getSize());
     267          26 :   W->printString("Name", Union.getName());
     268          13 :   if (Props & uint16_t(ClassOptions::HasUniqueName))
     269          20 :     W->printString("LinkageName", Union.getUniqueName());
     270          13 :   return Error::success();
     271             : }
     272             : 
     273          63 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
     274          63 :   uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
     275         126 :   W->printNumber("NumEnumerators", Enum.getMemberCount());
     276         126 :   W->printFlags("Properties", uint16_t(Enum.getOptions()),
     277             :                 makeArrayRef(ClassOptionNames));
     278          63 :   printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
     279          63 :   printTypeIndex("FieldListType", Enum.getFieldList());
     280         126 :   W->printString("Name", Enum.getName());
     281          63 :   if (Props & uint16_t(ClassOptions::HasUniqueName))
     282         124 :     W->printString("LinkageName", Enum.getUniqueName());
     283          63 :   return Error::success();
     284             : }
     285             : 
     286          37 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
     287          37 :   printTypeIndex("ElementType", AT.getElementType());
     288          37 :   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           7 :   printTypeIndex("CompleteClass", VFT.getCompleteClass());
     296           7 :   printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
     297          14 :   W->printHex("VFPtrOffset", VFT.getVFPtrOffset());
     298          14 :   W->printString("VFTableName", VFT.getName());
     299          31 :   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          65 :   printTypeIndex("ClassType", Id.getClassType());
     306          65 :   printTypeIndex("FunctionType", Id.getFunctionType());
     307         130 :   W->printString("Name", Id.getName());
     308          65 :   return Error::success();
     309             : }
     310             : 
     311         182 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
     312         182 :   printTypeIndex("ReturnType", Proc.getReturnType());
     313         364 :   W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
     314             :                makeArrayRef(CallingConventions));
     315         364 :   W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
     316             :                 makeArrayRef(FunctionOptionEnum));
     317         364 :   W->printNumber("NumParameters", Proc.getParameterCount());
     318         182 :   printTypeIndex("ArgListType", Proc.getArgumentList());
     319         182 :   return Error::success();
     320             : }
     321             : 
     322         403 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {
     323         403 :   printTypeIndex("ReturnType", MF.getReturnType());
     324         403 :   printTypeIndex("ClassType", MF.getClassType());
     325         403 :   printTypeIndex("ThisType", MF.getThisType());
     326         806 :   W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
     327             :                makeArrayRef(CallingConventions));
     328         806 :   W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
     329             :                 makeArrayRef(FunctionOptionEnum));
     330         806 :   W->printNumber("NumParameters", MF.getParameterCount());
     331         403 :   printTypeIndex("ArgListType", MF.getArgumentList());
     332         806 :   W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
     333         403 :   return Error::success();
     334             : }
     335             : 
     336          87 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
     337             :                                         MethodOverloadListRecord &MethodList) {
     338         511 :   for (auto &M : MethodList.getMethods()) {
     339         424 :     ListScope S(*W, "Method");
     340         212 :     printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());
     341         212 :     printTypeIndex("Type", M.getType());
     342             :     if (M.isIntroducingVirtual())
     343           0 :       W->printHex("VFTableOffset", M.getVFTableOffset());
     344             :   }
     345          87 :   return Error::success();
     346             : }
     347             : 
     348         258 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
     349         258 :   printItemIndex("ParentScope", Func.getParentScope());
     350         258 :   printTypeIndex("FunctionType", Func.getFunctionType());
     351         516 :   W->printString("Name", Func.getName());
     352         258 :   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         402 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
     363         402 :   printTypeIndex("PointeeType", Ptr.getReferentType());
     364         804 :   W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
     365        1206 :   W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
     366             :                makeArrayRef(PtrKindNames));
     367        1206 :   W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
     368             : 
     369        1206 :   W->printNumber("IsFlat", Ptr.isFlat());
     370        1206 :   W->printNumber("IsConst", Ptr.isConst());
     371        1206 :   W->printNumber("IsVolatile", Ptr.isVolatile());
     372        1206 :   W->printNumber("IsUnaligned", Ptr.isUnaligned());
     373        1206 :   W->printNumber("IsRestrict", Ptr.isRestrict());
     374        1206 :   W->printNumber("SizeOf", Ptr.getSize());
     375             : 
     376             :   if (Ptr.isPointerToMember()) {
     377          16 :     const MemberPointerInfo &MI = Ptr.getMemberInfo();
     378             : 
     379          16 :     printTypeIndex("ClassType", MI.getContainingType());
     380          32 :     W->printEnum("Representation", uint16_t(MI.getRepresentation()),
     381             :                  makeArrayRef(PtrMemberRepNames));
     382             :   }
     383             : 
     384         402 :   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          72 :   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           7 :   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         369 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
     409             :                                         UdtSourceLineRecord &Line) {
     410         369 :   printTypeIndex("UDT", Line.getUDT());
     411         369 :   printItemIndex("SourceFile", Line.getSourceFile());
     412         738 :   W->printNumber("LineNumber", Line.getLineNumber());
     413         369 :   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          23 : Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {
     426          69 :   W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
     427             : 
     428          46 :   ListScope Arguments(*W, "Arguments");
     429         253 :   for (auto Arg : Args.getArgs()) {
     430         115 :     printItemIndex("ArgType", Arg);
     431             :   }
     432          23 :   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        7072 : void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,
     441             :                                             MethodKind Kind,
     442             :                                             MethodOptions Options) {
     443       14144 :   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        7072 :   if (Kind != MethodKind::Vanilla)
     447          80 :     W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));
     448        7072 :   if (Options != MethodOptions::None) {
     449          90 :     W->printFlags("MethodOptions", unsigned(Options),
     450             :                   makeArrayRef(MethodOptionNames));
     451             :   }
     452        7072 : }
     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          69 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     466             :                                         NestedTypeRecord &Nested) {
     467          69 :   printTypeIndex("Type", Nested.getNestedType());
     468         138 :   W->printString("Name", Nested.getName());
     469          69 :   return Error::success();
     470             : }
     471             : 
     472         184 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     473             :                                         OneMethodRecord &Method) {
     474             :   MethodKind K = Method.getMethodKind();
     475         184 :   printMemberAttributes(Method.getAccess(), K, Method.getOptions());
     476         184 :   printTypeIndex("Type", Method.getType());
     477             :   // If virtual, then read the vftable offset.
     478             :   if (Method.isIntroducingVirtual())
     479          42 :     W->printHex("VFTableOffset", Method.getVFTableOffset());
     480         368 :   W->printString("Name", Method.getName());
     481         184 :   return Error::success();
     482             : }
     483             : 
     484          87 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     485             :                                         OverloadedMethodRecord &Method) {
     486         174 :   W->printHex("MethodCount", Method.getNumOverloads());
     487          87 :   printTypeIndex("MethodListIndex", Method.getMethodList());
     488         174 :   W->printString("Name", Method.getName());
     489          87 :   return Error::success();
     490             : }
     491             : 
     492         504 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     493             :                                         DataMemberRecord &Field) {
     494         504 :   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
     495             :                         MethodOptions::None);
     496         504 :   printTypeIndex("Type", Field.getType());
     497        1008 :   W->printHex("FieldOffset", Field.getFieldOffset());
     498        1008 :   W->printString("Name", Field.getName());
     499         504 :   return Error::success();
     500             : }
     501             : 
     502          42 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     503             :                                         StaticDataMemberRecord &Field) {
     504          42 :   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
     505             :                         MethodOptions::None);
     506          42 :   printTypeIndex("Type", Field.getType());
     507          84 :   W->printString("Name", Field.getName());
     508          42 :   return Error::success();
     509             : }
     510             : 
     511          16 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     512             :                                         VFPtrRecord &VFTable) {
     513          16 :   printTypeIndex("Type", VFTable.getType());
     514          16 :   return Error::success();
     515             : }
     516             : 
     517        6095 : Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
     518             :                                         EnumeratorRecord &Enum) {
     519        6095 :   printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
     520             :                         MethodOptions::None);
     521       18285 :   W->printNumber("EnumValue", Enum.getValue());
     522       12190 :   W->printString("Name", Enum.getName());
     523        6095 :   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          20 :   printTypeIndex("BaseType", Base.getBaseType());
     531          40 :   W->printHex("BaseOffset", Base.getBaseOffset());
     532          20 :   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          15 :   printTypeIndex("BaseType", Base.getBaseType());
     540          15 :   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           4 :   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      303507 : }

Generated by: LCOV version 1.13