LCOV - code coverage report
Current view: top level - lib/ObjectYAML - CodeViewYAMLTypes.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 352 451 78.0 %
Date: 2018-06-17 00:07:59 Functions: 204 267 76.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//
       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             : // This file defines classes for handling the YAML representation of CodeView
      11             : // Debug Info.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
      16             : #include "llvm/ADT/APSInt.h"
      17             : #include "llvm/ADT/ArrayRef.h"
      18             : #include "llvm/ADT/StringRef.h"
      19             : #include "llvm/BinaryFormat/COFF.h"
      20             : #include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
      21             : #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
      22             : #include "llvm/DebugInfo/CodeView/CodeView.h"
      23             : #include "llvm/DebugInfo/CodeView/CodeViewError.h"
      24             : #include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
      25             : #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
      26             : #include "llvm/DebugInfo/CodeView/TypeIndex.h"
      27             : #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
      28             : #include "llvm/Support/Allocator.h"
      29             : #include "llvm/Support/BinaryStreamReader.h"
      30             : #include "llvm/Support/BinaryStreamWriter.h"
      31             : #include "llvm/Support/Endian.h"
      32             : #include "llvm/Support/Error.h"
      33             : #include "llvm/Support/ErrorHandling.h"
      34             : #include "llvm/Support/YAMLTraits.h"
      35             : #include "llvm/Support/raw_ostream.h"
      36             : #include <algorithm>
      37             : #include <cassert>
      38             : #include <cstdint>
      39             : #include <vector>
      40             : 
      41             : using namespace llvm;
      42             : using namespace llvm::codeview;
      43             : using namespace llvm::CodeViewYAML;
      44             : using namespace llvm::CodeViewYAML::detail;
      45             : using namespace llvm::yaml;
      46             : 
      47             : LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
      48             : LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
      49             : LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
      50             : 
      51             : LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)
      52             : LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)
      53             : 
      54             : LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)
      55             : LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)
      56             : LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)
      57             : LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)
      58             : LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)
      59             : LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)
      60             : LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)
      61             : LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)
      62             : LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)
      63             : LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)
      64             : LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)
      65             : 
      66             : LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)
      67             : LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)
      68             : LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)
      69             : LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)
      70             : LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)
      71             : 
      72             : LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)
      73             : LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)
      74             : 
      75             : namespace llvm {
      76             : namespace CodeViewYAML {
      77             : namespace detail {
      78             : 
      79             : struct LeafRecordBase {
      80             :   TypeLeafKind Kind;
      81             : 
      82        3992 :   explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}
      83             :   virtual ~LeafRecordBase() = default;
      84             : 
      85             :   virtual void map(yaml::IO &io) = 0;
      86             :   virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;
      87             :   virtual Error fromCodeViewRecord(CVType Type) = 0;
      88             : };
      89             : 
      90        4001 : template <typename T> struct LeafRecordImpl : public LeafRecordBase {
      91        3478 :   explicit LeafRecordImpl(TypeLeafKind K)
      92        3478 :       : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
      93             : 
      94             :   void map(yaml::IO &io) override;
      95             : 
      96        1406 :   Error fromCodeViewRecord(CVType Type) override {
      97        1406 :     return TypeDeserializer::deserializeAs<T>(Type, Record);
      98             :   }
      99             : 
     100        1108 :   CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
     101        1108 :     TS.writeLeafType(Record);
     102        3324 :     return CVType(Kind, TS.records().back());
     103             :   }
     104             : 
     105             :   mutable T Record;
     106             : };
     107             : 
     108         514 : template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {
     109        1028 :   explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}
     110             : 
     111             :   void map(yaml::IO &io) override;
     112             :   CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;
     113             :   Error fromCodeViewRecord(CVType Type) override;
     114             : 
     115             :   std::vector<MemberRecord> Members;
     116             : };
     117             : 
     118             : struct MemberRecordBase {
     119             :   TypeLeafKind Kind;
     120             : 
     121        2181 :   explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}
     122             :   virtual ~MemberRecordBase() = default;
     123             : 
     124             :   virtual void map(yaml::IO &io) = 0;
     125             :   virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;
     126             : };
     127             : 
     128        3006 : template <typename T> struct MemberRecordImpl : public MemberRecordBase {
     129        2181 :   explicit MemberRecordImpl(TypeLeafKind K)
     130        2181 :       : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
     131             : 
     132             :   void map(yaml::IO &io) override;
     133             : 
     134         701 :   void writeTo(ContinuationRecordBuilder &CRB) override {
     135         701 :     CRB.writeMemberType(Record);
     136         701 :   }
     137             : 
     138             :   mutable T Record;
     139             : };
     140             : 
     141             : } // end namespace detail
     142             : } // end namespace CodeViewYAML
     143             : } // end namespace llvm
     144             : 
     145          10 : void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {
     146          10 :   OS << G;
     147          10 : }
     148             : 
     149          10 : StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {
     150          10 :   if (Scalar.size() != 38)
     151           0 :     return "GUID strings are 38 characters long";
     152          20 :   if (Scalar[0] != '{' || Scalar[37] != '}')
     153           0 :     return "GUID is not enclosed in {}";
     154          40 :   if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
     155             :       Scalar[24] != '-')
     156           0 :     return "GUID sections are not properly delineated with dashes";
     157             : 
     158          10 :   uint8_t *OutBuffer = S.Guid;
     159         230 :   for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
     160         280 :     if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
     161          60 :       ++Iter;
     162          60 :       continue;
     163             :     }
     164         320 :     uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);
     165         320 :     Value |= llvm::hexDigitValue(*Iter++);
     166         160 :     *OutBuffer++ = Value;
     167             :   }
     168             : 
     169          10 :   return "";
     170             : }
     171             : 
     172        4443 : void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
     173             :                                      raw_ostream &OS) {
     174             :   OS << S.getIndex();
     175        4443 : }
     176             : 
     177        5883 : StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,
     178             :                                          TypeIndex &S) {
     179             :   uint32_t I;
     180        5883 :   StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);
     181        5883 :   S.setIndex(I);
     182        5883 :   return Result;
     183             : }
     184             : 
     185         380 : void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {
     186         760 :   S.print(OS, S.isSigned());
     187         380 : }
     188             : 
     189         445 : StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {
     190         890 :   S = APSInt(Scalar);
     191         445 :   return "";
     192             : }
     193             : 
     194        6173 : void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
     195             :                                                         TypeLeafKind &Value) {
     196             : #define CV_TYPE(name, val) io.enumCase(Value, #name, name);
     197             : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
     198             : #undef CV_TYPE
     199        6173 : }
     200             : 
     201           0 : void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(
     202             :     IO &IO, PointerToMemberRepresentation &Value) {
     203           0 :   IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
     204           0 :   IO.enumCase(Value, "SingleInheritanceData",
     205             :               PointerToMemberRepresentation::SingleInheritanceData);
     206           0 :   IO.enumCase(Value, "MultipleInheritanceData",
     207             :               PointerToMemberRepresentation::MultipleInheritanceData);
     208           0 :   IO.enumCase(Value, "VirtualInheritanceData",
     209             :               PointerToMemberRepresentation::VirtualInheritanceData);
     210           0 :   IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);
     211           0 :   IO.enumCase(Value, "SingleInheritanceFunction",
     212             :               PointerToMemberRepresentation::SingleInheritanceFunction);
     213           0 :   IO.enumCase(Value, "MultipleInheritanceFunction",
     214             :               PointerToMemberRepresentation::MultipleInheritanceFunction);
     215           0 :   IO.enumCase(Value, "VirtualInheritanceFunction",
     216             :               PointerToMemberRepresentation::VirtualInheritanceFunction);
     217           0 :   IO.enumCase(Value, "GeneralFunction",
     218             :               PointerToMemberRepresentation::GeneralFunction);
     219           0 : }
     220             : 
     221           7 : void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(
     222             :     IO &IO, VFTableSlotKind &Kind) {
     223           7 :   IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);
     224           7 :   IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);
     225           7 :   IO.enumCase(Kind, "This", VFTableSlotKind::This);
     226           7 :   IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);
     227           7 :   IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);
     228           7 :   IO.enumCase(Kind, "Near", VFTableSlotKind::Near);
     229           7 :   IO.enumCase(Kind, "Far", VFTableSlotKind::Far);
     230           7 : }
     231             : 
     232         709 : void ScalarEnumerationTraits<CallingConvention>::enumeration(
     233             :     IO &IO, CallingConvention &Value) {
     234         709 :   IO.enumCase(Value, "NearC", CallingConvention::NearC);
     235         709 :   IO.enumCase(Value, "FarC", CallingConvention::FarC);
     236         709 :   IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);
     237         709 :   IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);
     238         709 :   IO.enumCase(Value, "NearFast", CallingConvention::NearFast);
     239         709 :   IO.enumCase(Value, "FarFast", CallingConvention::FarFast);
     240         709 :   IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);
     241         709 :   IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);
     242         709 :   IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);
     243         709 :   IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);
     244         709 :   IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);
     245         709 :   IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);
     246         709 :   IO.enumCase(Value, "Generic", CallingConvention::Generic);
     247         709 :   IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);
     248         709 :   IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);
     249         709 :   IO.enumCase(Value, "SHCall", CallingConvention::SHCall);
     250         709 :   IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);
     251         709 :   IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);
     252         709 :   IO.enumCase(Value, "TriCall", CallingConvention::TriCall);
     253         709 :   IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);
     254         709 :   IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);
     255         709 :   IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);
     256         709 :   IO.enumCase(Value, "Inline", CallingConvention::Inline);
     257         709 :   IO.enumCase(Value, "NearVector", CallingConvention::NearVector);
     258         709 : }
     259             : 
     260           0 : void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,
     261             :                                                        PointerKind &Kind) {
     262           0 :   IO.enumCase(Kind, "Near16", PointerKind::Near16);
     263           0 :   IO.enumCase(Kind, "Far16", PointerKind::Far16);
     264           0 :   IO.enumCase(Kind, "Huge16", PointerKind::Huge16);
     265           0 :   IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);
     266           0 :   IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);
     267           0 :   IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);
     268           0 :   IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);
     269           0 :   IO.enumCase(Kind, "BasedOnSegmentAddress",
     270             :               PointerKind::BasedOnSegmentAddress);
     271           0 :   IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);
     272           0 :   IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);
     273           0 :   IO.enumCase(Kind, "Near32", PointerKind::Near32);
     274           0 :   IO.enumCase(Kind, "Far32", PointerKind::Far32);
     275           0 :   IO.enumCase(Kind, "Near64", PointerKind::Near64);
     276           0 : }
     277             : 
     278           0 : void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,
     279             :                                                        PointerMode &Mode) {
     280           0 :   IO.enumCase(Mode, "Pointer", PointerMode::Pointer);
     281           0 :   IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);
     282           0 :   IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);
     283           0 :   IO.enumCase(Mode, "PointerToMemberFunction",
     284             :               PointerMode::PointerToMemberFunction);
     285           0 :   IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);
     286           0 : }
     287             : 
     288           0 : void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {
     289           0 :   IO.enumCase(Value, "None", HfaKind::None);
     290           0 :   IO.enumCase(Value, "Float", HfaKind::Float);
     291           0 :   IO.enumCase(Value, "Double", HfaKind::Double);
     292           0 :   IO.enumCase(Value, "Other", HfaKind::Other);
     293           0 : }
     294             : 
     295           0 : void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,
     296             :                                                         MemberAccess &Access) {
     297           0 :   IO.enumCase(Access, "None", MemberAccess::None);
     298           0 :   IO.enumCase(Access, "Private", MemberAccess::Private);
     299           0 :   IO.enumCase(Access, "Protected", MemberAccess::Protected);
     300           0 :   IO.enumCase(Access, "Public", MemberAccess::Public);
     301           0 : }
     302             : 
     303           0 : void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,
     304             :                                                       MethodKind &Kind) {
     305           0 :   IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);
     306           0 :   IO.enumCase(Kind, "Virtual", MethodKind::Virtual);
     307           0 :   IO.enumCase(Kind, "Static", MethodKind::Static);
     308           0 :   IO.enumCase(Kind, "Friend", MethodKind::Friend);
     309           0 :   IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);
     310           0 :   IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);
     311           0 :   IO.enumCase(Kind, "PureIntroducingVirtual",
     312             :               MethodKind::PureIntroducingVirtual);
     313           0 : }
     314             : 
     315           0 : void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(
     316             :     IO &IO, WindowsRTClassKind &Value) {
     317           0 :   IO.enumCase(Value, "None", WindowsRTClassKind::None);
     318           0 :   IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);
     319           0 :   IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);
     320           0 :   IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);
     321           0 : }
     322             : 
     323           0 : void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {
     324           0 :   IO.enumCase(Value, "Near", LabelType::Near);
     325           0 :   IO.enumCase(Value, "Far", LabelType::Far);
     326           0 : }
     327             : 
     328           0 : void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
     329             :                                                 PointerOptions &Options) {
     330           0 :   IO.bitSetCase(Options, "None", PointerOptions::None);
     331           0 :   IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
     332           0 :   IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
     333           0 :   IO.bitSetCase(Options, "Const", PointerOptions::Const);
     334           0 :   IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
     335           0 :   IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
     336           0 :   IO.bitSetCase(Options, "WinRTSmartPointer",
     337             :                 PointerOptions::WinRTSmartPointer);
     338           0 : }
     339             : 
     340          64 : void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
     341             :                                                  ModifierOptions &Options) {
     342          64 :   IO.bitSetCase(Options, "None", ModifierOptions::None);
     343          64 :   IO.bitSetCase(Options, "Const", ModifierOptions::Const);
     344          64 :   IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
     345          64 :   IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);
     346          64 : }
     347             : 
     348         709 : void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,
     349             :                                                  FunctionOptions &Options) {
     350         709 :   IO.bitSetCase(Options, "None", FunctionOptions::None);
     351         709 :   IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
     352         709 :   IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
     353         709 :   IO.bitSetCase(Options, "ConstructorWithVirtualBases",
     354             :                 FunctionOptions::ConstructorWithVirtualBases);
     355         709 : }
     356             : 
     357         924 : void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {
     358         924 :   IO.bitSetCase(Options, "None", ClassOptions::None);
     359         924 :   IO.bitSetCase(Options, "HasConstructorOrDestructor",
     360             :                 ClassOptions::HasConstructorOrDestructor);
     361         924 :   IO.bitSetCase(Options, "HasOverloadedOperator",
     362             :                 ClassOptions::HasOverloadedOperator);
     363         924 :   IO.bitSetCase(Options, "Nested", ClassOptions::Nested);
     364         924 :   IO.bitSetCase(Options, "ContainsNestedClass",
     365             :                 ClassOptions::ContainsNestedClass);
     366         924 :   IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",
     367             :                 ClassOptions::HasOverloadedAssignmentOperator);
     368         924 :   IO.bitSetCase(Options, "HasConversionOperator",
     369             :                 ClassOptions::HasConversionOperator);
     370         924 :   IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);
     371         924 :   IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);
     372         924 :   IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);
     373         924 :   IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);
     374         924 :   IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);
     375         924 : }
     376             : 
     377           0 : void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {
     378           0 :   IO.bitSetCase(Options, "None", MethodOptions::None);
     379           0 :   IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);
     380           0 :   IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);
     381           0 :   IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);
     382           0 :   IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);
     383           0 :   IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
     384           0 : }
     385             : 
     386           0 : void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
     387           0 :   IO.mapRequired("ContainingType", MPI.ContainingType);
     388           0 :   IO.mapRequired("Representation", MPI.Representation);
     389           0 : }
     390             : 
     391             : namespace llvm {
     392             : namespace CodeViewYAML {
     393             : namespace detail {
     394             : 
     395          64 : template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {
     396          64 :   IO.mapRequired("ModifiedType", Record.ModifiedType);
     397          64 :   IO.mapRequired("Modifiers", Record.Modifiers);
     398          64 : }
     399             : 
     400          78 : template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {
     401          78 :   IO.mapRequired("ReturnType", Record.ReturnType);
     402          78 :   IO.mapRequired("CallConv", Record.CallConv);
     403          78 :   IO.mapRequired("Options", Record.Options);
     404          78 :   IO.mapRequired("ParameterCount", Record.ParameterCount);
     405          78 :   IO.mapRequired("ArgumentList", Record.ArgumentList);
     406          78 : }
     407             : 
     408         631 : template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {
     409         631 :   IO.mapRequired("ReturnType", Record.ReturnType);
     410         631 :   IO.mapRequired("ClassType", Record.ClassType);
     411         631 :   IO.mapRequired("ThisType", Record.ThisType);
     412         631 :   IO.mapRequired("CallConv", Record.CallConv);
     413         631 :   IO.mapRequired("Options", Record.Options);
     414         631 :   IO.mapRequired("ParameterCount", Record.ParameterCount);
     415         631 :   IO.mapRequired("ArgumentList", Record.ArgumentList);
     416         631 :   IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);
     417         631 : }
     418             : 
     419           0 : template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {
     420           0 :   IO.mapRequired("Mode", Record.Mode);
     421           0 : }
     422             : 
     423          23 : template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {
     424          23 :   IO.mapRequired("ClassType", Record.ClassType);
     425          23 :   IO.mapRequired("FunctionType", Record.FunctionType);
     426          23 :   IO.mapRequired("Name", Record.Name);
     427          23 : }
     428             : 
     429         284 : template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {
     430         284 :   IO.mapRequired("ArgIndices", Record.ArgIndices);
     431         284 : }
     432             : 
     433          34 : template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {
     434          34 :   IO.mapRequired("StringIndices", Record.StringIndices);
     435          34 : }
     436             : 
     437         502 : template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {
     438         502 :   IO.mapRequired("ReferentType", Record.ReferentType);
     439         502 :   IO.mapRequired("Attrs", Record.Attrs);
     440         502 :   IO.mapOptional("MemberInfo", Record.MemberInfo);
     441         502 : }
     442             : 
     443          13 : template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {
     444          13 :   IO.mapRequired("ElementType", Record.ElementType);
     445          13 :   IO.mapRequired("IndexType", Record.IndexType);
     446          13 :   IO.mapRequired("Size", Record.Size);
     447          13 :   IO.mapRequired("Name", Record.Name);
     448          13 : }
     449             : 
     450         514 : void LeafRecordImpl<FieldListRecord>::map(IO &IO) {
     451         514 :   IO.mapRequired("FieldList", Members);
     452         514 : }
     453             : 
     454             : } // end namespace detail
     455             : } // end namespace CodeViewYAML
     456             : } // end namespace llvm
     457             : 
     458             : namespace {
     459             : 
     460           0 : class MemberRecordConversionVisitor : public TypeVisitorCallbacks {
     461             : public:
     462             :   explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)
     463         242 :       : Records(Records) {}
     464             : 
     465             : #define TYPE_RECORD(EnumName, EnumVal, Name)
     466             : #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
     467             :   Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
     468             :     return visitKnownMemberImpl(Record);                                       \
     469             :   }
     470             : #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
     471             : #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
     472             : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
     473             : private:
     474        1026 :   template <typename T> Error visitKnownMemberImpl(T &Record) {
     475        1026 :     TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());
     476             :     auto Impl = std::make_shared<MemberRecordImpl<T>>(K);
     477         646 :     Impl->Record = Record;
     478        2052 :     Records.push_back(MemberRecord{Impl});
     479        1026 :     return Error::success();
     480             :   }
     481             : 
     482             :   std::vector<MemberRecord> &Records;
     483             : };
     484             : 
     485             : } // end anonymous namespace
     486             : 
     487         242 : Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {
     488         242 :   MemberRecordConversionVisitor V(Members);
     489         242 :   return visitMemberRecordStream(Type.content(), V);
     490             : }
     491             : 
     492         118 : CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(
     493             :     AppendingTypeTableBuilder &TS) const {
     494         236 :   ContinuationRecordBuilder CRB;
     495         118 :   CRB.begin(ContinuationRecordKind::FieldList);
     496         118 :   for (const auto &Member : Members) {
     497         701 :     Member.Member->writeTo(CRB);
     498             :   }
     499         118 :   TS.insertRecord(CRB);
     500         472 :   return CVType(Kind, TS.records().back());
     501             : }
     502             : 
     503         627 : void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {
     504         627 :   io.mapRequired("Type", Record.Type);
     505         627 :   io.mapRequired("Attrs", Record.Attrs.Attrs);
     506         627 :   io.mapRequired("VFTableOffset", Record.VFTableOffset);
     507         627 :   io.mapRequired("Name", Record.Name);
     508         627 : }
     509             : 
     510             : namespace llvm {
     511             : namespace CodeViewYAML {
     512             : namespace detail {
     513             : 
     514         798 : template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {
     515         798 :   IO.mapRequired("MemberCount", Record.MemberCount);
     516         798 :   IO.mapRequired("Options", Record.Options);
     517         798 :   IO.mapRequired("FieldList", Record.FieldList);
     518         798 :   IO.mapRequired("Name", Record.Name);
     519         798 :   IO.mapRequired("UniqueName", Record.UniqueName);
     520         798 :   IO.mapRequired("DerivationList", Record.DerivationList);
     521         798 :   IO.mapRequired("VTableShape", Record.VTableShape);
     522         798 :   IO.mapRequired("Size", Record.Size);
     523         798 : }
     524             : 
     525           2 : template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {
     526           2 :   IO.mapRequired("MemberCount", Record.MemberCount);
     527           2 :   IO.mapRequired("Options", Record.Options);
     528           2 :   IO.mapRequired("FieldList", Record.FieldList);
     529           2 :   IO.mapRequired("Name", Record.Name);
     530           2 :   IO.mapRequired("UniqueName", Record.UniqueName);
     531           2 :   IO.mapRequired("Size", Record.Size);
     532           2 : }
     533             : 
     534         124 : template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {
     535         124 :   IO.mapRequired("NumEnumerators", Record.MemberCount);
     536         124 :   IO.mapRequired("Options", Record.Options);
     537         124 :   IO.mapRequired("FieldList", Record.FieldList);
     538         124 :   IO.mapRequired("Name", Record.Name);
     539         124 :   IO.mapRequired("UniqueName", Record.UniqueName);
     540         124 :   IO.mapRequired("UnderlyingType", Record.UnderlyingType);
     541         124 : }
     542             : 
     543           4 : template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {
     544           4 :   IO.mapRequired("Type", Record.Type);
     545           4 :   IO.mapRequired("BitSize", Record.BitSize);
     546           4 :   IO.mapRequired("BitOffset", Record.BitOffset);
     547           4 : }
     548             : 
     549           7 : template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {
     550           7 :   IO.mapRequired("Slots", Record.Slots);
     551           7 : }
     552             : 
     553           7 : template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {
     554           7 :   IO.mapRequired("Guid", Record.Guid);
     555           7 :   IO.mapRequired("Age", Record.Age);
     556           7 :   IO.mapRequired("Name", Record.Name);
     557           7 : }
     558             : 
     559         236 : template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {
     560         236 :   IO.mapRequired("Id", Record.Id);
     561         236 :   IO.mapRequired("String", Record.String);
     562         236 : }
     563             : 
     564          67 : template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {
     565          67 :   IO.mapRequired("ParentScope", Record.ParentScope);
     566          67 :   IO.mapRequired("FunctionType", Record.FunctionType);
     567          67 :   IO.mapRequired("Name", Record.Name);
     568          67 : }
     569             : 
     570         374 : template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {
     571         374 :   IO.mapRequired("UDT", Record.UDT);
     572         374 :   IO.mapRequired("SourceFile", Record.SourceFile);
     573         374 :   IO.mapRequired("LineNumber", Record.LineNumber);
     574         374 : }
     575             : 
     576          28 : template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {
     577          28 :   IO.mapRequired("UDT", Record.UDT);
     578          28 :   IO.mapRequired("SourceFile", Record.SourceFile);
     579          28 :   IO.mapRequired("LineNumber", Record.LineNumber);
     580          28 :   IO.mapRequired("Module", Record.Module);
     581          28 : }
     582             : 
     583          35 : template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {
     584          35 :   IO.mapRequired("ArgIndices", Record.ArgIndices);
     585          35 : }
     586             : 
     587           4 : template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {
     588           4 :   IO.mapRequired("CompleteClass", Record.CompleteClass);
     589           4 :   IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);
     590           4 :   IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);
     591           4 :   IO.mapRequired("MethodNames", Record.MethodNames);
     592           4 : }
     593             : 
     594         159 : template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {
     595         159 :   IO.mapRequired("Methods", Record.Methods);
     596         159 : }
     597             : 
     598           2 : template <> void LeafRecordImpl<PrecompRecord>::map(IO &IO) {
     599           2 :   IO.mapRequired("StartTypeIndex", Record.StartTypeIndex);
     600           2 :   IO.mapRequired("TypesCount", Record.TypesCount);
     601           2 :   IO.mapRequired("Signature", Record.Signature);
     602           2 :   IO.mapRequired("PrecompFilePath", Record.PrecompFilePath);
     603           2 : }
     604             : 
     605           2 : template <> void LeafRecordImpl<EndPrecompRecord>::map(IO &IO) {
     606           2 :   IO.mapRequired("Signature", Record.Signature);
     607           2 : }
     608             : 
     609         230 : template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {
     610         230 :   MappingTraits<OneMethodRecord>::mapping(IO, Record);
     611         230 : }
     612             : 
     613         159 : template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {
     614         159 :   IO.mapRequired("NumOverloads", Record.NumOverloads);
     615         159 :   IO.mapRequired("MethodList", Record.MethodList);
     616         159 :   IO.mapRequired("Name", Record.Name);
     617         159 : }
     618             : 
     619         124 : template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {
     620         124 :   IO.mapRequired("Type", Record.Type);
     621         124 :   IO.mapRequired("Name", Record.Name);
     622         124 : }
     623             : 
     624         753 : template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {
     625         753 :   IO.mapRequired("Attrs", Record.Attrs.Attrs);
     626         753 :   IO.mapRequired("Type", Record.Type);
     627         753 :   IO.mapRequired("FieldOffset", Record.FieldOffset);
     628         753 :   IO.mapRequired("Name", Record.Name);
     629         753 : }
     630             : 
     631          76 : template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {
     632          76 :   IO.mapRequired("Attrs", Record.Attrs.Attrs);
     633          76 :   IO.mapRequired("Type", Record.Type);
     634          76 :   IO.mapRequired("Name", Record.Name);
     635          76 : }
     636             : 
     637         825 : template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {
     638         825 :   IO.mapRequired("Attrs", Record.Attrs.Attrs);
     639         825 :   IO.mapRequired("Value", Record.Value);
     640         825 :   IO.mapRequired("Name", Record.Name);
     641         825 : }
     642             : 
     643           4 : template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {
     644           4 :   IO.mapRequired("Type", Record.Type);
     645           4 : }
     646             : 
     647           6 : template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {
     648           6 :   IO.mapRequired("Attrs", Record.Attrs.Attrs);
     649           6 :   IO.mapRequired("Type", Record.Type);
     650           6 :   IO.mapRequired("Offset", Record.Offset);
     651           6 : }
     652             : 
     653           4 : template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {
     654           4 :   IO.mapRequired("Attrs", Record.Attrs.Attrs);
     655           4 :   IO.mapRequired("BaseType", Record.BaseType);
     656           4 :   IO.mapRequired("VBPtrType", Record.VBPtrType);
     657           4 :   IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);
     658           4 :   IO.mapRequired("VTableIndex", Record.VTableIndex);
     659           4 : }
     660             : 
     661           0 : template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {
     662           0 :   IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);
     663           0 : }
     664             : 
     665             : } // end namespace detail
     666             : } // end namespace CodeViewYAML
     667             : } // end namespace llvm
     668             : 
     669             : template <typename T>
     670        1648 : static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
     671        1648 :   LeafRecord Result;
     672             : 
     673        3296 :   auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
     674        4944 :   if (auto EC = Impl->fromCodeViewRecord(Type))
     675             :     return std::move(EC);
     676             :   Result.Leaf = Impl;
     677             :   return Result;
     678             : }
     679             : 
     680        1648 : Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {
     681             : #define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \
     682             :   case EnumName:                                                               \
     683             :     return fromCodeViewRecordImpl<ClassName##Record>(Type);
     684             : #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)             \
     685             :   TYPE_RECORD(EnumName, EnumVal, ClassName)
     686             : #define MEMBER_RECORD(EnumName, EnumVal, ClassName)
     687             : #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
     688        1648 :   switch (Type.kind()) {
     689             : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
     690           0 :   default:
     691           0 :       llvm_unreachable("Unknown leaf kind!");
     692             :   }
     693             :   return make_error<CodeViewError>(cv_error_code::corrupt_record);
     694             : }
     695             : 
     696             : CVType
     697         438 : LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {
     698         438 :   return Leaf->toCodeViewRecord(Serializer);
     699             : }
     700             : 
     701             : namespace llvm {
     702             : namespace yaml {
     703             : 
     704             : template <> struct MappingTraits<LeafRecordBase> {
     705        3478 :   static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }
     706             : };
     707             : 
     708             : template <> struct MappingTraits<MemberRecordBase> {
     709        2181 :   static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }
     710             : };
     711             : 
     712             : } // end namespace yaml
     713             : } // end namespace llvm
     714             : 
     715             : template <typename ConcreteType>
     716        3992 : static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
     717             :                               LeafRecord &Obj) {
     718        3992 :   if (!IO.outputting())
     719        2344 :     Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);
     720             : 
     721        3992 :   if (Kind == LF_FIELDLIST)
     722         514 :     Obj.Leaf->map(IO);
     723             :   else
     724             :     IO.mapRequired(Class, *Obj.Leaf);
     725        3992 : }
     726             : 
     727        3992 : void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {
     728             :   TypeLeafKind Kind;
     729        3992 :   if (IO.outputting())
     730        1648 :     Kind = Obj.Leaf->Kind;
     731             :   IO.mapRequired("Kind", Kind);
     732             : 
     733             : #define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \
     734             :   case EnumName:                                                               \
     735             :     mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj);           \
     736             :     break;
     737             : #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)             \
     738             :   TYPE_RECORD(EnumName, EnumVal, ClassName)
     739             : #define MEMBER_RECORD(EnumName, EnumVal, ClassName)
     740             : #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
     741        3992 :   switch (Kind) {
     742             : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
     743           0 :   default: { llvm_unreachable("Unknown leaf kind!"); }
     744             :   }
     745        3992 : }
     746             : 
     747             : template <typename ConcreteType>
     748        2181 : static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
     749             :                                 MemberRecord &Obj) {
     750        2181 :   if (!IO.outputting())
     751        1155 :     Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);
     752             : 
     753             :   IO.mapRequired(Class, *Obj.Member);
     754        2181 : }
     755             : 
     756        2181 : void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {
     757             :   TypeLeafKind Kind;
     758        2181 :   if (IO.outputting())
     759        1026 :     Kind = Obj.Member->Kind;
     760             :   IO.mapRequired("Kind", Kind);
     761             : 
     762             : #define MEMBER_RECORD(EnumName, EnumVal, ClassName)                            \
     763             :   case EnumName:                                                               \
     764             :     mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj);         \
     765             :     break;
     766             : #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)           \
     767             :   MEMBER_RECORD(EnumName, EnumVal, ClassName)
     768             : #define TYPE_RECORD(EnumName, EnumVal, ClassName)
     769             : #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
     770        2181 :   switch (Kind) {
     771             : #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
     772           0 :   default: { llvm_unreachable("Unknown member kind!"); }
     773             :   }
     774        2181 : }
     775             : 
     776             : std::vector<LeafRecord>
     777           5 : llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugTorP,
     778             :                                StringRef SectionName) {
     779          25 :   ExitOnError Err("Invalid " + std::string(SectionName) + " section!");
     780           5 :   BinaryStreamReader Reader(DebugTorP, support::little);
     781             :   CVTypeArray Types;
     782             :   uint32_t Magic;
     783             : 
     784          10 :   Err(Reader.readInteger(Magic));
     785             :   assert(Magic == COFF::DEBUG_SECTION_MAGIC &&
     786             :          "Invalid .debug$T or .debug$P section!");
     787             : 
     788             :   std::vector<LeafRecord> Result;
     789          10 :   Err(Reader.readArray(Types, Reader.bytesRemaining()));
     790        1079 :   for (const auto &T : Types) {
     791        1074 :     auto CVT = Err(LeafRecord::fromCodeViewRecord(T));
     792        1074 :     Result.push_back(CVT);
     793             :   }
     794           5 :   return Result;
     795             : }
     796             : 
     797          32 : ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,
     798             :                                                BumpPtrAllocator &Alloc,
     799             :                                                StringRef SectionName) {
     800          64 :   AppendingTypeTableBuilder TS(Alloc);
     801             :   uint32_t Size = sizeof(uint32_t);
     802        1608 :   for (const auto &Leaf : Leafs) {
     803         788 :     CVType T = Leaf.Leaf->toCodeViewRecord(TS);
     804         788 :     Size += T.length();
     805             :     assert(T.length() % 4 == 0 && "Improper type record alignment!");
     806             :   }
     807          32 :   uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);
     808             :   MutableArrayRef<uint8_t> Output(ResultBuffer, Size);
     809          32 :   BinaryStreamWriter Writer(Output, support::little);
     810         128 :   ExitOnError Err("Error writing type record to " + std::string(SectionName) +
     811          32 :                   " section");
     812          64 :   Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));
     813        1640 :   for (const auto &R : TS.records()) {
     814        1576 :     Err(Writer.writeBytes(R));
     815             :   }
     816             :   assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!");
     817          64 :   return Output;
     818             : }

Generated by: LCOV version 1.13