contrib/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp

   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 }