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