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