Home | History | Annotate | Line # | Download | only in ObjectYAML 
      1 //===- CodeViewYAMLSymbols.cpp - CodeView YAMLIO Symbol 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/CodeViewYAMLSymbols.h"
     15 #include "llvm/ADT/ArrayRef.h"
     16 #include "llvm/ADT/StringRef.h"
     17 #include "llvm/DebugInfo/CodeView/CodeView.h"
     18 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
     19 #include "llvm/DebugInfo/CodeView/EnumTables.h"
     20 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
     21 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
     22 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
     23 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
     24 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
     25 #include "llvm/ObjectYAML/YAML.h"
     26 #include "llvm/Support/Allocator.h"
     27 #include "llvm/Support/Error.h"
     28 #include "llvm/Support/YAMLTraits.h"
     29 #include <algorithm>
     30 #include <cstdint>
     31 #include <cstring>
     32 #include <string>
     33 #include <vector>
     34 
     35 using namespace llvm;
     36 using namespace llvm::codeview;
     37 using namespace llvm::CodeViewYAML;
     38 using namespace llvm::CodeViewYAML::detail;
     39 using namespace llvm::yaml;
     40 
     41 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
     42 LLVM_YAML_IS_SEQUENCE_VECTOR(LocalVariableAddrGap)
     43 
     44 // We only need to declare these, the definitions are in CodeViewYAMLTypes.cpp
     45 LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)
     46 LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)
     47 
     48 LLVM_YAML_DECLARE_ENUM_TRAITS(SymbolKind)
     49 LLVM_YAML_DECLARE_ENUM_TRAITS(FrameCookieKind)
     50 
     51 LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym2Flags)
     52 LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym3Flags)
     53 LLVM_YAML_DECLARE_BITSET_TRAITS(ExportFlags)
     54 LLVM_YAML_DECLARE_BITSET_TRAITS(PublicSymFlags)
     55 LLVM_YAML_DECLARE_BITSET_TRAITS(LocalSymFlags)
     56 LLVM_YAML_DECLARE_BITSET_TRAITS(ProcSymFlags)
     57 LLVM_YAML_DECLARE_BITSET_TRAITS(FrameProcedureOptions)
     58 LLVM_YAML_DECLARE_ENUM_TRAITS(CPUType)
     59 LLVM_YAML_DECLARE_ENUM_TRAITS(RegisterId)
     60 LLVM_YAML_DECLARE_ENUM_TRAITS(TrampolineType)
     61 LLVM_YAML_DECLARE_ENUM_TRAITS(ThunkOrdinal)
     62 
     63 LLVM_YAML_STRONG_TYPEDEF(StringRef, TypeName)
     64 
     65 LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeName, QuotingType::Single)
     66 
     67 StringRef ScalarTraits<TypeName>::input(StringRef S, void *V, TypeName &T) {
     68   return ScalarTraits<StringRef>::input(S, V, T.value);
     69 }
     70 
     71 void ScalarTraits<TypeName>::output(const TypeName &T, void *V,
     72                                     raw_ostream &R) {
     73   ScalarTraits<StringRef>::output(T.value, V, R);
     74 }
     75 
     76 void ScalarEnumerationTraits<SymbolKind>::enumeration(IO &io,
     77                                                       SymbolKind &Value) {
     78   auto SymbolNames = getSymbolTypeNames();
     79   for (const auto &E : SymbolNames)
     80     io.enumCase(Value, E.Name.str().c_str(), E.Value);
     81 }
     82 
     83 void ScalarBitSetTraits<CompileSym2Flags>::bitset(IO &io,
     84                                                   CompileSym2Flags &Flags) {
     85   auto FlagNames = getCompileSym2FlagNames();
     86   for (const auto &E : FlagNames) {
     87     io.bitSetCase(Flags, E.Name.str().c_str(),
     88                   static_cast<CompileSym2Flags>(E.Value));
     89   }
     90 }
     91 
     92 void ScalarBitSetTraits<CompileSym3Flags>::bitset(IO &io,
     93                                                   CompileSym3Flags &Flags) {
     94   auto FlagNames = getCompileSym3FlagNames();
     95   for (const auto &E : FlagNames) {
     96     io.bitSetCase(Flags, E.Name.str().c_str(),
     97                   static_cast<CompileSym3Flags>(E.Value));
     98   }
     99 }
    100 
    101 void ScalarBitSetTraits<ExportFlags>::bitset(IO &io, ExportFlags &Flags) {
    102   auto FlagNames = getExportSymFlagNames();
    103   for (const auto &E : FlagNames) {
    104     io.bitSetCase(Flags, E.Name.str().c_str(),
    105                   static_cast<ExportFlags>(E.Value));
    106   }
    107 }
    108 
    109 void ScalarBitSetTraits<PublicSymFlags>::bitset(IO &io, PublicSymFlags &Flags) {
    110   auto FlagNames = getPublicSymFlagNames();
    111   for (const auto &E : FlagNames) {
    112     io.bitSetCase(Flags, E.Name.str().c_str(),
    113                   static_cast<PublicSymFlags>(E.Value));
    114   }
    115 }
    116 
    117 void ScalarBitSetTraits<LocalSymFlags>::bitset(IO &io, LocalSymFlags &Flags) {
    118   auto FlagNames = getLocalFlagNames();
    119   for (const auto &E : FlagNames) {
    120     io.bitSetCase(Flags, E.Name.str().c_str(),
    121                   static_cast<LocalSymFlags>(E.Value));
    122   }
    123 }
    124 
    125 void ScalarBitSetTraits<ProcSymFlags>::bitset(IO &io, ProcSymFlags &Flags) {
    126   auto FlagNames = getProcSymFlagNames();
    127   for (const auto &E : FlagNames) {
    128     io.bitSetCase(Flags, E.Name.str().c_str(),
    129                   static_cast<ProcSymFlags>(E.Value));
    130   }
    131 }
    132 
    133 void ScalarBitSetTraits<FrameProcedureOptions>::bitset(
    134     IO &io, FrameProcedureOptions &Flags) {
    135   auto FlagNames = getFrameProcSymFlagNames();
    136   for (const auto &E : FlagNames) {
    137     io.bitSetCase(Flags, E.Name.str().c_str(),
    138                   static_cast<FrameProcedureOptions>(E.Value));
    139   }
    140 }
    141 
    142 void ScalarEnumerationTraits<CPUType>::enumeration(IO &io, CPUType &Cpu) {
    143   auto CpuNames = getCPUTypeNames();
    144   for (const auto &E : CpuNames) {
    145     io.enumCase(Cpu, E.Name.str().c_str(), static_cast<CPUType>(E.Value));
    146   }
    147 }
    148 
    149 void ScalarEnumerationTraits<RegisterId>::enumeration(IO &io, RegisterId &Reg) {
    150   const auto *Header = static_cast<COFF::header *>(io.getContext());
    151   assert(Header && "The IO context is not initialized");
    152 
    153   Optional<CPUType> CpuType;
    154   ArrayRef<EnumEntry<uint16_t>> RegNames;
    155 
    156   switch (Header->Machine) {
    157   case COFF::IMAGE_FILE_MACHINE_I386:
    158     CpuType = CPUType::Pentium3;
    159     break;
    160   case COFF::IMAGE_FILE_MACHINE_AMD64:
    161     CpuType = CPUType::X64;
    162     break;
    163   case COFF::IMAGE_FILE_MACHINE_ARMNT:
    164     CpuType = CPUType::ARMNT;
    165     break;
    166   case COFF::IMAGE_FILE_MACHINE_ARM64:
    167     CpuType = CPUType::ARM64;
    168     break;
    169   }
    170 
    171   if (CpuType)
    172     RegNames = getRegisterNames(*CpuType);
    173 
    174   for (const auto &E : RegNames) {
    175     io.enumCase(Reg, E.Name.str().c_str(), static_cast<RegisterId>(E.Value));
    176   }
    177   io.enumFallback<Hex16>(Reg);
    178 }
    179 
    180 void ScalarEnumerationTraits<TrampolineType>::enumeration(
    181     IO &io, TrampolineType &Tramp) {
    182   auto TrampNames = getTrampolineNames();
    183   for (const auto &E : TrampNames) {
    184     io.enumCase(Tramp, E.Name.str().c_str(),
    185                 static_cast<TrampolineType>(E.Value));
    186   }
    187 }
    188 
    189 void ScalarEnumerationTraits<ThunkOrdinal>::enumeration(IO &io,
    190                                                         ThunkOrdinal &Ord) {
    191   auto ThunkNames = getThunkOrdinalNames();
    192   for (const auto &E : ThunkNames) {
    193     io.enumCase(Ord, E.Name.str().c_str(), static_cast<ThunkOrdinal>(E.Value));
    194   }
    195 }
    196 
    197 void ScalarEnumerationTraits<FrameCookieKind>::enumeration(
    198     IO &io, FrameCookieKind &FC) {
    199   auto ThunkNames = getFrameCookieKindNames();
    200   for (const auto &E : ThunkNames) {
    201     io.enumCase(FC, E.Name.str().c_str(),
    202                 static_cast<FrameCookieKind>(E.Value));
    203   }
    204 }
    205 
    206 namespace llvm {
    207 namespace yaml {
    208 template <> struct MappingTraits<LocalVariableAddrRange> {
    209   static void mapping(IO &io, LocalVariableAddrRange &Range) {
    210     io.mapRequired("OffsetStart", Range.OffsetStart);
    211     io.mapRequired("ISectStart", Range.ISectStart);
    212     io.mapRequired("Range", Range.Range);
    213   }
    214 };
    215 template <> struct MappingTraits<LocalVariableAddrGap> {
    216   static void mapping(IO &io, LocalVariableAddrGap &Gap) {
    217     io.mapRequired("GapStartOffset", Gap.GapStartOffset);
    218     io.mapRequired("Range", Gap.Range);
    219   }
    220 };
    221 } // namespace yaml
    222 } // namespace llvm
    223 
    224 namespace llvm {
    225 namespace CodeViewYAML {
    226 namespace detail {
    227 
    228 struct SymbolRecordBase {
    229   codeview::SymbolKind Kind;
    230 
    231   explicit SymbolRecordBase(codeview::SymbolKind K) : Kind(K) {}
    232   virtual ~SymbolRecordBase() = default;
    233 
    234   virtual void map(yaml::IO &io) = 0;
    235   virtual codeview::CVSymbol
    236   toCodeViewSymbol(BumpPtrAllocator &Allocator,
    237                    CodeViewContainer Container) const = 0;
    238   virtual Error fromCodeViewSymbol(codeview::CVSymbol Type) = 0;
    239 };
    240 
    241 template <typename T> struct SymbolRecordImpl : public SymbolRecordBase {
    242   explicit SymbolRecordImpl(codeview::SymbolKind K)
    243       : SymbolRecordBase(K), Symbol(static_cast<SymbolRecordKind>(K)) {}
    244 
    245   void map(yaml::IO &io) override;
    246 
    247   codeview::CVSymbol
    248   toCodeViewSymbol(BumpPtrAllocator &Allocator,
    249                    CodeViewContainer Container) const override {
    250     return SymbolSerializer::writeOneSymbol(Symbol, Allocator, Container);
    251   }
    252 
    253   Error fromCodeViewSymbol(codeview::CVSymbol CVS) override {
    254     return SymbolDeserializer::deserializeAs<T>(CVS, Symbol);
    255   }
    256 
    257   mutable T Symbol;
    258 };
    259 
    260 struct UnknownSymbolRecord : public SymbolRecordBase {
    261   explicit UnknownSymbolRecord(codeview::SymbolKind K) : SymbolRecordBase(K) {}
    262 
    263   void map(yaml::IO &io) override;
    264 
    265   CVSymbol toCodeViewSymbol(BumpPtrAllocator &Allocator,
    266                             CodeViewContainer Container) const override {
    267     RecordPrefix Prefix;
    268     uint32_t TotalLen = sizeof(RecordPrefix) + Data.size();
    269     Prefix.RecordKind = Kind;
    270     Prefix.RecordLen = TotalLen - 2;
    271     uint8_t *Buffer = Allocator.Allocate<uint8_t>(TotalLen);
    272     ::memcpy(Buffer, &Prefix, sizeof(RecordPrefix));
    273     ::memcpy(Buffer + sizeof(RecordPrefix), Data.data(), Data.size());
    274     return CVSymbol(ArrayRef<uint8_t>(Buffer, TotalLen));
    275   }
    276 
    277   Error fromCodeViewSymbol(CVSymbol CVS) override {
    278     this->Kind = CVS.kind();
    279     Data = CVS.RecordData.drop_front(sizeof(RecordPrefix));
    280     return Error::success();
    281   }
    282 
    283   std::vector<uint8_t> Data;
    284 };
    285 
    286 template <> void SymbolRecordImpl<ScopeEndSym>::map(IO &IO) {}
    287 
    288 void UnknownSymbolRecord::map(yaml::IO &io) {
    289   yaml::BinaryRef Binary;
    290   if (io.outputting())
    291     Binary = yaml::BinaryRef(Data);
    292   io.mapRequired("Data", Binary);
    293   if (!io.outputting()) {
    294     std::string Str;
    295     raw_string_ostream OS(Str);
    296     Binary.writeAsBinary(OS);
    297     OS.flush();
    298     Data.assign(Str.begin(), Str.end());
    299   }
    300 }
    301 
    302 template <> void SymbolRecordImpl<Thunk32Sym>::map(IO &IO) {
    303   IO.mapRequired("Parent", Symbol.Parent);
    304   IO.mapRequired("End", Symbol.End);
    305   IO.mapRequired("Next", Symbol.Next);
    306   IO.mapRequired("Off", Symbol.Offset);
    307   IO.mapRequired("Seg", Symbol.Segment);
    308   IO.mapRequired("Len", Symbol.Length);
    309   IO.mapRequired("Ordinal", Symbol.Thunk);
    310 }
    311 
    312 template <> void SymbolRecordImpl<TrampolineSym>::map(IO &IO) {
    313   IO.mapRequired("Type", Symbol.Type);
    314   IO.mapRequired("Size", Symbol.Size);
    315   IO.mapRequired("ThunkOff", Symbol.ThunkOffset);
    316   IO.mapRequired("TargetOff", Symbol.TargetOffset);
    317   IO.mapRequired("ThunkSection", Symbol.ThunkSection);
    318   IO.mapRequired("TargetSection", Symbol.TargetSection);
    319 }
    320 
    321 template <> void SymbolRecordImpl<SectionSym>::map(IO &IO) {
    322   IO.mapRequired("SectionNumber", Symbol.SectionNumber);
    323   IO.mapRequired("Alignment", Symbol.Alignment);
    324   IO.mapRequired("Rva", Symbol.Rva);
    325   IO.mapRequired("Length", Symbol.Length);
    326   IO.mapRequired("Characteristics", Symbol.Characteristics);
    327   IO.mapRequired("Name", Symbol.Name);
    328 }
    329 
    330 template <> void SymbolRecordImpl<CoffGroupSym>::map(IO &IO) {
    331   IO.mapRequired("Size", Symbol.Size);
    332   IO.mapRequired("Characteristics", Symbol.Characteristics);
    333   IO.mapRequired("Offset", Symbol.Offset);
    334   IO.mapRequired("Segment", Symbol.Segment);
    335   IO.mapRequired("Name", Symbol.Name);
    336 }
    337 
    338 template <> void SymbolRecordImpl<ExportSym>::map(IO &IO) {
    339   IO.mapRequired("Ordinal", Symbol.Ordinal);
    340   IO.mapRequired("Flags", Symbol.Flags);
    341   IO.mapRequired("Name", Symbol.Name);
    342 }
    343 
    344 template <> void SymbolRecordImpl<ProcSym>::map(IO &IO) {
    345   IO.mapOptional("PtrParent", Symbol.Parent, 0U);
    346   IO.mapOptional("PtrEnd", Symbol.End, 0U);
    347   IO.mapOptional("PtrNext", Symbol.Next, 0U);
    348   IO.mapRequired("CodeSize", Symbol.CodeSize);
    349   IO.mapRequired("DbgStart", Symbol.DbgStart);
    350   IO.mapRequired("DbgEnd", Symbol.DbgEnd);
    351   IO.mapRequired("FunctionType", Symbol.FunctionType);
    352   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
    353   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    354   IO.mapRequired("Flags", Symbol.Flags);
    355   IO.mapRequired("DisplayName", Symbol.Name);
    356 }
    357 
    358 template <> void SymbolRecordImpl<RegisterSym>::map(IO &IO) {
    359   IO.mapRequired("Type", Symbol.Index);
    360   IO.mapRequired("Seg", Symbol.Register);
    361   IO.mapRequired("Name", Symbol.Name);
    362 }
    363 
    364 template <> void SymbolRecordImpl<PublicSym32>::map(IO &IO) {
    365   IO.mapRequired("Flags", Symbol.Flags);
    366   IO.mapOptional("Offset", Symbol.Offset, 0U);
    367   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    368   IO.mapRequired("Name", Symbol.Name);
    369 }
    370 
    371 template <> void SymbolRecordImpl<ProcRefSym>::map(IO &IO) {
    372   IO.mapRequired("SumName", Symbol.SumName);
    373   IO.mapRequired("SymOffset", Symbol.SymOffset);
    374   IO.mapRequired("Mod", Symbol.Module);
    375   IO.mapRequired("Name", Symbol.Name);
    376 }
    377 
    378 template <> void SymbolRecordImpl<EnvBlockSym>::map(IO &IO) {
    379   IO.mapRequired("Entries", Symbol.Fields);
    380 }
    381 
    382 template <> void SymbolRecordImpl<InlineSiteSym>::map(IO &IO) {
    383   IO.mapOptional("PtrParent", Symbol.Parent, 0U);
    384   IO.mapOptional("PtrEnd", Symbol.End, 0U);
    385   IO.mapRequired("Inlinee", Symbol.Inlinee);
    386   // TODO: The binary annotations
    387 }
    388 
    389 template <> void SymbolRecordImpl<LocalSym>::map(IO &IO) {
    390   IO.mapRequired("Type", Symbol.Type);
    391   IO.mapRequired("Flags", Symbol.Flags);
    392 
    393   IO.mapRequired("VarName", Symbol.Name);
    394 }
    395 
    396 template <> void SymbolRecordImpl<DefRangeSym>::map(IO &IO) {
    397   IO.mapRequired("Program", Symbol.Program);
    398   IO.mapRequired("Range", Symbol.Range);
    399   IO.mapRequired("Gaps", Symbol.Gaps);
    400 }
    401 
    402 template <> void SymbolRecordImpl<DefRangeSubfieldSym>::map(IO &IO) {
    403   IO.mapRequired("Program", Symbol.Program);
    404   IO.mapRequired("OffsetInParent", Symbol.OffsetInParent);
    405   IO.mapRequired("Range", Symbol.Range);
    406   IO.mapRequired("Gaps", Symbol.Gaps);
    407 }
    408 
    409 template <> void SymbolRecordImpl<DefRangeRegisterSym>::map(IO &IO) {
    410   IO.mapRequired("Register", Symbol.Hdr.Register);
    411   IO.mapRequired("MayHaveNoName", Symbol.Hdr.MayHaveNoName);
    412   IO.mapRequired("Range", Symbol.Range);
    413   IO.mapRequired("Gaps", Symbol.Gaps);
    414 }
    415 
    416 template <> void SymbolRecordImpl<DefRangeFramePointerRelSym>::map(IO &IO) {
    417   IO.mapRequired("Offset", Symbol.Hdr.Offset);
    418   IO.mapRequired("Range", Symbol.Range);
    419   IO.mapRequired("Gaps", Symbol.Gaps);
    420 }
    421 
    422 template <> void SymbolRecordImpl<DefRangeSubfieldRegisterSym>::map(IO &IO) {
    423   IO.mapRequired("Register", Symbol.Hdr.Register);
    424   IO.mapRequired("MayHaveNoName", Symbol.Hdr.MayHaveNoName);
    425   IO.mapRequired("OffsetInParent", Symbol.Hdr.OffsetInParent);
    426   IO.mapRequired("Range", Symbol.Range);
    427   IO.mapRequired("Gaps", Symbol.Gaps);
    428 }
    429 
    430 template <>
    431 void SymbolRecordImpl<DefRangeFramePointerRelFullScopeSym>::map(IO &IO) {
    432   IO.mapRequired("Register", Symbol.Offset);
    433 }
    434 
    435 template <> void SymbolRecordImpl<DefRangeRegisterRelSym>::map(IO &IO) {
    436   IO.mapRequired("Register", Symbol.Hdr.Register);
    437   IO.mapRequired("Flags", Symbol.Hdr.Flags);
    438   IO.mapRequired("BasePointerOffset", Symbol.Hdr.BasePointerOffset);
    439   IO.mapRequired("Range", Symbol.Range);
    440   IO.mapRequired("Gaps", Symbol.Gaps);
    441 }
    442 
    443 template <> void SymbolRecordImpl<BlockSym>::map(IO &IO) {
    444   IO.mapOptional("PtrParent", Symbol.Parent, 0U);
    445   IO.mapOptional("PtrEnd", Symbol.End, 0U);
    446   IO.mapRequired("CodeSize", Symbol.CodeSize);
    447   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
    448   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    449   IO.mapRequired("BlockName", Symbol.Name);
    450 }
    451 
    452 template <> void SymbolRecordImpl<LabelSym>::map(IO &IO) {
    453   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
    454   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    455   IO.mapRequired("Flags", Symbol.Flags);
    456   IO.mapRequired("Flags", Symbol.Flags);
    457   IO.mapRequired("DisplayName", Symbol.Name);
    458 }
    459 
    460 template <> void SymbolRecordImpl<ObjNameSym>::map(IO &IO) {
    461   IO.mapRequired("Signature", Symbol.Signature);
    462   IO.mapRequired("ObjectName", Symbol.Name);
    463 }
    464 
    465 template <> void SymbolRecordImpl<Compile2Sym>::map(IO &IO) {
    466   IO.mapRequired("Flags", Symbol.Flags);
    467   IO.mapRequired("Machine", Symbol.Machine);
    468   IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor);
    469   IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor);
    470   IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild);
    471   IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor);
    472   IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor);
    473   IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild);
    474   IO.mapRequired("Version", Symbol.Version);
    475 }
    476 
    477 template <> void SymbolRecordImpl<Compile3Sym>::map(IO &IO) {
    478   IO.mapRequired("Flags", Symbol.Flags);
    479   IO.mapRequired("Machine", Symbol.Machine);
    480   IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor);
    481   IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor);
    482   IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild);
    483   IO.mapRequired("FrontendQFE", Symbol.VersionFrontendQFE);
    484   IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor);
    485   IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor);
    486   IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild);
    487   IO.mapRequired("BackendQFE", Symbol.VersionBackendQFE);
    488   IO.mapRequired("Version", Symbol.Version);
    489 }
    490 
    491 template <> void SymbolRecordImpl<FrameProcSym>::map(IO &IO) {
    492   IO.mapRequired("TotalFrameBytes", Symbol.TotalFrameBytes);
    493   IO.mapRequired("PaddingFrameBytes", Symbol.PaddingFrameBytes);
    494   IO.mapRequired("OffsetToPadding", Symbol.OffsetToPadding);
    495   IO.mapRequired("BytesOfCalleeSavedRegisters",
    496                  Symbol.BytesOfCalleeSavedRegisters);
    497   IO.mapRequired("OffsetOfExceptionHandler", Symbol.OffsetOfExceptionHandler);
    498   IO.mapRequired("SectionIdOfExceptionHandler",
    499                  Symbol.SectionIdOfExceptionHandler);
    500   IO.mapRequired("Flags", Symbol.Flags);
    501 }
    502 
    503 template <> void SymbolRecordImpl<CallSiteInfoSym>::map(IO &IO) {
    504   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
    505   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    506   IO.mapRequired("Type", Symbol.Type);
    507 }
    508 
    509 template <> void SymbolRecordImpl<FileStaticSym>::map(IO &IO) {
    510   IO.mapRequired("Index", Symbol.Index);
    511   IO.mapRequired("ModFilenameOffset", Symbol.ModFilenameOffset);
    512   IO.mapRequired("Flags", Symbol.Flags);
    513   IO.mapRequired("Name", Symbol.Name);
    514 }
    515 
    516 template <> void SymbolRecordImpl<HeapAllocationSiteSym>::map(IO &IO) {
    517   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
    518   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    519   IO.mapRequired("CallInstructionSize", Symbol.CallInstructionSize);
    520   IO.mapRequired("Type", Symbol.Type);
    521 }
    522 
    523 template <> void SymbolRecordImpl<FrameCookieSym>::map(IO &IO) {
    524   IO.mapRequired("Register", Symbol.Register);
    525   IO.mapRequired("CookieKind", Symbol.CookieKind);
    526   IO.mapRequired("Flags", Symbol.Flags);
    527 }
    528 
    529 template <> void SymbolRecordImpl<CallerSym>::map(IO &IO) {
    530   IO.mapRequired("FuncID", Symbol.Indices);
    531 }
    532 
    533 template <> void SymbolRecordImpl<UDTSym>::map(IO &IO) {
    534   IO.mapRequired("Type", Symbol.Type);
    535   IO.mapRequired("UDTName", Symbol.Name);
    536 }
    537 
    538 template <> void SymbolRecordImpl<BuildInfoSym>::map(IO &IO) {
    539   IO.mapRequired("BuildId", Symbol.BuildId);
    540 }
    541 
    542 template <> void SymbolRecordImpl<BPRelativeSym>::map(IO &IO) {
    543   IO.mapRequired("Offset", Symbol.Offset);
    544   IO.mapRequired("Type", Symbol.Type);
    545   IO.mapRequired("VarName", Symbol.Name);
    546 }
    547 
    548 template <> void SymbolRecordImpl<RegRelativeSym>::map(IO &IO) {
    549   IO.mapRequired("Offset", Symbol.Offset);
    550   IO.mapRequired("Type", Symbol.Type);
    551   IO.mapRequired("Register", Symbol.Register);
    552   IO.mapRequired("VarName", Symbol.Name);
    553 }
    554 
    555 template <> void SymbolRecordImpl<ConstantSym>::map(IO &IO) {
    556   IO.mapRequired("Type", Symbol.Type);
    557   IO.mapRequired("Value", Symbol.Value);
    558   IO.mapRequired("Name", Symbol.Name);
    559 }
    560 
    561 template <> void SymbolRecordImpl<DataSym>::map(IO &IO) {
    562   IO.mapRequired("Type", Symbol.Type);
    563   IO.mapOptional("Offset", Symbol.DataOffset, 0U);
    564   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    565   IO.mapRequired("DisplayName", Symbol.Name);
    566 }
    567 
    568 template <> void SymbolRecordImpl<ThreadLocalDataSym>::map(IO &IO) {
    569   IO.mapRequired("Type", Symbol.Type);
    570   IO.mapOptional("Offset", Symbol.DataOffset, 0U);
    571   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    572   IO.mapRequired("DisplayName", Symbol.Name);
    573 }
    574 
    575 template <> void SymbolRecordImpl<UsingNamespaceSym>::map(IO &IO) {
    576   IO.mapRequired("Namespace", Symbol.Name);
    577 }
    578 
    579 template <> void SymbolRecordImpl<AnnotationSym>::map(IO &IO) {
    580   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
    581   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
    582   IO.mapRequired("Strings", Symbol.Strings);
    583 }
    584 
    585 } // end namespace detail
    586 } // end namespace CodeViewYAML
    587 } // end namespace llvm
    588 
    589 CVSymbol CodeViewYAML::SymbolRecord::toCodeViewSymbol(
    590     BumpPtrAllocator &Allocator, CodeViewContainer Container) const {
    591   return Symbol->toCodeViewSymbol(Allocator, Container);
    592 }
    593 
    594 namespace llvm {
    595 namespace yaml {
    596 
    597 template <> struct MappingTraits<SymbolRecordBase> {
    598   static void mapping(IO &io, SymbolRecordBase &Record) { Record.map(io); }
    599 };
    600 
    601 } // end namespace yaml
    602 } // end namespace llvm
    603 
    604 template <typename SymbolType>
    605 static inline Expected<CodeViewYAML::SymbolRecord>
    606 fromCodeViewSymbolImpl(CVSymbol Symbol) {
    607   CodeViewYAML::SymbolRecord Result;
    608 
    609   auto Impl = std::make_shared<SymbolType>(Symbol.kind());
    610   if (auto EC = Impl->fromCodeViewSymbol(Symbol))
    611     return std::move(EC);
    612   Result.Symbol = Impl;
    613   return Result;
    614 }
    615 
    616 Expected<CodeViewYAML::SymbolRecord>
    617 CodeViewYAML::SymbolRecord::fromCodeViewSymbol(CVSymbol Symbol) {
    618 #define SYMBOL_RECORD(EnumName, EnumVal, ClassName)                            \
    619   case EnumName:                                                               \
    620     return fromCodeViewSymbolImpl<SymbolRecordImpl<ClassName>>(Symbol);
    621 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)           \
    622   SYMBOL_RECORD(EnumName, EnumVal, ClassName)
    623   switch (Symbol.kind()) {
    624 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
    625   default:
    626     return fromCodeViewSymbolImpl<UnknownSymbolRecord>(Symbol);
    627   }
    628   return make_error<CodeViewError>(cv_error_code::corrupt_record);
    629 }
    630 
    631 template <typename ConcreteType>
    632 static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind,
    633                                 CodeViewYAML::SymbolRecord &Obj) {
    634   if (!IO.outputting())
    635     Obj.Symbol = std::make_shared<ConcreteType>(Kind);
    636 
    637   IO.mapRequired(Class, *Obj.Symbol);
    638 }
    639 
    640 void MappingTraits<CodeViewYAML::SymbolRecord>::mapping(
    641     IO &IO, CodeViewYAML::SymbolRecord &Obj) {
    642   SymbolKind Kind;
    643   if (IO.outputting())
    644     Kind = Obj.Symbol->Kind;
    645   IO.mapRequired("Kind", Kind);
    646 
    647 #define SYMBOL_RECORD(EnumName, EnumVal, ClassName)                            \
    648   case EnumName:                                                               \
    649     mapSymbolRecordImpl<SymbolRecordImpl<ClassName>>(IO, #ClassName, Kind,     \
    650                                                      Obj);                     \
    651     break;
    652 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)           \
    653   SYMBOL_RECORD(EnumName, EnumVal, ClassName)
    654   switch (Kind) {
    655 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
    656   default:
    657     mapSymbolRecordImpl<UnknownSymbolRecord>(IO, "UnknownSym", Kind, Obj);
    658   }
    659 }
    660