Fix line endings (CR/LF -> LF) introduced by rL329613

reviewer: zturner
llvm-svn: 329646

4 files changed, 2218 insertions, 2218 deletions

diff --git a/llvm/lib/DebugInfo/CodeView/RecordName.cpp b/llvm/lib/DebugInfo/CodeView/RecordName.cpp
index d18d346e86a..576b3958485 100644
--- a/llvm/lib/DebugInfo/CodeView/RecordName.cpp
+++ b/llvm/lib/DebugInfo/CodeView/RecordName.cpp
@@ -1,333 +1,333 @@
-//===- RecordName.cpp ----------------------------------------- *- C++ --*-===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-

-#include "llvm/DebugInfo/CodeView/RecordName.h"

-

-#include "llvm/ADT/SmallString.h"

-#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"

-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"

-#include "llvm/DebugInfo/CodeView/SymbolRecordMapping.h"

-#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"

-#include "llvm/Support/FormatVariadic.h"

-

-using namespace llvm;

-using namespace llvm::codeview;

-

-namespace {

-class TypeNameComputer : public TypeVisitorCallbacks {

-  /// The type collection.  Used to calculate names of nested types.

-  TypeCollection &Types;

-  TypeIndex CurrentTypeIndex = TypeIndex::None();

-

-  /// Name of the current type. Only valid before visitTypeEnd.

-  SmallString<256> Name;

-

-public:

-  explicit TypeNameComputer(TypeCollection &Types) : Types(Types) {}

-

-  StringRef name() const { return Name; }

-

-  /// Paired begin/end actions for all types. Receives all record data,

-  /// including the fixed-length record prefix.

-  Error visitTypeBegin(CVType &Record) override;

-  Error visitTypeBegin(CVType &Record, TypeIndex Index) override;

-  Error visitTypeEnd(CVType &Record) override;

-

-#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \

-  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;

-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)

-#define MEMBER_RECORD(EnumName, EnumVal, Name)

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-};

-} // namespace

-

-Error TypeNameComputer::visitTypeBegin(CVType &Record) {

-  llvm_unreachable("Must call visitTypeBegin with a TypeIndex!");

-  return Error::success();

-}

-

-Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {

-  // Reset Name to the empty string. If the visitor sets it, we know it.

-  Name = "";

-  CurrentTypeIndex = Index;

-  return Error::success();

-}

-

-Error TypeNameComputer::visitTypeEnd(CVType &CVR) { return Error::success(); }

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         FieldListRecord &FieldList) {

-  Name = "<field list>";

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,

-                                         StringIdRecord &String) {

-  Name = String.getString();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {

-  auto Indices = Args.getIndices();

-  uint32_t Size = Indices.size();

-  Name = "(";

-  for (uint32_t I = 0; I < Size; ++I) {

-    assert(Indices[I] < CurrentTypeIndex);

-

-    Name.append(Types.getTypeName(Indices[I]));

-    if (I + 1 != Size)

-      Name.append(", ");

-  }

-  Name.push_back(')');

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         StringListRecord &Strings) {

-  auto Indices = Strings.getIndices();

-  uint32_t Size = Indices.size();

-  Name = "\"";

-  for (uint32_t I = 0; I < Size; ++I) {

-    Name.append(Types.getTypeName(Indices[I]));

-    if (I + 1 != Size)

-      Name.append("\" \"");

-  }

-  Name.push_back('\"');

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ClassRecord &Class) {

-  Name = Class.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, UnionRecord &Union) {

-  Name = Union.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {

-  Name = Enum.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {

-  Name = AT.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {

-  Name = VFT.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {

-  Name = Id.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {

-  StringRef Ret = Types.getTypeName(Proc.getReturnType());

-  StringRef Params = Types.getTypeName(Proc.getArgumentList());

-  Name = formatv("{0} {1}", Ret, Params).sstr<256>();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         MemberFunctionRecord &MF) {

-  StringRef Ret = Types.getTypeName(MF.getReturnType());

-  StringRef Class = Types.getTypeName(MF.getClassType());

-  StringRef Params = Types.getTypeName(MF.getArgumentList());

-  Name = formatv("{0} {1}::{2}", Ret, Class, Params).sstr<256>();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {

-  Name = Func.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {

-  Name = TS.getName();

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {

-

-  if (Ptr.isPointerToMember()) {

-    const MemberPointerInfo &MI = Ptr.getMemberInfo();

-

-    StringRef Pointee = Types.getTypeName(Ptr.getReferentType());

-    StringRef Class = Types.getTypeName(MI.getContainingType());

-    Name = formatv("{0} {1}::*", Pointee, Class);

-  } else {

-    Name.append(Types.getTypeName(Ptr.getReferentType()));

-

-    if (Ptr.getMode() == PointerMode::LValueReference)

-      Name.append("&");

-    else if (Ptr.getMode() == PointerMode::RValueReference)

-      Name.append("&&");

-    else if (Ptr.getMode() == PointerMode::Pointer)

-      Name.append("*");

-

-    // Qualifiers in pointer records apply to the pointer, not the pointee, so

-    // they go on the right.

-    if (Ptr.isConst())

-      Name.append(" const");

-    if (Ptr.isVolatile())

-      Name.append(" volatile");

-    if (Ptr.isUnaligned())

-      Name.append(" __unaligned");

-    if (Ptr.isRestrict())

-      Name.append(" __restrict");

-  }

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {

-  uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());

-

-  if (Mods & uint16_t(ModifierOptions::Const))

-    Name.append("const ");

-  if (Mods & uint16_t(ModifierOptions::Volatile))

-    Name.append("volatile ");

-  if (Mods & uint16_t(ModifierOptions::Unaligned))

-    Name.append("__unaligned ");

-  Name.append(Types.getTypeName(Mod.getModifiedType()));

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         VFTableShapeRecord &Shape) {

-  Name = formatv("<vftable {0} methods>", Shape.getEntryCount());

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(

-    CVType &CVR, UdtModSourceLineRecord &ModSourceLine) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         UdtSourceLineRecord &SourceLine) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, BitFieldRecord &BF) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         MethodOverloadListRecord &Overloads) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, BuildInfoRecord &BI) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR, LabelRecord &R) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         PrecompRecord &Precomp) {

-  return Error::success();

-}

-

-Error TypeNameComputer::visitKnownRecord(CVType &CVR,

-                                         EndPrecompRecord &EndPrecomp) {

-  return Error::success();

-}

-

-std::string llvm::codeview::computeTypeName(TypeCollection &Types,

-                                            TypeIndex Index) {

-  TypeNameComputer Computer(Types);

-  CVType Record = Types.getType(Index);

-  if (auto EC = visitTypeRecord(Record, Index, Computer)) {

-    consumeError(std::move(EC));

-    return "<unknown UDT>";

-  }

-  return Computer.name();

-}

-

-static int getSymbolNameOffset(CVSymbol Sym) {

-  switch (Sym.kind()) {

-  // See ProcSym

-  case SymbolKind::S_GPROC32:

-  case SymbolKind::S_LPROC32:

-  case SymbolKind::S_GPROC32_ID:

-  case SymbolKind::S_LPROC32_ID:

-  case SymbolKind::S_LPROC32_DPC:

-  case SymbolKind::S_LPROC32_DPC_ID:

-    return 35;

-  // See Thunk32Sym

-  case SymbolKind::S_THUNK32:

-    return 21;

-  // See SectionSym

-  case SymbolKind::S_SECTION:

-    return 16;

-  // See CoffGroupSym

-  case SymbolKind::S_COFFGROUP:

-    return 14;

-  // See PublicSym32, FileStaticSym, RegRelativeSym, DataSym, ThreadLocalDataSym

-  case SymbolKind::S_PUB32:

-  case SymbolKind::S_FILESTATIC:

-  case SymbolKind::S_REGREL32:

-  case SymbolKind::S_GDATA32:

-  case SymbolKind::S_LDATA32:

-  case SymbolKind::S_LMANDATA:

-  case SymbolKind::S_GMANDATA:

-  case SymbolKind::S_LTHREAD32:

-  case SymbolKind::S_GTHREAD32:

-    return 10;

-  // See RegisterSym and LocalSym

-  case SymbolKind::S_REGISTER:

-  case SymbolKind::S_LOCAL:

-    return 6;

-  // See BlockSym

-  case SymbolKind::S_BLOCK32:

-    return 18;

-  // See LabelSym

-  case SymbolKind::S_LABEL32:

-    return 7;

-  // See ObjNameSym, ExportSym, and UDTSym

-  case SymbolKind::S_OBJNAME:

-  case SymbolKind::S_EXPORT:

-  case SymbolKind::S_UDT:

-    return 4;

-  // See BPRelativeSym

-  case SymbolKind::S_BPREL32:

-    return 8;

-  default:

-    return -1;

-  }

-}

-

-StringRef llvm::codeview::getSymbolName(CVSymbol Sym) {

-  if (Sym.kind() == SymbolKind::S_CONSTANT) {

-    // S_CONSTANT is preceded by an APSInt, which has a variable length.  So we

-    // have to do a full deserialization.

-    BinaryStreamReader Reader(Sym.content(), llvm::support::little);

-    // The container doesn't matter for single records.

-    SymbolRecordMapping Mapping(Reader, CodeViewContainer::ObjectFile);

-    ConstantSym Const(SymbolKind::S_CONSTANT);

-    cantFail(Mapping.visitSymbolBegin(Sym));

-    cantFail(Mapping.visitKnownRecord(Sym, Const));

-    cantFail(Mapping.visitSymbolEnd(Sym));

-    return Const.Name;

-  }

-

-  int Offset = getSymbolNameOffset(Sym);

-  if (Offset == -1)

-    return StringRef();

-

-  StringRef StringData = toStringRef(Sym.content()).drop_front(Offset);

-  return StringData.split('\0').first;

-}

+//===- RecordName.cpp ----------------------------------------- *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/RecordName.h"
+
+#include "llvm/ADT/SmallString.h"
+#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecordMapping.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+namespace {
+class TypeNameComputer : public TypeVisitorCallbacks {
+  /// The type collection.  Used to calculate names of nested types.
+  TypeCollection &Types;
+  TypeIndex CurrentTypeIndex = TypeIndex::None();
+
+  /// Name of the current type. Only valid before visitTypeEnd.
+  SmallString<256> Name;
+
+public:
+  explicit TypeNameComputer(TypeCollection &Types) : Types(Types) {}
+
+  StringRef name() const { return Name; }
+
+  /// Paired begin/end actions for all types. Receives all record data,
+  /// including the fixed-length record prefix.
+  Error visitTypeBegin(CVType &Record) override;
+  Error visitTypeBegin(CVType &Record, TypeIndex Index) override;
+  Error visitTypeEnd(CVType &Record) override;
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+};
+} // namespace
+
+Error TypeNameComputer::visitTypeBegin(CVType &Record) {
+  llvm_unreachable("Must call visitTypeBegin with a TypeIndex!");
+  return Error::success();
+}
+
+Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {
+  // Reset Name to the empty string. If the visitor sets it, we know it.
+  Name = "";
+  CurrentTypeIndex = Index;
+  return Error::success();
+}
+
+Error TypeNameComputer::visitTypeEnd(CVType &CVR) { return Error::success(); }
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         FieldListRecord &FieldList) {
+  Name = "<field list>";
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+                                         StringIdRecord &String) {
+  Name = String.getString();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
+  auto Indices = Args.getIndices();
+  uint32_t Size = Indices.size();
+  Name = "(";
+  for (uint32_t I = 0; I < Size; ++I) {
+    assert(Indices[I] < CurrentTypeIndex);
+
+    Name.append(Types.getTypeName(Indices[I]));
+    if (I + 1 != Size)
+      Name.append(", ");
+  }
+  Name.push_back(')');
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         StringListRecord &Strings) {
+  auto Indices = Strings.getIndices();
+  uint32_t Size = Indices.size();
+  Name = "\"";
+  for (uint32_t I = 0; I < Size; ++I) {
+    Name.append(Types.getTypeName(Indices[I]));
+    if (I + 1 != Size)
+      Name.append("\" \"");
+  }
+  Name.push_back('\"');
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
+  Name = Class.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
+  Name = Union.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
+  Name = Enum.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
+  Name = AT.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {
+  Name = VFT.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {
+  Name = Id.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
+  StringRef Ret = Types.getTypeName(Proc.getReturnType());
+  StringRef Params = Types.getTypeName(Proc.getArgumentList());
+  Name = formatv("{0} {1}", Ret, Params).sstr<256>();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         MemberFunctionRecord &MF) {
+  StringRef Ret = Types.getTypeName(MF.getReturnType());
+  StringRef Class = Types.getTypeName(MF.getClassType());
+  StringRef Params = Types.getTypeName(MF.getArgumentList());
+  Name = formatv("{0} {1}::{2}", Ret, Class, Params).sstr<256>();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
+  Name = Func.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
+  Name = TS.getName();
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
+
+  if (Ptr.isPointerToMember()) {
+    const MemberPointerInfo &MI = Ptr.getMemberInfo();
+
+    StringRef Pointee = Types.getTypeName(Ptr.getReferentType());
+    StringRef Class = Types.getTypeName(MI.getContainingType());
+    Name = formatv("{0} {1}::*", Pointee, Class);
+  } else {
+    Name.append(Types.getTypeName(Ptr.getReferentType()));
+
+    if (Ptr.getMode() == PointerMode::LValueReference)
+      Name.append("&");
+    else if (Ptr.getMode() == PointerMode::RValueReference)
+      Name.append("&&");
+    else if (Ptr.getMode() == PointerMode::Pointer)
+      Name.append("*");
+
+    // Qualifiers in pointer records apply to the pointer, not the pointee, so
+    // they go on the right.
+    if (Ptr.isConst())
+      Name.append(" const");
+    if (Ptr.isVolatile())
+      Name.append(" volatile");
+    if (Ptr.isUnaligned())
+      Name.append(" __unaligned");
+    if (Ptr.isRestrict())
+      Name.append(" __restrict");
+  }
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
+  uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
+
+  if (Mods & uint16_t(ModifierOptions::Const))
+    Name.append("const ");
+  if (Mods & uint16_t(ModifierOptions::Volatile))
+    Name.append("volatile ");
+  if (Mods & uint16_t(ModifierOptions::Unaligned))
+    Name.append("__unaligned ");
+  Name.append(Types.getTypeName(Mod.getModifiedType()));
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         VFTableShapeRecord &Shape) {
+  Name = formatv("<vftable {0} methods>", Shape.getEntryCount());
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(
+    CVType &CVR, UdtModSourceLineRecord &ModSourceLine) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         UdtSourceLineRecord &SourceLine) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, BitFieldRecord &BF) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         MethodOverloadListRecord &Overloads) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, BuildInfoRecord &BI) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, LabelRecord &R) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         PrecompRecord &Precomp) {
+  return Error::success();
+}
+
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,
+                                         EndPrecompRecord &EndPrecomp) {
+  return Error::success();
+}
+
+std::string llvm::codeview::computeTypeName(TypeCollection &Types,
+                                            TypeIndex Index) {
+  TypeNameComputer Computer(Types);
+  CVType Record = Types.getType(Index);
+  if (auto EC = visitTypeRecord(Record, Index, Computer)) {
+    consumeError(std::move(EC));
+    return "<unknown UDT>";
+  }
+  return Computer.name();
+}
+
+static int getSymbolNameOffset(CVSymbol Sym) {
+  switch (Sym.kind()) {
+  // See ProcSym
+  case SymbolKind::S_GPROC32:
+  case SymbolKind::S_LPROC32:
+  case SymbolKind::S_GPROC32_ID:
+  case SymbolKind::S_LPROC32_ID:
+  case SymbolKind::S_LPROC32_DPC:
+  case SymbolKind::S_LPROC32_DPC_ID:
+    return 35;
+  // See Thunk32Sym
+  case SymbolKind::S_THUNK32:
+    return 21;
+  // See SectionSym
+  case SymbolKind::S_SECTION:
+    return 16;
+  // See CoffGroupSym
+  case SymbolKind::S_COFFGROUP:
+    return 14;
+  // See PublicSym32, FileStaticSym, RegRelativeSym, DataSym, ThreadLocalDataSym
+  case SymbolKind::S_PUB32:
+  case SymbolKind::S_FILESTATIC:
+  case SymbolKind::S_REGREL32:
+  case SymbolKind::S_GDATA32:
+  case SymbolKind::S_LDATA32:
+  case SymbolKind::S_LMANDATA:
+  case SymbolKind::S_GMANDATA:
+  case SymbolKind::S_LTHREAD32:
+  case SymbolKind::S_GTHREAD32:
+    return 10;
+  // See RegisterSym and LocalSym
+  case SymbolKind::S_REGISTER:
+  case SymbolKind::S_LOCAL:
+    return 6;
+  // See BlockSym
+  case SymbolKind::S_BLOCK32:
+    return 18;
+  // See LabelSym
+  case SymbolKind::S_LABEL32:
+    return 7;
+  // See ObjNameSym, ExportSym, and UDTSym
+  case SymbolKind::S_OBJNAME:
+  case SymbolKind::S_EXPORT:
+  case SymbolKind::S_UDT:
+    return 4;
+  // See BPRelativeSym
+  case SymbolKind::S_BPREL32:
+    return 8;
+  default:
+    return -1;
+  }
+}
+
+StringRef llvm::codeview::getSymbolName(CVSymbol Sym) {
+  if (Sym.kind() == SymbolKind::S_CONSTANT) {
+    // S_CONSTANT is preceded by an APSInt, which has a variable length.  So we
+    // have to do a full deserialization.
+    BinaryStreamReader Reader(Sym.content(), llvm::support::little);
+    // The container doesn't matter for single records.
+    SymbolRecordMapping Mapping(Reader, CodeViewContainer::ObjectFile);
+    ConstantSym Const(SymbolKind::S_CONSTANT);
+    cantFail(Mapping.visitSymbolBegin(Sym));
+    cantFail(Mapping.visitKnownRecord(Sym, Const));
+    cantFail(Mapping.visitSymbolEnd(Sym));
+    return Const.Name;
+  }
+
+  int Offset = getSymbolNameOffset(Sym);
+  if (Offset == -1)
+    return StringRef();
+
+  StringRef StringData = toStringRef(Sym.content()).drop_front(Offset);
+  return StringData.split('\0').first;
+}
diff --git a/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp b/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp
index f6e0b5b998e..7c68c9167c9 100644
--- a/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp
+++ b/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp
@@ -1,570 +1,570 @@
-//===-- TypeDumpVisitor.cpp - CodeView type info dumper ----------*- C++-*-===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-

-#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"

-

-#include "llvm/ADT/SmallString.h"

-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"

-#include "llvm/DebugInfo/CodeView/Formatters.h"

-#include "llvm/DebugInfo/CodeView/TypeCollection.h"

-#include "llvm/DebugInfo/CodeView/TypeIndex.h"

-#include "llvm/DebugInfo/CodeView/TypeRecord.h"

-#include "llvm/Support/FormatVariadic.h"

-#include "llvm/Support/ScopedPrinter.h"

-

-using namespace llvm;

-using namespace llvm::codeview;

-

-static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {

-#define CV_TYPE(enum, val) {#enum, enum},

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-};

-

-#define ENUM_ENTRY(enum_class, enum)                                           \

-  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }

-

-static const EnumEntry<uint16_t> ClassOptionNames[] = {

-    ENUM_ENTRY(ClassOptions, Packed),

-    ENUM_ENTRY(ClassOptions, HasConstructorOrDestructor),

-    ENUM_ENTRY(ClassOptions, HasOverloadedOperator),

-    ENUM_ENTRY(ClassOptions, Nested),

-    ENUM_ENTRY(ClassOptions, ContainsNestedClass),

-    ENUM_ENTRY(ClassOptions, HasOverloadedAssignmentOperator),

-    ENUM_ENTRY(ClassOptions, HasConversionOperator),

-    ENUM_ENTRY(ClassOptions, ForwardReference),

-    ENUM_ENTRY(ClassOptions, Scoped),

-    ENUM_ENTRY(ClassOptions, HasUniqueName),

-    ENUM_ENTRY(ClassOptions, Sealed),

-    ENUM_ENTRY(ClassOptions, Intrinsic),

-};

-

-static const EnumEntry<uint8_t> MemberAccessNames[] = {

-    ENUM_ENTRY(MemberAccess, None), ENUM_ENTRY(MemberAccess, Private),

-    ENUM_ENTRY(MemberAccess, Protected), ENUM_ENTRY(MemberAccess, Public),

-};

-

-static const EnumEntry<uint16_t> MethodOptionNames[] = {

-    ENUM_ENTRY(MethodOptions, Pseudo),

-    ENUM_ENTRY(MethodOptions, NoInherit),

-    ENUM_ENTRY(MethodOptions, NoConstruct),

-    ENUM_ENTRY(MethodOptions, CompilerGenerated),

-    ENUM_ENTRY(MethodOptions, Sealed),

-};

-

-static const EnumEntry<uint16_t> MemberKindNames[] = {

-    ENUM_ENTRY(MethodKind, Vanilla),

-    ENUM_ENTRY(MethodKind, Virtual),

-    ENUM_ENTRY(MethodKind, Static),

-    ENUM_ENTRY(MethodKind, Friend),

-    ENUM_ENTRY(MethodKind, IntroducingVirtual),

-    ENUM_ENTRY(MethodKind, PureVirtual),

-    ENUM_ENTRY(MethodKind, PureIntroducingVirtual),

-};

-

-static const EnumEntry<uint8_t> PtrKindNames[] = {

-    ENUM_ENTRY(PointerKind, Near16),

-    ENUM_ENTRY(PointerKind, Far16),

-    ENUM_ENTRY(PointerKind, Huge16),

-    ENUM_ENTRY(PointerKind, BasedOnSegment),

-    ENUM_ENTRY(PointerKind, BasedOnValue),

-    ENUM_ENTRY(PointerKind, BasedOnSegmentValue),

-    ENUM_ENTRY(PointerKind, BasedOnAddress),

-    ENUM_ENTRY(PointerKind, BasedOnSegmentAddress),

-    ENUM_ENTRY(PointerKind, BasedOnType),

-    ENUM_ENTRY(PointerKind, BasedOnSelf),

-    ENUM_ENTRY(PointerKind, Near32),

-    ENUM_ENTRY(PointerKind, Far32),

-    ENUM_ENTRY(PointerKind, Near64),

-};

-

-static const EnumEntry<uint8_t> PtrModeNames[] = {

-    ENUM_ENTRY(PointerMode, Pointer),

-    ENUM_ENTRY(PointerMode, LValueReference),

-    ENUM_ENTRY(PointerMode, PointerToDataMember),

-    ENUM_ENTRY(PointerMode, PointerToMemberFunction),

-    ENUM_ENTRY(PointerMode, RValueReference),

-};

-

-static const EnumEntry<uint16_t> PtrMemberRepNames[] = {

-    ENUM_ENTRY(PointerToMemberRepresentation, Unknown),

-    ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceData),

-    ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceData),

-    ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceData),

-    ENUM_ENTRY(PointerToMemberRepresentation, GeneralData),

-    ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceFunction),

-    ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceFunction),

-    ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceFunction),

-    ENUM_ENTRY(PointerToMemberRepresentation, GeneralFunction),

-};

-

-static const EnumEntry<uint16_t> TypeModifierNames[] = {

-    ENUM_ENTRY(ModifierOptions, Const), ENUM_ENTRY(ModifierOptions, Volatile),

-    ENUM_ENTRY(ModifierOptions, Unaligned),

-};

-

-static const EnumEntry<uint8_t> CallingConventions[] = {

-    ENUM_ENTRY(CallingConvention, NearC),

-    ENUM_ENTRY(CallingConvention, FarC),

-    ENUM_ENTRY(CallingConvention, NearPascal),

-    ENUM_ENTRY(CallingConvention, FarPascal),

-    ENUM_ENTRY(CallingConvention, NearFast),

-    ENUM_ENTRY(CallingConvention, FarFast),

-    ENUM_ENTRY(CallingConvention, NearStdCall),

-    ENUM_ENTRY(CallingConvention, FarStdCall),

-    ENUM_ENTRY(CallingConvention, NearSysCall),

-    ENUM_ENTRY(CallingConvention, FarSysCall),

-    ENUM_ENTRY(CallingConvention, ThisCall),

-    ENUM_ENTRY(CallingConvention, MipsCall),

-    ENUM_ENTRY(CallingConvention, Generic),

-    ENUM_ENTRY(CallingConvention, AlphaCall),

-    ENUM_ENTRY(CallingConvention, PpcCall),

-    ENUM_ENTRY(CallingConvention, SHCall),

-    ENUM_ENTRY(CallingConvention, ArmCall),

-    ENUM_ENTRY(CallingConvention, AM33Call),

-    ENUM_ENTRY(CallingConvention, TriCall),

-    ENUM_ENTRY(CallingConvention, SH5Call),

-    ENUM_ENTRY(CallingConvention, M32RCall),

-    ENUM_ENTRY(CallingConvention, ClrCall),

-    ENUM_ENTRY(CallingConvention, Inline),

-    ENUM_ENTRY(CallingConvention, NearVector),

-};

-

-static const EnumEntry<uint8_t> FunctionOptionEnum[] = {

-    ENUM_ENTRY(FunctionOptions, CxxReturnUdt),

-    ENUM_ENTRY(FunctionOptions, Constructor),

-    ENUM_ENTRY(FunctionOptions, ConstructorWithVirtualBases),

-};

-

-static const EnumEntry<uint16_t> LabelTypeEnum[] = {

-    ENUM_ENTRY(LabelType, Near), ENUM_ENTRY(LabelType, Far),

-};

-

-#undef ENUM_ENTRY

-

-static StringRef getLeafTypeName(TypeLeafKind LT) {

-  switch (LT) {

-#define TYPE_RECORD(ename, value, name)                                        \

-  case ename:                                                                  \

-    return #name;

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-  default:

-    break;

-  }

-  return "UnknownLeaf";

-}

-

-void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {

-  codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);

-}

-

-void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {

-  codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());

-}

-

-Error TypeDumpVisitor::visitTypeBegin(CVType &Record) {

-  return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));

-}

-

-Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {

-  W->startLine() << getLeafTypeName(Record.Type);

-  W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";

-  W->getOStream() << " {\n";

-  W->indent();

-  W->printEnum("TypeLeafKind", unsigned(Record.Type),

-               makeArrayRef(LeafTypeNames));

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitTypeEnd(CVType &Record) {

-  if (PrintRecordBytes)

-    W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));

-

-  W->unindent();

-  W->startLine() << "}\n";

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {

-  W->startLine() << getLeafTypeName(Record.Kind);

-  W->getOStream() << " {\n";

-  W->indent();

-  W->printEnum("TypeLeafKind", unsigned(Record.Kind),

-               makeArrayRef(LeafTypeNames));

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {

-  if (PrintRecordBytes)

-    W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));

-

-  W->unindent();

-  W->startLine() << "}\n";

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        FieldListRecord &FieldList) {

-  if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))

-    return EC;

-

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {

-  printItemIndex("Id", String.getId());

-  W->printString("StringData", String.getString());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {

-  auto Indices = Args.getIndices();

-  uint32_t Size = Indices.size();

-  W->printNumber("NumArgs", Size);

-  ListScope Arguments(*W, "Arguments");

-  for (uint32_t I = 0; I < Size; ++I) {

-    printTypeIndex("ArgType", Indices[I]);

-  }

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringListRecord &Strs) {

-  auto Indices = Strs.getIndices();

-  uint32_t Size = Indices.size();

-  W->printNumber("NumStrings", Size);

-  ListScope Arguments(*W, "Strings");

-  for (uint32_t I = 0; I < Size; ++I) {

-    printItemIndex("String", Indices[I]);

-  }

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {

-  uint16_t Props = static_cast<uint16_t>(Class.getOptions());

-  W->printNumber("MemberCount", Class.getMemberCount());

-  W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));

-  printTypeIndex("FieldList", Class.getFieldList());

-  printTypeIndex("DerivedFrom", Class.getDerivationList());

-  printTypeIndex("VShape", Class.getVTableShape());

-  W->printNumber("SizeOf", Class.getSize());

-  W->printString("Name", Class.getName());

-  if (Props & uint16_t(ClassOptions::HasUniqueName))

-    W->printString("LinkageName", Class.getUniqueName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {

-  uint16_t Props = static_cast<uint16_t>(Union.getOptions());

-  W->printNumber("MemberCount", Union.getMemberCount());

-  W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));

-  printTypeIndex("FieldList", Union.getFieldList());

-  W->printNumber("SizeOf", Union.getSize());

-  W->printString("Name", Union.getName());

-  if (Props & uint16_t(ClassOptions::HasUniqueName))

-    W->printString("LinkageName", Union.getUniqueName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {

-  uint16_t Props = static_cast<uint16_t>(Enum.getOptions());

-  W->printNumber("NumEnumerators", Enum.getMemberCount());

-  W->printFlags("Properties", uint16_t(Enum.getOptions()),

-                makeArrayRef(ClassOptionNames));

-  printTypeIndex("UnderlyingType", Enum.getUnderlyingType());

-  printTypeIndex("FieldListType", Enum.getFieldList());

-  W->printString("Name", Enum.getName());

-  if (Props & uint16_t(ClassOptions::HasUniqueName))

-    W->printString("LinkageName", Enum.getUniqueName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {

-  printTypeIndex("ElementType", AT.getElementType());

-  printTypeIndex("IndexType", AT.getIndexType());

-  W->printNumber("SizeOf", AT.getSize());

-  W->printString("Name", AT.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {

-  printTypeIndex("CompleteClass", VFT.getCompleteClass());

-  printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());

-  W->printHex("VFPtrOffset", VFT.getVFPtrOffset());

-  W->printString("VFTableName", VFT.getName());

-  for (auto N : VFT.getMethodNames())

-    W->printString("MethodName", N);

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {

-  printTypeIndex("ClassType", Id.getClassType());

-  printTypeIndex("FunctionType", Id.getFunctionType());

-  W->printString("Name", Id.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {

-  printTypeIndex("ReturnType", Proc.getReturnType());

-  W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),

-               makeArrayRef(CallingConventions));

-  W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),

-                makeArrayRef(FunctionOptionEnum));

-  W->printNumber("NumParameters", Proc.getParameterCount());

-  printTypeIndex("ArgListType", Proc.getArgumentList());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {

-  printTypeIndex("ReturnType", MF.getReturnType());

-  printTypeIndex("ClassType", MF.getClassType());

-  printTypeIndex("ThisType", MF.getThisType());

-  W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),

-               makeArrayRef(CallingConventions));

-  W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),

-                makeArrayRef(FunctionOptionEnum));

-  W->printNumber("NumParameters", MF.getParameterCount());

-  printTypeIndex("ArgListType", MF.getArgumentList());

-  W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        MethodOverloadListRecord &MethodList) {

-  for (auto &M : MethodList.getMethods()) {

-    ListScope S(*W, "Method");

-    printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());

-    printTypeIndex("Type", M.getType());

-    if (M.isIntroducingVirtual())

-      W->printHex("VFTableOffset", M.getVFTableOffset());

-  }

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {

-  printItemIndex("ParentScope", Func.getParentScope());

-  printTypeIndex("FunctionType", Func.getFunctionType());

-  W->printString("Name", Func.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {

-  W->printString("Guid", formatv("{0}", TS.getGuid()).str());

-  W->printNumber("Age", TS.getAge());

-  W->printString("Name", TS.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {

-  printTypeIndex("PointeeType", Ptr.getReferentType());

-  W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));

-  W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),

-               makeArrayRef(PtrKindNames));

-  W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));

-

-  W->printNumber("IsFlat", Ptr.isFlat());

-  W->printNumber("IsConst", Ptr.isConst());

-  W->printNumber("IsVolatile", Ptr.isVolatile());

-  W->printNumber("IsUnaligned", Ptr.isUnaligned());

-  W->printNumber("IsRestrict", Ptr.isRestrict());

-  W->printNumber("SizeOf", Ptr.getSize());

-

-  if (Ptr.isPointerToMember()) {

-    const MemberPointerInfo &MI = Ptr.getMemberInfo();

-

-    printTypeIndex("ClassType", MI.getContainingType());

-    W->printEnum("Representation", uint16_t(MI.getRepresentation()),

-                 makeArrayRef(PtrMemberRepNames));

-  }

-

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {

-  uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());

-  printTypeIndex("ModifiedType", Mod.getModifiedType());

-  W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));

-

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BitFieldRecord &BitField) {

-  printTypeIndex("Type", BitField.getType());

-  W->printNumber("BitSize", BitField.getBitSize());

-  W->printNumber("BitOffset", BitField.getBitOffset());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        VFTableShapeRecord &Shape) {

-  W->printNumber("VFEntryCount", Shape.getEntryCount());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        UdtSourceLineRecord &Line) {

-  printTypeIndex("UDT", Line.getUDT());

-  printItemIndex("SourceFile", Line.getSourceFile());

-  W->printNumber("LineNumber", Line.getLineNumber());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        UdtModSourceLineRecord &Line) {

-  printTypeIndex("UDT", Line.getUDT());

-  printItemIndex("SourceFile", Line.getSourceFile());

-  W->printNumber("LineNumber", Line.getLineNumber());

-  W->printNumber("Module", Line.getModule());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {

-  W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));

-

-  ListScope Arguments(*W, "Arguments");

-  for (auto Arg : Args.getArgs()) {

-    printItemIndex("ArgType", Arg);

-  }

-  return Error::success();

-}

-

-void TypeDumpVisitor::printMemberAttributes(MemberAttributes Attrs) {

-  return printMemberAttributes(Attrs.getAccess(), Attrs.getMethodKind(),

-                               Attrs.getFlags());

-}

-

-void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,

-                                            MethodKind Kind,

-                                            MethodOptions Options) {

-  W->printEnum("AccessSpecifier", uint8_t(Access),

-               makeArrayRef(MemberAccessNames));

-  // Data members will be vanilla. Don't try to print a method kind for them.

-  if (Kind != MethodKind::Vanilla)

-    W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));

-  if (Options != MethodOptions::None) {

-    W->printFlags("MethodOptions", unsigned(Options),

-                  makeArrayRef(MethodOptionNames));

-  }

-}

-

-Error TypeDumpVisitor::visitUnknownMember(CVMemberRecord &Record) {

-  W->printHex("UnknownMember", unsigned(Record.Kind));

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitUnknownType(CVType &Record) {

-  W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames));

-  W->printNumber("Length", uint32_t(Record.content().size()));

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        NestedTypeRecord &Nested) {

-  printTypeIndex("Type", Nested.getNestedType());

-  W->printString("Name", Nested.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        OneMethodRecord &Method) {

-  MethodKind K = Method.getMethodKind();

-  printMemberAttributes(Method.getAccess(), K, Method.getOptions());

-  printTypeIndex("Type", Method.getType());

-  // If virtual, then read the vftable offset.

-  if (Method.isIntroducingVirtual())

-    W->printHex("VFTableOffset", Method.getVFTableOffset());

-  W->printString("Name", Method.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        OverloadedMethodRecord &Method) {

-  W->printHex("MethodCount", Method.getNumOverloads());

-  printTypeIndex("MethodListIndex", Method.getMethodList());

-  W->printString("Name", Method.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        DataMemberRecord &Field) {

-  printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,

-                        MethodOptions::None);

-  printTypeIndex("Type", Field.getType());

-  W->printHex("FieldOffset", Field.getFieldOffset());

-  W->printString("Name", Field.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        StaticDataMemberRecord &Field) {

-  printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,

-                        MethodOptions::None);

-  printTypeIndex("Type", Field.getType());

-  W->printString("Name", Field.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        VFPtrRecord &VFTable) {

-  printTypeIndex("Type", VFTable.getType());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        EnumeratorRecord &Enum) {

-  printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,

-                        MethodOptions::None);

-  W->printNumber("EnumValue", Enum.getValue());

-  W->printString("Name", Enum.getName());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        BaseClassRecord &Base) {

-  printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,

-                        MethodOptions::None);

-  printTypeIndex("BaseType", Base.getBaseType());

-  W->printHex("BaseOffset", Base.getBaseOffset());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        VirtualBaseClassRecord &Base) {

-  printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,

-                        MethodOptions::None);

-  printTypeIndex("BaseType", Base.getBaseType());

-  printTypeIndex("VBPtrType", Base.getVBPtrType());

-  W->printHex("VBPtrOffset", Base.getVBPtrOffset());

-  W->printHex("VBTableIndex", Base.getVTableIndex());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,

-                                        ListContinuationRecord &Cont) {

-  printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {

-  W->printEnum("Mode", uint16_t(LR.Mode), makeArrayRef(LabelTypeEnum));

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        PrecompRecord &Precomp) {

-  W->printHex("StartIndex", Precomp.getStartTypeIndex());

-  W->printHex("Count", Precomp.getTypesCount());

-  W->printHex("Signature", Precomp.getSignature());

-  W->printString("PrecompFile", Precomp.getPrecompFilePath());

-  return Error::success();

-}

-

-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,

-                                        EndPrecompRecord &EndPrecomp) {

-  W->printHex("Signature", EndPrecomp.getSignature());

-  return Error::success();

-}

+//===-- TypeDumpVisitor.cpp - CodeView type info dumper ----------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
+
+#include "llvm/ADT/SmallString.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/Formatters.h"
+#include "llvm/DebugInfo/CodeView/TypeCollection.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
+#define CV_TYPE(enum, val) {#enum, enum},
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+};
+
+#define ENUM_ENTRY(enum_class, enum)                                           \
+  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
+
+static const EnumEntry<uint16_t> ClassOptionNames[] = {
+    ENUM_ENTRY(ClassOptions, Packed),
+    ENUM_ENTRY(ClassOptions, HasConstructorOrDestructor),
+    ENUM_ENTRY(ClassOptions, HasOverloadedOperator),
+    ENUM_ENTRY(ClassOptions, Nested),
+    ENUM_ENTRY(ClassOptions, ContainsNestedClass),
+    ENUM_ENTRY(ClassOptions, HasOverloadedAssignmentOperator),
+    ENUM_ENTRY(ClassOptions, HasConversionOperator),
+    ENUM_ENTRY(ClassOptions, ForwardReference),
+    ENUM_ENTRY(ClassOptions, Scoped),
+    ENUM_ENTRY(ClassOptions, HasUniqueName),
+    ENUM_ENTRY(ClassOptions, Sealed),
+    ENUM_ENTRY(ClassOptions, Intrinsic),
+};
+
+static const EnumEntry<uint8_t> MemberAccessNames[] = {
+    ENUM_ENTRY(MemberAccess, None), ENUM_ENTRY(MemberAccess, Private),
+    ENUM_ENTRY(MemberAccess, Protected), ENUM_ENTRY(MemberAccess, Public),
+};
+
+static const EnumEntry<uint16_t> MethodOptionNames[] = {
+    ENUM_ENTRY(MethodOptions, Pseudo),
+    ENUM_ENTRY(MethodOptions, NoInherit),
+    ENUM_ENTRY(MethodOptions, NoConstruct),
+    ENUM_ENTRY(MethodOptions, CompilerGenerated),
+    ENUM_ENTRY(MethodOptions, Sealed),
+};
+
+static const EnumEntry<uint16_t> MemberKindNames[] = {
+    ENUM_ENTRY(MethodKind, Vanilla),
+    ENUM_ENTRY(MethodKind, Virtual),
+    ENUM_ENTRY(MethodKind, Static),
+    ENUM_ENTRY(MethodKind, Friend),
+    ENUM_ENTRY(MethodKind, IntroducingVirtual),
+    ENUM_ENTRY(MethodKind, PureVirtual),
+    ENUM_ENTRY(MethodKind, PureIntroducingVirtual),
+};
+
+static const EnumEntry<uint8_t> PtrKindNames[] = {
+    ENUM_ENTRY(PointerKind, Near16),
+    ENUM_ENTRY(PointerKind, Far16),
+    ENUM_ENTRY(PointerKind, Huge16),
+    ENUM_ENTRY(PointerKind, BasedOnSegment),
+    ENUM_ENTRY(PointerKind, BasedOnValue),
+    ENUM_ENTRY(PointerKind, BasedOnSegmentValue),
+    ENUM_ENTRY(PointerKind, BasedOnAddress),
+    ENUM_ENTRY(PointerKind, BasedOnSegmentAddress),
+    ENUM_ENTRY(PointerKind, BasedOnType),
+    ENUM_ENTRY(PointerKind, BasedOnSelf),
+    ENUM_ENTRY(PointerKind, Near32),
+    ENUM_ENTRY(PointerKind, Far32),
+    ENUM_ENTRY(PointerKind, Near64),
+};
+
+static const EnumEntry<uint8_t> PtrModeNames[] = {
+    ENUM_ENTRY(PointerMode, Pointer),
+    ENUM_ENTRY(PointerMode, LValueReference),
+    ENUM_ENTRY(PointerMode, PointerToDataMember),
+    ENUM_ENTRY(PointerMode, PointerToMemberFunction),
+    ENUM_ENTRY(PointerMode, RValueReference),
+};
+
+static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
+    ENUM_ENTRY(PointerToMemberRepresentation, Unknown),
+    ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceData),
+    ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceData),
+    ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceData),
+    ENUM_ENTRY(PointerToMemberRepresentation, GeneralData),
+    ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceFunction),
+    ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceFunction),
+    ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceFunction),
+    ENUM_ENTRY(PointerToMemberRepresentation, GeneralFunction),
+};
+
+static const EnumEntry<uint16_t> TypeModifierNames[] = {
+    ENUM_ENTRY(ModifierOptions, Const), ENUM_ENTRY(ModifierOptions, Volatile),
+    ENUM_ENTRY(ModifierOptions, Unaligned),
+};
+
+static const EnumEntry<uint8_t> CallingConventions[] = {
+    ENUM_ENTRY(CallingConvention, NearC),
+    ENUM_ENTRY(CallingConvention, FarC),
+    ENUM_ENTRY(CallingConvention, NearPascal),
+    ENUM_ENTRY(CallingConvention, FarPascal),
+    ENUM_ENTRY(CallingConvention, NearFast),
+    ENUM_ENTRY(CallingConvention, FarFast),
+    ENUM_ENTRY(CallingConvention, NearStdCall),
+    ENUM_ENTRY(CallingConvention, FarStdCall),
+    ENUM_ENTRY(CallingConvention, NearSysCall),
+    ENUM_ENTRY(CallingConvention, FarSysCall),
+    ENUM_ENTRY(CallingConvention, ThisCall),
+    ENUM_ENTRY(CallingConvention, MipsCall),
+    ENUM_ENTRY(CallingConvention, Generic),
+    ENUM_ENTRY(CallingConvention, AlphaCall),
+    ENUM_ENTRY(CallingConvention, PpcCall),
+    ENUM_ENTRY(CallingConvention, SHCall),
+    ENUM_ENTRY(CallingConvention, ArmCall),
+    ENUM_ENTRY(CallingConvention, AM33Call),
+    ENUM_ENTRY(CallingConvention, TriCall),
+    ENUM_ENTRY(CallingConvention, SH5Call),
+    ENUM_ENTRY(CallingConvention, M32RCall),
+    ENUM_ENTRY(CallingConvention, ClrCall),
+    ENUM_ENTRY(CallingConvention, Inline),
+    ENUM_ENTRY(CallingConvention, NearVector),
+};
+
+static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
+    ENUM_ENTRY(FunctionOptions, CxxReturnUdt),
+    ENUM_ENTRY(FunctionOptions, Constructor),
+    ENUM_ENTRY(FunctionOptions, ConstructorWithVirtualBases),
+};
+
+static const EnumEntry<uint16_t> LabelTypeEnum[] = {
+    ENUM_ENTRY(LabelType, Near), ENUM_ENTRY(LabelType, Far),
+};
+
+#undef ENUM_ENTRY
+
+static StringRef getLeafTypeName(TypeLeafKind LT) {
+  switch (LT) {
+#define TYPE_RECORD(ename, value, name)                                        \
+  case ename:                                                                  \
+    return #name;
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+  default:
+    break;
+  }
+  return "UnknownLeaf";
+}
+
+void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {
+  codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);
+}
+
+void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {
+  codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());
+}
+
+Error TypeDumpVisitor::visitTypeBegin(CVType &Record) {
+  return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));
+}
+
+Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
+  W->startLine() << getLeafTypeName(Record.Type);
+  W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";
+  W->getOStream() << " {\n";
+  W->indent();
+  W->printEnum("TypeLeafKind", unsigned(Record.Type),
+               makeArrayRef(LeafTypeNames));
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitTypeEnd(CVType &Record) {
+  if (PrintRecordBytes)
+    W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));
+
+  W->unindent();
+  W->startLine() << "}\n";
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
+  W->startLine() << getLeafTypeName(Record.Kind);
+  W->getOStream() << " {\n";
+  W->indent();
+  W->printEnum("TypeLeafKind", unsigned(Record.Kind),
+               makeArrayRef(LeafTypeNames));
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
+  if (PrintRecordBytes)
+    W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
+
+  W->unindent();
+  W->startLine() << "}\n";
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        FieldListRecord &FieldList) {
+  if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
+    return EC;
+
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {
+  printItemIndex("Id", String.getId());
+  W->printString("StringData", String.getString());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
+  auto Indices = Args.getIndices();
+  uint32_t Size = Indices.size();
+  W->printNumber("NumArgs", Size);
+  ListScope Arguments(*W, "Arguments");
+  for (uint32_t I = 0; I < Size; ++I) {
+    printTypeIndex("ArgType", Indices[I]);
+  }
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringListRecord &Strs) {
+  auto Indices = Strs.getIndices();
+  uint32_t Size = Indices.size();
+  W->printNumber("NumStrings", Size);
+  ListScope Arguments(*W, "Strings");
+  for (uint32_t I = 0; I < Size; ++I) {
+    printItemIndex("String", Indices[I]);
+  }
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
+  uint16_t Props = static_cast<uint16_t>(Class.getOptions());
+  W->printNumber("MemberCount", Class.getMemberCount());
+  W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
+  printTypeIndex("FieldList", Class.getFieldList());
+  printTypeIndex("DerivedFrom", Class.getDerivationList());
+  printTypeIndex("VShape", Class.getVTableShape());
+  W->printNumber("SizeOf", Class.getSize());
+  W->printString("Name", Class.getName());
+  if (Props & uint16_t(ClassOptions::HasUniqueName))
+    W->printString("LinkageName", Class.getUniqueName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
+  uint16_t Props = static_cast<uint16_t>(Union.getOptions());
+  W->printNumber("MemberCount", Union.getMemberCount());
+  W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
+  printTypeIndex("FieldList", Union.getFieldList());
+  W->printNumber("SizeOf", Union.getSize());
+  W->printString("Name", Union.getName());
+  if (Props & uint16_t(ClassOptions::HasUniqueName))
+    W->printString("LinkageName", Union.getUniqueName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
+  uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
+  W->printNumber("NumEnumerators", Enum.getMemberCount());
+  W->printFlags("Properties", uint16_t(Enum.getOptions()),
+                makeArrayRef(ClassOptionNames));
+  printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
+  printTypeIndex("FieldListType", Enum.getFieldList());
+  W->printString("Name", Enum.getName());
+  if (Props & uint16_t(ClassOptions::HasUniqueName))
+    W->printString("LinkageName", Enum.getUniqueName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
+  printTypeIndex("ElementType", AT.getElementType());
+  printTypeIndex("IndexType", AT.getIndexType());
+  W->printNumber("SizeOf", AT.getSize());
+  W->printString("Name", AT.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {
+  printTypeIndex("CompleteClass", VFT.getCompleteClass());
+  printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
+  W->printHex("VFPtrOffset", VFT.getVFPtrOffset());
+  W->printString("VFTableName", VFT.getName());
+  for (auto N : VFT.getMethodNames())
+    W->printString("MethodName", N);
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {
+  printTypeIndex("ClassType", Id.getClassType());
+  printTypeIndex("FunctionType", Id.getFunctionType());
+  W->printString("Name", Id.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
+  printTypeIndex("ReturnType", Proc.getReturnType());
+  W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
+               makeArrayRef(CallingConventions));
+  W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
+                makeArrayRef(FunctionOptionEnum));
+  W->printNumber("NumParameters", Proc.getParameterCount());
+  printTypeIndex("ArgListType", Proc.getArgumentList());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {
+  printTypeIndex("ReturnType", MF.getReturnType());
+  printTypeIndex("ClassType", MF.getClassType());
+  printTypeIndex("ThisType", MF.getThisType());
+  W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
+               makeArrayRef(CallingConventions));
+  W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
+                makeArrayRef(FunctionOptionEnum));
+  W->printNumber("NumParameters", MF.getParameterCount());
+  printTypeIndex("ArgListType", MF.getArgumentList());
+  W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        MethodOverloadListRecord &MethodList) {
+  for (auto &M : MethodList.getMethods()) {
+    ListScope S(*W, "Method");
+    printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());
+    printTypeIndex("Type", M.getType());
+    if (M.isIntroducingVirtual())
+      W->printHex("VFTableOffset", M.getVFTableOffset());
+  }
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
+  printItemIndex("ParentScope", Func.getParentScope());
+  printTypeIndex("FunctionType", Func.getFunctionType());
+  W->printString("Name", Func.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
+  W->printString("Guid", formatv("{0}", TS.getGuid()).str());
+  W->printNumber("Age", TS.getAge());
+  W->printString("Name", TS.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
+  printTypeIndex("PointeeType", Ptr.getReferentType());
+  W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
+  W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
+               makeArrayRef(PtrKindNames));
+  W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
+
+  W->printNumber("IsFlat", Ptr.isFlat());
+  W->printNumber("IsConst", Ptr.isConst());
+  W->printNumber("IsVolatile", Ptr.isVolatile());
+  W->printNumber("IsUnaligned", Ptr.isUnaligned());
+  W->printNumber("IsRestrict", Ptr.isRestrict());
+  W->printNumber("SizeOf", Ptr.getSize());
+
+  if (Ptr.isPointerToMember()) {
+    const MemberPointerInfo &MI = Ptr.getMemberInfo();
+
+    printTypeIndex("ClassType", MI.getContainingType());
+    W->printEnum("Representation", uint16_t(MI.getRepresentation()),
+                 makeArrayRef(PtrMemberRepNames));
+  }
+
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
+  uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
+  printTypeIndex("ModifiedType", Mod.getModifiedType());
+  W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));
+
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BitFieldRecord &BitField) {
+  printTypeIndex("Type", BitField.getType());
+  W->printNumber("BitSize", BitField.getBitSize());
+  W->printNumber("BitOffset", BitField.getBitOffset());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        VFTableShapeRecord &Shape) {
+  W->printNumber("VFEntryCount", Shape.getEntryCount());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        UdtSourceLineRecord &Line) {
+  printTypeIndex("UDT", Line.getUDT());
+  printItemIndex("SourceFile", Line.getSourceFile());
+  W->printNumber("LineNumber", Line.getLineNumber());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        UdtModSourceLineRecord &Line) {
+  printTypeIndex("UDT", Line.getUDT());
+  printItemIndex("SourceFile", Line.getSourceFile());
+  W->printNumber("LineNumber", Line.getLineNumber());
+  W->printNumber("Module", Line.getModule());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {
+  W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
+
+  ListScope Arguments(*W, "Arguments");
+  for (auto Arg : Args.getArgs()) {
+    printItemIndex("ArgType", Arg);
+  }
+  return Error::success();
+}
+
+void TypeDumpVisitor::printMemberAttributes(MemberAttributes Attrs) {
+  return printMemberAttributes(Attrs.getAccess(), Attrs.getMethodKind(),
+                               Attrs.getFlags());
+}
+
+void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,
+                                            MethodKind Kind,
+                                            MethodOptions Options) {
+  W->printEnum("AccessSpecifier", uint8_t(Access),
+               makeArrayRef(MemberAccessNames));
+  // Data members will be vanilla. Don't try to print a method kind for them.
+  if (Kind != MethodKind::Vanilla)
+    W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));
+  if (Options != MethodOptions::None) {
+    W->printFlags("MethodOptions", unsigned(Options),
+                  makeArrayRef(MethodOptionNames));
+  }
+}
+
+Error TypeDumpVisitor::visitUnknownMember(CVMemberRecord &Record) {
+  W->printHex("UnknownMember", unsigned(Record.Kind));
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitUnknownType(CVType &Record) {
+  W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames));
+  W->printNumber("Length", uint32_t(Record.content().size()));
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        NestedTypeRecord &Nested) {
+  printTypeIndex("Type", Nested.getNestedType());
+  W->printString("Name", Nested.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        OneMethodRecord &Method) {
+  MethodKind K = Method.getMethodKind();
+  printMemberAttributes(Method.getAccess(), K, Method.getOptions());
+  printTypeIndex("Type", Method.getType());
+  // If virtual, then read the vftable offset.
+  if (Method.isIntroducingVirtual())
+    W->printHex("VFTableOffset", Method.getVFTableOffset());
+  W->printString("Name", Method.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        OverloadedMethodRecord &Method) {
+  W->printHex("MethodCount", Method.getNumOverloads());
+  printTypeIndex("MethodListIndex", Method.getMethodList());
+  W->printString("Name", Method.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        DataMemberRecord &Field) {
+  printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
+                        MethodOptions::None);
+  printTypeIndex("Type", Field.getType());
+  W->printHex("FieldOffset", Field.getFieldOffset());
+  W->printString("Name", Field.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        StaticDataMemberRecord &Field) {
+  printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
+                        MethodOptions::None);
+  printTypeIndex("Type", Field.getType());
+  W->printString("Name", Field.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        VFPtrRecord &VFTable) {
+  printTypeIndex("Type", VFTable.getType());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        EnumeratorRecord &Enum) {
+  printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
+                        MethodOptions::None);
+  W->printNumber("EnumValue", Enum.getValue());
+  W->printString("Name", Enum.getName());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        BaseClassRecord &Base) {
+  printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
+                        MethodOptions::None);
+  printTypeIndex("BaseType", Base.getBaseType());
+  W->printHex("BaseOffset", Base.getBaseOffset());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        VirtualBaseClassRecord &Base) {
+  printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
+                        MethodOptions::None);
+  printTypeIndex("BaseType", Base.getBaseType());
+  printTypeIndex("VBPtrType", Base.getVBPtrType());
+  W->printHex("VBPtrOffset", Base.getVBPtrOffset());
+  W->printHex("VBTableIndex", Base.getVTableIndex());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                        ListContinuationRecord &Cont) {
+  printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {
+  W->printEnum("Mode", uint16_t(LR.Mode), makeArrayRef(LabelTypeEnum));
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        PrecompRecord &Precomp) {
+  W->printHex("StartIndex", Precomp.getStartTypeIndex());
+  W->printHex("Count", Precomp.getTypesCount());
+  W->printHex("Signature", Precomp.getSignature());
+  W->printString("PrecompFile", Precomp.getPrecompFilePath());
+  return Error::success();
+}
+
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                        EndPrecompRecord &EndPrecomp) {
+  W->printHex("Signature", EndPrecomp.getSignature());
+  return Error::success();
+}
diff --git a/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp b/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp
index b1d51b25d3b..3203ff64d3b 100644
--- a/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp
+++ b/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp
@@ -1,497 +1,497 @@
-//===- TypeRecordMapping.cpp ------------------------------------*- C++ -*-===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-

-#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"

-

-using namespace llvm;

-using namespace llvm::codeview;

-

-#define error(X)                                                               \

-  if (auto EC = X)                                                             \

-    return EC;

-

-namespace {

-struct MapOneMethodRecord {

-  explicit MapOneMethodRecord(bool IsFromOverloadList)

-      : IsFromOverloadList(IsFromOverloadList) {}

-

-  Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {

-    error(IO.mapInteger(Method.Attrs.Attrs));

-    if (IsFromOverloadList) {

-      uint16_t Padding = 0;

-      error(IO.mapInteger(Padding));

-    }

-    error(IO.mapInteger(Method.Type));

-    if (Method.isIntroducingVirtual()) {

-      error(IO.mapInteger(Method.VFTableOffset));

-    } else if (!IO.isWriting())

-      Method.VFTableOffset = -1;

-

-    if (!IsFromOverloadList)

-      error(IO.mapStringZ(Method.Name));

-

-    return Error::success();

-  }

-

-private:

-  bool IsFromOverloadList;

-};

-}

-

-static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,

-                                  StringRef &UniqueName, bool HasUniqueName) {

-  if (IO.isWriting()) {

-    // Try to be smart about what we write here.  We can't write anything too

-    // large, so if we're going to go over the limit, truncate both the name

-    // and unique name by the same amount.

-    size_t BytesLeft = IO.maxFieldLength();

-    if (HasUniqueName) {

-      size_t BytesNeeded = Name.size() + UniqueName.size() + 2;

-      StringRef N = Name;

-      StringRef U = UniqueName;

-      if (BytesNeeded > BytesLeft) {

-        size_t BytesToDrop = (BytesNeeded - BytesLeft);

-        size_t DropN = std::min(N.size(), BytesToDrop / 2);

-        size_t DropU = std::min(U.size(), BytesToDrop - DropN);

-

-        N = N.drop_back(DropN);

-        U = U.drop_back(DropU);

-      }

-

-      error(IO.mapStringZ(N));

-      error(IO.mapStringZ(U));

-    } else {

-      // Cap the length of the string at however many bytes we have available,

-      // plus one for the required null terminator.

-      auto N = StringRef(Name).take_front(BytesLeft - 1);

-      error(IO.mapStringZ(N));

-    }

-  } else {

-    error(IO.mapStringZ(Name));

-    if (HasUniqueName)

-      error(IO.mapStringZ(UniqueName));

-  }

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {

-  assert(!TypeKind.hasValue() && "Already in a type mapping!");

-  assert(!MemberKind.hasValue() && "Already in a member mapping!");

-

-  // FieldList and MethodList records can be any length because they can be

-  // split with continuation records.  All other record types cannot be

-  // longer than the maximum record length.

-  Optional<uint32_t> MaxLen;

-  if (CVR.Type != TypeLeafKind::LF_FIELDLIST &&

-      CVR.Type != TypeLeafKind::LF_METHODLIST)

-    MaxLen = MaxRecordLength - sizeof(RecordPrefix);

-  error(IO.beginRecord(MaxLen));

-  TypeKind = CVR.Type;

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitTypeEnd(CVType &Record) {

-  assert(TypeKind.hasValue() && "Not in a type mapping!");

-  assert(!MemberKind.hasValue() && "Still in a member mapping!");

-

-  error(IO.endRecord());

-

-  TypeKind.reset();

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {

-  assert(TypeKind.hasValue() && "Not in a type mapping!");

-  assert(!MemberKind.hasValue() && "Already in a member mapping!");

-

-  // The largest possible subrecord is one in which there is a record prefix,

-  // followed by the subrecord, followed by a continuation, and that entire

-  // sequence spaws `MaxRecordLength` bytes.  So the record's length is

-  // calculated as follows.

-  constexpr uint32_t ContinuationLength = 8;

-  error(IO.beginRecord(MaxRecordLength - sizeof(RecordPrefix) -

-                       ContinuationLength));

-

-  MemberKind = Record.Kind;

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {

-  assert(TypeKind.hasValue() && "Not in a type mapping!");

-  assert(MemberKind.hasValue() && "Not in a member mapping!");

-

-  if (!IO.isWriting()) {

-    if (auto EC = IO.skipPadding())

-      return EC;

-  }

-

-  MemberKind.reset();

-  error(IO.endRecord());

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {

-  error(IO.mapInteger(Record.ModifiedType));

-  error(IO.mapEnum(Record.Modifiers));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          ProcedureRecord &Record) {

-  error(IO.mapInteger(Record.ReturnType));

-  error(IO.mapEnum(Record.CallConv));

-  error(IO.mapEnum(Record.Options));

-  error(IO.mapInteger(Record.ParameterCount));

-  error(IO.mapInteger(Record.ArgumentList));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          MemberFunctionRecord &Record) {

-  error(IO.mapInteger(Record.ReturnType));

-  error(IO.mapInteger(Record.ClassType));

-  error(IO.mapInteger(Record.ThisType));

-  error(IO.mapEnum(Record.CallConv));

-  error(IO.mapEnum(Record.Options));

-  error(IO.mapInteger(Record.ParameterCount));

-  error(IO.mapInteger(Record.ArgumentList));

-  error(IO.mapInteger(Record.ThisPointerAdjustment));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {

-  error(IO.mapVectorN<uint32_t>(

-      Record.ArgIndices,

-      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          StringListRecord &Record) {

-  error(IO.mapVectorN<uint32_t>(

-      Record.StringIndices,

-      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {

-  error(IO.mapInteger(Record.ReferentType));

-  error(IO.mapInteger(Record.Attrs));

-

-  if (Record.isPointerToMember()) {

-    if (!IO.isWriting())

-      Record.MemberInfo.emplace();

-

-    MemberPointerInfo &M = *Record.MemberInfo;

-    error(IO.mapInteger(M.ContainingType));

-    error(IO.mapEnum(M.Representation));

-  }

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {

-  error(IO.mapInteger(Record.ElementType));

-  error(IO.mapInteger(Record.IndexType));

-  error(IO.mapEncodedInteger(Record.Size));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ClassRecord &Record) {

-  assert((CVR.Type == TypeLeafKind::LF_STRUCTURE) ||

-         (CVR.Type == TypeLeafKind::LF_CLASS) ||

-         (CVR.Type == TypeLeafKind::LF_INTERFACE));

-

-  error(IO.mapInteger(Record.MemberCount));

-  error(IO.mapEnum(Record.Options));

-  error(IO.mapInteger(Record.FieldList));

-  error(IO.mapInteger(Record.DerivationList));

-  error(IO.mapInteger(Record.VTableShape));

-  error(IO.mapEncodedInteger(Record.Size));

-  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,

-                             Record.hasUniqueName()));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {

-  error(IO.mapInteger(Record.MemberCount));

-  error(IO.mapEnum(Record.Options));

-  error(IO.mapInteger(Record.FieldList));

-  error(IO.mapEncodedInteger(Record.Size));

-  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,

-                             Record.hasUniqueName()));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {

-  error(IO.mapInteger(Record.MemberCount));

-  error(IO.mapEnum(Record.Options));

-  error(IO.mapInteger(Record.UnderlyingType));

-  error(IO.mapInteger(Record.FieldList));

-  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,

-                             Record.hasUniqueName()));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, BitFieldRecord &Record) {

-  error(IO.mapInteger(Record.Type));

-  error(IO.mapInteger(Record.BitSize));

-  error(IO.mapInteger(Record.BitOffset));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          VFTableShapeRecord &Record) {

-  uint16_t Size;

-  if (IO.isWriting()) {

-    ArrayRef<VFTableSlotKind> Slots = Record.getSlots();

-    Size = Slots.size();

-    error(IO.mapInteger(Size));

-

-    for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {

-      uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;

-      if ((SlotIndex + 1) < Slots.size()) {

-        Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);

-      }

-      error(IO.mapInteger(Byte));

-    }

-  } else {

-    error(IO.mapInteger(Size));

-    for (uint16_t I = 0; I < Size; I += 2) {

-      uint8_t Byte;

-      error(IO.mapInteger(Byte));

-      Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));

-      if ((I + 1) < Size)

-        Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));

-    }

-  }

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {

-  error(IO.mapInteger(Record.CompleteClass));

-  error(IO.mapInteger(Record.OverriddenVFTable));

-  error(IO.mapInteger(Record.VFPtrOffset));

-  uint32_t NamesLen = 0;

-  if (IO.isWriting()) {

-    for (auto Name : Record.MethodNames)

-      NamesLen += Name.size() + 1;

-  }

-  error(IO.mapInteger(NamesLen));

-  error(IO.mapVectorTail(

-      Record.MethodNames,

-      [](CodeViewRecordIO &IO, StringRef &S) { return IO.mapStringZ(S); }));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {

-  error(IO.mapInteger(Record.Id));

-  error(IO.mapStringZ(Record.String));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          UdtSourceLineRecord &Record) {

-  error(IO.mapInteger(Record.UDT));

-  error(IO.mapInteger(Record.SourceFile));

-  error(IO.mapInteger(Record.LineNumber));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          UdtModSourceLineRecord &Record) {

-  error(IO.mapInteger(Record.UDT));

-  error(IO.mapInteger(Record.SourceFile));

-  error(IO.mapInteger(Record.LineNumber));

-  error(IO.mapInteger(Record.Module));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, FuncIdRecord &Record) {

-  error(IO.mapInteger(Record.ParentScope));

-  error(IO.mapInteger(Record.FunctionType));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          MemberFuncIdRecord &Record) {

-  error(IO.mapInteger(Record.ClassType));

-  error(IO.mapInteger(Record.FunctionType));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          BuildInfoRecord &Record) {

-  error(IO.mapVectorN<uint16_t>(

-      Record.ArgIndices,

-      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          MethodOverloadListRecord &Record) {

-  // TODO: Split the list into multiple records if it's longer than 64KB, using

-  // a subrecord of TypeRecordKind::Index to chain the records together.

-  error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true)));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          FieldListRecord &Record) {

-  error(IO.mapByteVectorTail(Record.Data));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          TypeServer2Record &Record) {

-  error(IO.mapGuid(Record.Guid));

-  error(IO.mapInteger(Record.Age));

-  error(IO.mapStringZ(Record.Name));

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {

-  error(IO.mapEnum(Record.Mode));

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          BaseClassRecord &Record) {

-  error(IO.mapInteger(Record.Attrs.Attrs));

-  error(IO.mapInteger(Record.Type));

-  error(IO.mapEncodedInteger(Record.Offset));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          EnumeratorRecord &Record) {

-  error(IO.mapInteger(Record.Attrs.Attrs));

-

-  // FIXME: Handle full APInt such as __int128.

-  error(IO.mapEncodedInteger(Record.Value));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          DataMemberRecord &Record) {

-  error(IO.mapInteger(Record.Attrs.Attrs));

-  error(IO.mapInteger(Record.Type));

-  error(IO.mapEncodedInteger(Record.FieldOffset));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          OverloadedMethodRecord &Record) {

-  error(IO.mapInteger(Record.NumOverloads));

-  error(IO.mapInteger(Record.MethodList));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          OneMethodRecord &Record) {

-  const bool IsFromOverloadList = (TypeKind == LF_METHODLIST);

-  MapOneMethodRecord Mapper(IsFromOverloadList);

-  return Mapper(IO, Record);

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          NestedTypeRecord &Record) {

-  uint16_t Padding = 0;

-  error(IO.mapInteger(Padding));

-  error(IO.mapInteger(Record.Type));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          StaticDataMemberRecord &Record) {

-

-  error(IO.mapInteger(Record.Attrs.Attrs));

-  error(IO.mapInteger(Record.Type));

-  error(IO.mapStringZ(Record.Name));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          VirtualBaseClassRecord &Record) {

-

-  error(IO.mapInteger(Record.Attrs.Attrs));

-  error(IO.mapInteger(Record.BaseType));

-  error(IO.mapInteger(Record.VBPtrType));

-  error(IO.mapEncodedInteger(Record.VBPtrOffset));

-  error(IO.mapEncodedInteger(Record.VTableIndex));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          VFPtrRecord &Record) {

-  uint16_t Padding = 0;

-  error(IO.mapInteger(Padding));

-  error(IO.mapInteger(Record.Type));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,

-                                          ListContinuationRecord &Record) {

-  uint16_t Padding = 0;

-  error(IO.mapInteger(Padding));

-  error(IO.mapInteger(Record.ContinuationIndex));

-

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          PrecompRecord &Precomp) {

-  error(IO.mapInteger(Precomp.StartTypeIndex));

-  error(IO.mapInteger(Precomp.TypesCount));

-  error(IO.mapInteger(Precomp.Signature));

-  error(IO.mapStringZ(Precomp.PrecompFilePath));

-  return Error::success();

-}

-

-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,

-                                          EndPrecompRecord &EndPrecomp) {

-  error(IO.mapInteger(EndPrecomp.Signature));

-  return Error::success();

-}

+//===- TypeRecordMapping.cpp ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+#define error(X)                                                               \
+  if (auto EC = X)                                                             \
+    return EC;
+
+namespace {
+struct MapOneMethodRecord {
+  explicit MapOneMethodRecord(bool IsFromOverloadList)
+      : IsFromOverloadList(IsFromOverloadList) {}
+
+  Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {
+    error(IO.mapInteger(Method.Attrs.Attrs));
+    if (IsFromOverloadList) {
+      uint16_t Padding = 0;
+      error(IO.mapInteger(Padding));
+    }
+    error(IO.mapInteger(Method.Type));
+    if (Method.isIntroducingVirtual()) {
+      error(IO.mapInteger(Method.VFTableOffset));
+    } else if (!IO.isWriting())
+      Method.VFTableOffset = -1;
+
+    if (!IsFromOverloadList)
+      error(IO.mapStringZ(Method.Name));
+
+    return Error::success();
+  }
+
+private:
+  bool IsFromOverloadList;
+};
+}
+
+static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,
+                                  StringRef &UniqueName, bool HasUniqueName) {
+  if (IO.isWriting()) {
+    // Try to be smart about what we write here.  We can't write anything too
+    // large, so if we're going to go over the limit, truncate both the name
+    // and unique name by the same amount.
+    size_t BytesLeft = IO.maxFieldLength();
+    if (HasUniqueName) {
+      size_t BytesNeeded = Name.size() + UniqueName.size() + 2;
+      StringRef N = Name;
+      StringRef U = UniqueName;
+      if (BytesNeeded > BytesLeft) {
+        size_t BytesToDrop = (BytesNeeded - BytesLeft);
+        size_t DropN = std::min(N.size(), BytesToDrop / 2);
+        size_t DropU = std::min(U.size(), BytesToDrop - DropN);
+
+        N = N.drop_back(DropN);
+        U = U.drop_back(DropU);
+      }
+
+      error(IO.mapStringZ(N));
+      error(IO.mapStringZ(U));
+    } else {
+      // Cap the length of the string at however many bytes we have available,
+      // plus one for the required null terminator.
+      auto N = StringRef(Name).take_front(BytesLeft - 1);
+      error(IO.mapStringZ(N));
+    }
+  } else {
+    error(IO.mapStringZ(Name));
+    if (HasUniqueName)
+      error(IO.mapStringZ(UniqueName));
+  }
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {
+  assert(!TypeKind.hasValue() && "Already in a type mapping!");
+  assert(!MemberKind.hasValue() && "Already in a member mapping!");
+
+  // FieldList and MethodList records can be any length because they can be
+  // split with continuation records.  All other record types cannot be
+  // longer than the maximum record length.
+  Optional<uint32_t> MaxLen;
+  if (CVR.Type != TypeLeafKind::LF_FIELDLIST &&
+      CVR.Type != TypeLeafKind::LF_METHODLIST)
+    MaxLen = MaxRecordLength - sizeof(RecordPrefix);
+  error(IO.beginRecord(MaxLen));
+  TypeKind = CVR.Type;
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitTypeEnd(CVType &Record) {
+  assert(TypeKind.hasValue() && "Not in a type mapping!");
+  assert(!MemberKind.hasValue() && "Still in a member mapping!");
+
+  error(IO.endRecord());
+
+  TypeKind.reset();
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {
+  assert(TypeKind.hasValue() && "Not in a type mapping!");
+  assert(!MemberKind.hasValue() && "Already in a member mapping!");
+
+  // The largest possible subrecord is one in which there is a record prefix,
+  // followed by the subrecord, followed by a continuation, and that entire
+  // sequence spaws `MaxRecordLength` bytes.  So the record's length is
+  // calculated as follows.
+  constexpr uint32_t ContinuationLength = 8;
+  error(IO.beginRecord(MaxRecordLength - sizeof(RecordPrefix) -
+                       ContinuationLength));
+
+  MemberKind = Record.Kind;
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {
+  assert(TypeKind.hasValue() && "Not in a type mapping!");
+  assert(MemberKind.hasValue() && "Not in a member mapping!");
+
+  if (!IO.isWriting()) {
+    if (auto EC = IO.skipPadding())
+      return EC;
+  }
+
+  MemberKind.reset();
+  error(IO.endRecord());
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
+  error(IO.mapInteger(Record.ModifiedType));
+  error(IO.mapEnum(Record.Modifiers));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          ProcedureRecord &Record) {
+  error(IO.mapInteger(Record.ReturnType));
+  error(IO.mapEnum(Record.CallConv));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.ParameterCount));
+  error(IO.mapInteger(Record.ArgumentList));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          MemberFunctionRecord &Record) {
+  error(IO.mapInteger(Record.ReturnType));
+  error(IO.mapInteger(Record.ClassType));
+  error(IO.mapInteger(Record.ThisType));
+  error(IO.mapEnum(Record.CallConv));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.ParameterCount));
+  error(IO.mapInteger(Record.ArgumentList));
+  error(IO.mapInteger(Record.ThisPointerAdjustment));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {
+  error(IO.mapVectorN<uint32_t>(
+      Record.ArgIndices,
+      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          StringListRecord &Record) {
+  error(IO.mapVectorN<uint32_t>(
+      Record.StringIndices,
+      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {
+  error(IO.mapInteger(Record.ReferentType));
+  error(IO.mapInteger(Record.Attrs));
+
+  if (Record.isPointerToMember()) {
+    if (!IO.isWriting())
+      Record.MemberInfo.emplace();
+
+    MemberPointerInfo &M = *Record.MemberInfo;
+    error(IO.mapInteger(M.ContainingType));
+    error(IO.mapEnum(M.Representation));
+  }
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {
+  error(IO.mapInteger(Record.ElementType));
+  error(IO.mapInteger(Record.IndexType));
+  error(IO.mapEncodedInteger(Record.Size));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ClassRecord &Record) {
+  assert((CVR.Type == TypeLeafKind::LF_STRUCTURE) ||
+         (CVR.Type == TypeLeafKind::LF_CLASS) ||
+         (CVR.Type == TypeLeafKind::LF_INTERFACE));
+
+  error(IO.mapInteger(Record.MemberCount));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.FieldList));
+  error(IO.mapInteger(Record.DerivationList));
+  error(IO.mapInteger(Record.VTableShape));
+  error(IO.mapEncodedInteger(Record.Size));
+  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
+                             Record.hasUniqueName()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {
+  error(IO.mapInteger(Record.MemberCount));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.FieldList));
+  error(IO.mapEncodedInteger(Record.Size));
+  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
+                             Record.hasUniqueName()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {
+  error(IO.mapInteger(Record.MemberCount));
+  error(IO.mapEnum(Record.Options));
+  error(IO.mapInteger(Record.UnderlyingType));
+  error(IO.mapInteger(Record.FieldList));
+  error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
+                             Record.hasUniqueName()));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, BitFieldRecord &Record) {
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapInteger(Record.BitSize));
+  error(IO.mapInteger(Record.BitOffset));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          VFTableShapeRecord &Record) {
+  uint16_t Size;
+  if (IO.isWriting()) {
+    ArrayRef<VFTableSlotKind> Slots = Record.getSlots();
+    Size = Slots.size();
+    error(IO.mapInteger(Size));
+
+    for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {
+      uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;
+      if ((SlotIndex + 1) < Slots.size()) {
+        Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);
+      }
+      error(IO.mapInteger(Byte));
+    }
+  } else {
+    error(IO.mapInteger(Size));
+    for (uint16_t I = 0; I < Size; I += 2) {
+      uint8_t Byte;
+      error(IO.mapInteger(Byte));
+      Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));
+      if ((I + 1) < Size)
+        Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));
+    }
+  }
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {
+  error(IO.mapInteger(Record.CompleteClass));
+  error(IO.mapInteger(Record.OverriddenVFTable));
+  error(IO.mapInteger(Record.VFPtrOffset));
+  uint32_t NamesLen = 0;
+  if (IO.isWriting()) {
+    for (auto Name : Record.MethodNames)
+      NamesLen += Name.size() + 1;
+  }
+  error(IO.mapInteger(NamesLen));
+  error(IO.mapVectorTail(
+      Record.MethodNames,
+      [](CodeViewRecordIO &IO, StringRef &S) { return IO.mapStringZ(S); }));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {
+  error(IO.mapInteger(Record.Id));
+  error(IO.mapStringZ(Record.String));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          UdtSourceLineRecord &Record) {
+  error(IO.mapInteger(Record.UDT));
+  error(IO.mapInteger(Record.SourceFile));
+  error(IO.mapInteger(Record.LineNumber));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          UdtModSourceLineRecord &Record) {
+  error(IO.mapInteger(Record.UDT));
+  error(IO.mapInteger(Record.SourceFile));
+  error(IO.mapInteger(Record.LineNumber));
+  error(IO.mapInteger(Record.Module));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, FuncIdRecord &Record) {
+  error(IO.mapInteger(Record.ParentScope));
+  error(IO.mapInteger(Record.FunctionType));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          MemberFuncIdRecord &Record) {
+  error(IO.mapInteger(Record.ClassType));
+  error(IO.mapInteger(Record.FunctionType));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          BuildInfoRecord &Record) {
+  error(IO.mapVectorN<uint16_t>(
+      Record.ArgIndices,
+      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          MethodOverloadListRecord &Record) {
+  // TODO: Split the list into multiple records if it's longer than 64KB, using
+  // a subrecord of TypeRecordKind::Index to chain the records together.
+  error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true)));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          FieldListRecord &Record) {
+  error(IO.mapByteVectorTail(Record.Data));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          TypeServer2Record &Record) {
+  error(IO.mapGuid(Record.Guid));
+  error(IO.mapInteger(Record.Age));
+  error(IO.mapStringZ(Record.Name));
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {
+  error(IO.mapEnum(Record.Mode));
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          BaseClassRecord &Record) {
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapEncodedInteger(Record.Offset));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          EnumeratorRecord &Record) {
+  error(IO.mapInteger(Record.Attrs.Attrs));
+
+  // FIXME: Handle full APInt such as __int128.
+  error(IO.mapEncodedInteger(Record.Value));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          DataMemberRecord &Record) {
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapEncodedInteger(Record.FieldOffset));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          OverloadedMethodRecord &Record) {
+  error(IO.mapInteger(Record.NumOverloads));
+  error(IO.mapInteger(Record.MethodList));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          OneMethodRecord &Record) {
+  const bool IsFromOverloadList = (TypeKind == LF_METHODLIST);
+  MapOneMethodRecord Mapper(IsFromOverloadList);
+  return Mapper(IO, Record);
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          NestedTypeRecord &Record) {
+  uint16_t Padding = 0;
+  error(IO.mapInteger(Padding));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          StaticDataMemberRecord &Record) {
+
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.Type));
+  error(IO.mapStringZ(Record.Name));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          VirtualBaseClassRecord &Record) {
+
+  error(IO.mapInteger(Record.Attrs.Attrs));
+  error(IO.mapInteger(Record.BaseType));
+  error(IO.mapInteger(Record.VBPtrType));
+  error(IO.mapEncodedInteger(Record.VBPtrOffset));
+  error(IO.mapEncodedInteger(Record.VTableIndex));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          VFPtrRecord &Record) {
+  uint16_t Padding = 0;
+  error(IO.mapInteger(Padding));
+  error(IO.mapInteger(Record.Type));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
+                                          ListContinuationRecord &Record) {
+  uint16_t Padding = 0;
+  error(IO.mapInteger(Padding));
+  error(IO.mapInteger(Record.ContinuationIndex));
+
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          PrecompRecord &Precomp) {
+  error(IO.mapInteger(Precomp.StartTypeIndex));
+  error(IO.mapInteger(Precomp.TypesCount));
+  error(IO.mapInteger(Precomp.Signature));
+  error(IO.mapStringZ(Precomp.PrecompFilePath));
+  return Error::success();
+}
+
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
+                                          EndPrecompRecord &EndPrecomp) {
+  error(IO.mapInteger(EndPrecomp.Signature));
+  return Error::success();
+}
diff --git a/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp b/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp
index 06aeb6d4df7..791b115dc49 100644
--- a/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp
+++ b/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp
@@ -1,818 +1,818 @@
-//===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-//

-// This file defines classes for handling the YAML representation of CodeView

-// Debug Info.

-//

-//===----------------------------------------------------------------------===//

-

-#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"

-#include "llvm/ADT/APSInt.h"

-#include "llvm/ADT/ArrayRef.h"

-#include "llvm/ADT/StringRef.h"

-#include "llvm/BinaryFormat/COFF.h"

-#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"

-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"

-#include "llvm/DebugInfo/CodeView/CodeView.h"

-#include "llvm/DebugInfo/CodeView/CodeViewError.h"

-#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"

-#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"

-#include "llvm/DebugInfo/CodeView/TypeIndex.h"

-#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"

-#include "llvm/Support/Allocator.h"

-#include "llvm/Support/BinaryStreamReader.h"

-#include "llvm/Support/BinaryStreamWriter.h"

-#include "llvm/Support/Endian.h"

-#include "llvm/Support/Error.h"

-#include "llvm/Support/ErrorHandling.h"

-#include "llvm/Support/YAMLTraits.h"

-#include "llvm/Support/raw_ostream.h"

-#include <algorithm>

-#include <cassert>

-#include <cstdint>

-#include <vector>

-

-using namespace llvm;

-using namespace llvm::codeview;

-using namespace llvm::CodeViewYAML;

-using namespace llvm::CodeViewYAML::detail;

-using namespace llvm::yaml;

-

-LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)

-LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)

-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)

-

-LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)

-LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)

-

-LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)

-LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)

-LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)

-LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)

-LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)

-LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)

-LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)

-LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)

-LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)

-LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)

-LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)

-

-LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)

-LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)

-LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)

-LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)

-LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)

-

-LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)

-LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)

-

-namespace llvm {

-namespace CodeViewYAML {

-namespace detail {

-

-struct LeafRecordBase {

-  TypeLeafKind Kind;

-

-  explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}

-  virtual ~LeafRecordBase() = default;

-

-  virtual void map(yaml::IO &io) = 0;

-  virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;

-  virtual Error fromCodeViewRecord(CVType Type) = 0;

-};

-

-template <typename T> struct LeafRecordImpl : public LeafRecordBase {

-  explicit LeafRecordImpl(TypeLeafKind K)

-      : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}

-

-  void map(yaml::IO &io) override;

-

-  Error fromCodeViewRecord(CVType Type) override {

-    return TypeDeserializer::deserializeAs<T>(Type, Record);

-  }

-

-  CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {

-    TS.writeLeafType(Record);

-    return CVType(Kind, TS.records().back());

-  }

-

-  mutable T Record;

-};

-

-template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {

-  explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}

-

-  void map(yaml::IO &io) override;

-  CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;

-  Error fromCodeViewRecord(CVType Type) override;

-

-  std::vector<MemberRecord> Members;

-};

-

-struct MemberRecordBase {

-  TypeLeafKind Kind;

-

-  explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}

-  virtual ~MemberRecordBase() = default;

-

-  virtual void map(yaml::IO &io) = 0;

-  virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;

-};

-

-template <typename T> struct MemberRecordImpl : public MemberRecordBase {

-  explicit MemberRecordImpl(TypeLeafKind K)

-      : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}

-

-  void map(yaml::IO &io) override;

-

-  void writeTo(ContinuationRecordBuilder &CRB) override {

-    CRB.writeMemberType(Record);

-  }

-

-  mutable T Record;

-};

-

-} // end namespace detail

-} // end namespace CodeViewYAML

-} // end namespace llvm

-

-void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {

-  OS << G;

-}

-

-StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {

-  if (Scalar.size() != 38)

-    return "GUID strings are 38 characters long";

-  if (Scalar[0] != '{' || Scalar[37] != '}')

-    return "GUID is not enclosed in {}";

-  if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||

-      Scalar[24] != '-')

-    return "GUID sections are not properly delineated with dashes";

-

-  uint8_t *OutBuffer = S.Guid;

-  for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {

-    if (*Iter == '-' || *Iter == '{' || *Iter == '}') {

-      ++Iter;

-      continue;

-    }

-    uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);

-    Value |= llvm::hexDigitValue(*Iter++);

-    *OutBuffer++ = Value;

-  }

-

-  return "";

-}

-

-void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,

-                                     raw_ostream &OS) {

-  OS << S.getIndex();

-}

-

-StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,

-                                         TypeIndex &S) {

-  uint32_t I;

-  StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);

-  S.setIndex(I);

-  return Result;

-}

-

-void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {

-  S.print(OS, S.isSigned());

-}

-

-StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {

-  S = APSInt(Scalar);

-  return "";

-}

-

-void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,

-                                                        TypeLeafKind &Value) {

-#define CV_TYPE(name, val) io.enumCase(Value, #name, name);

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-#undef CV_TYPE

-}

-

-void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(

-    IO &IO, PointerToMemberRepresentation &Value) {

-  IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);

-  IO.enumCase(Value, "SingleInheritanceData",

-              PointerToMemberRepresentation::SingleInheritanceData);

-  IO.enumCase(Value, "MultipleInheritanceData",

-              PointerToMemberRepresentation::MultipleInheritanceData);

-  IO.enumCase(Value, "VirtualInheritanceData",

-              PointerToMemberRepresentation::VirtualInheritanceData);

-  IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);

-  IO.enumCase(Value, "SingleInheritanceFunction",

-              PointerToMemberRepresentation::SingleInheritanceFunction);

-  IO.enumCase(Value, "MultipleInheritanceFunction",

-              PointerToMemberRepresentation::MultipleInheritanceFunction);

-  IO.enumCase(Value, "VirtualInheritanceFunction",

-              PointerToMemberRepresentation::VirtualInheritanceFunction);

-  IO.enumCase(Value, "GeneralFunction",

-              PointerToMemberRepresentation::GeneralFunction);

-}

-

-void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(

-    IO &IO, VFTableSlotKind &Kind) {

-  IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);

-  IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);

-  IO.enumCase(Kind, "This", VFTableSlotKind::This);

-  IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);

-  IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);

-  IO.enumCase(Kind, "Near", VFTableSlotKind::Near);

-  IO.enumCase(Kind, "Far", VFTableSlotKind::Far);

-}

-

-void ScalarEnumerationTraits<CallingConvention>::enumeration(

-    IO &IO, CallingConvention &Value) {

-  IO.enumCase(Value, "NearC", CallingConvention::NearC);

-  IO.enumCase(Value, "FarC", CallingConvention::FarC);

-  IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);

-  IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);

-  IO.enumCase(Value, "NearFast", CallingConvention::NearFast);

-  IO.enumCase(Value, "FarFast", CallingConvention::FarFast);

-  IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);

-  IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);

-  IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);

-  IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);

-  IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);

-  IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);

-  IO.enumCase(Value, "Generic", CallingConvention::Generic);

-  IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);

-  IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);

-  IO.enumCase(Value, "SHCall", CallingConvention::SHCall);

-  IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);

-  IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);

-  IO.enumCase(Value, "TriCall", CallingConvention::TriCall);

-  IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);

-  IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);

-  IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);

-  IO.enumCase(Value, "Inline", CallingConvention::Inline);

-  IO.enumCase(Value, "NearVector", CallingConvention::NearVector);

-}

-

-void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,

-                                                       PointerKind &Kind) {

-  IO.enumCase(Kind, "Near16", PointerKind::Near16);

-  IO.enumCase(Kind, "Far16", PointerKind::Far16);

-  IO.enumCase(Kind, "Huge16", PointerKind::Huge16);

-  IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);

-  IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);

-  IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);

-  IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);

-  IO.enumCase(Kind, "BasedOnSegmentAddress",

-              PointerKind::BasedOnSegmentAddress);

-  IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);

-  IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);

-  IO.enumCase(Kind, "Near32", PointerKind::Near32);

-  IO.enumCase(Kind, "Far32", PointerKind::Far32);

-  IO.enumCase(Kind, "Near64", PointerKind::Near64);

-}

-

-void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,

-                                                       PointerMode &Mode) {

-  IO.enumCase(Mode, "Pointer", PointerMode::Pointer);

-  IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);

-  IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);

-  IO.enumCase(Mode, "PointerToMemberFunction",

-              PointerMode::PointerToMemberFunction);

-  IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);

-}

-

-void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {

-  IO.enumCase(Value, "None", HfaKind::None);

-  IO.enumCase(Value, "Float", HfaKind::Float);

-  IO.enumCase(Value, "Double", HfaKind::Double);

-  IO.enumCase(Value, "Other", HfaKind::Other);

-}

-

-void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,

-                                                        MemberAccess &Access) {

-  IO.enumCase(Access, "None", MemberAccess::None);

-  IO.enumCase(Access, "Private", MemberAccess::Private);

-  IO.enumCase(Access, "Protected", MemberAccess::Protected);

-  IO.enumCase(Access, "Public", MemberAccess::Public);

-}

-

-void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,

-                                                      MethodKind &Kind) {

-  IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);

-  IO.enumCase(Kind, "Virtual", MethodKind::Virtual);

-  IO.enumCase(Kind, "Static", MethodKind::Static);

-  IO.enumCase(Kind, "Friend", MethodKind::Friend);

-  IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);

-  IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);

-  IO.enumCase(Kind, "PureIntroducingVirtual",

-              MethodKind::PureIntroducingVirtual);

-}

-

-void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(

-    IO &IO, WindowsRTClassKind &Value) {

-  IO.enumCase(Value, "None", WindowsRTClassKind::None);

-  IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);

-  IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);

-  IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);

-}

-

-void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {

-  IO.enumCase(Value, "Near", LabelType::Near);

-  IO.enumCase(Value, "Far", LabelType::Far);

-}

-

-void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,

-                                                PointerOptions &Options) {

-  IO.bitSetCase(Options, "None", PointerOptions::None);

-  IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);

-  IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);

-  IO.bitSetCase(Options, "Const", PointerOptions::Const);

-  IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);

-  IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);

-  IO.bitSetCase(Options, "WinRTSmartPointer",

-                PointerOptions::WinRTSmartPointer);

-}

-

-void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,

-                                                 ModifierOptions &Options) {

-  IO.bitSetCase(Options, "None", ModifierOptions::None);

-  IO.bitSetCase(Options, "Const", ModifierOptions::Const);

-  IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);

-  IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);

-}

-

-void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,

-                                                 FunctionOptions &Options) {

-  IO.bitSetCase(Options, "None", FunctionOptions::None);

-  IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);

-  IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);

-  IO.bitSetCase(Options, "ConstructorWithVirtualBases",

-                FunctionOptions::ConstructorWithVirtualBases);

-}

-

-void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {

-  IO.bitSetCase(Options, "None", ClassOptions::None);

-  IO.bitSetCase(Options, "HasConstructorOrDestructor",

-                ClassOptions::HasConstructorOrDestructor);

-  IO.bitSetCase(Options, "HasOverloadedOperator",

-                ClassOptions::HasOverloadedOperator);

-  IO.bitSetCase(Options, "Nested", ClassOptions::Nested);

-  IO.bitSetCase(Options, "ContainsNestedClass",

-                ClassOptions::ContainsNestedClass);

-  IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",

-                ClassOptions::HasOverloadedAssignmentOperator);

-  IO.bitSetCase(Options, "HasConversionOperator",

-                ClassOptions::HasConversionOperator);

-  IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);

-  IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);

-  IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);

-  IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);

-  IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);

-}

-

-void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {

-  IO.bitSetCase(Options, "None", MethodOptions::None);

-  IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);

-  IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);

-  IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);

-  IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);

-  IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);

-}

-

-void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {

-  IO.mapRequired("ContainingType", MPI.ContainingType);

-  IO.mapRequired("Representation", MPI.Representation);

-}

-

-namespace llvm {

-namespace CodeViewYAML {

-namespace detail {

-

-template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {

-  IO.mapRequired("ModifiedType", Record.ModifiedType);

-  IO.mapRequired("Modifiers", Record.Modifiers);

-}

-

-template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {

-  IO.mapRequired("ReturnType", Record.ReturnType);

-  IO.mapRequired("CallConv", Record.CallConv);

-  IO.mapRequired("Options", Record.Options);

-  IO.mapRequired("ParameterCount", Record.ParameterCount);

-  IO.mapRequired("ArgumentList", Record.ArgumentList);

-}

-

-template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {

-  IO.mapRequired("ReturnType", Record.ReturnType);

-  IO.mapRequired("ClassType", Record.ClassType);

-  IO.mapRequired("ThisType", Record.ThisType);

-  IO.mapRequired("CallConv", Record.CallConv);

-  IO.mapRequired("Options", Record.Options);

-  IO.mapRequired("ParameterCount", Record.ParameterCount);

-  IO.mapRequired("ArgumentList", Record.ArgumentList);

-  IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);

-}

-

-template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {

-  IO.mapRequired("Mode", Record.Mode);

-}

-

-template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {

-  IO.mapRequired("ClassType", Record.ClassType);

-  IO.mapRequired("FunctionType", Record.FunctionType);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {

-  IO.mapRequired("ArgIndices", Record.ArgIndices);

-}

-

-template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {

-  IO.mapRequired("StringIndices", Record.StringIndices);

-}

-

-template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {

-  IO.mapRequired("ReferentType", Record.ReferentType);

-  IO.mapRequired("Attrs", Record.Attrs);

-  IO.mapOptional("MemberInfo", Record.MemberInfo);

-}

-

-template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {

-  IO.mapRequired("ElementType", Record.ElementType);

-  IO.mapRequired("IndexType", Record.IndexType);

-  IO.mapRequired("Size", Record.Size);

-  IO.mapRequired("Name", Record.Name);

-}

-

-void LeafRecordImpl<FieldListRecord>::map(IO &IO) {

-  IO.mapRequired("FieldList", Members);

-}

-

-} // end namespace detail

-} // end namespace CodeViewYAML

-} // end namespace llvm

-

-namespace {

-

-class MemberRecordConversionVisitor : public TypeVisitorCallbacks {

-public:

-  explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)

-      : Records(Records) {}

-

-#define TYPE_RECORD(EnumName, EnumVal, Name)

-#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \

-  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \

-    return visitKnownMemberImpl(Record);                                       \

-  }

-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)

-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-private:

-  template <typename T> Error visitKnownMemberImpl(T &Record) {

-    TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());

-    auto Impl = std::make_shared<MemberRecordImpl<T>>(K);

-    Impl->Record = Record;

-    Records.push_back(MemberRecord{Impl});

-    return Error::success();

-  }

-

-  std::vector<MemberRecord> &Records;

-};

-

-} // end anonymous namespace

-

-Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {

-  MemberRecordConversionVisitor V(Members);

-  return visitMemberRecordStream(Type.content(), V);

-}

-

-CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(

-    AppendingTypeTableBuilder &TS) const {

-  ContinuationRecordBuilder CRB;

-  CRB.begin(ContinuationRecordKind::FieldList);

-  for (const auto &Member : Members) {

-    Member.Member->writeTo(CRB);

-  }

-  TS.insertRecord(CRB);

-  return CVType(Kind, TS.records().back());

-}

-

-void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {

-  io.mapRequired("Type", Record.Type);

-  io.mapRequired("Attrs", Record.Attrs.Attrs);

-  io.mapRequired("VFTableOffset", Record.VFTableOffset);

-  io.mapRequired("Name", Record.Name);

-}

-

-namespace llvm {

-namespace CodeViewYAML {

-namespace detail {

-

-template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {

-  IO.mapRequired("MemberCount", Record.MemberCount);

-  IO.mapRequired("Options", Record.Options);

-  IO.mapRequired("FieldList", Record.FieldList);

-  IO.mapRequired("Name", Record.Name);

-  IO.mapRequired("UniqueName", Record.UniqueName);

-  IO.mapRequired("DerivationList", Record.DerivationList);

-  IO.mapRequired("VTableShape", Record.VTableShape);

-  IO.mapRequired("Size", Record.Size);

-}

-

-template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {

-  IO.mapRequired("MemberCount", Record.MemberCount);

-  IO.mapRequired("Options", Record.Options);

-  IO.mapRequired("FieldList", Record.FieldList);

-  IO.mapRequired("Name", Record.Name);

-  IO.mapRequired("UniqueName", Record.UniqueName);

-  IO.mapRequired("Size", Record.Size);

-}

-

-template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {

-  IO.mapRequired("NumEnumerators", Record.MemberCount);

-  IO.mapRequired("Options", Record.Options);

-  IO.mapRequired("FieldList", Record.FieldList);

-  IO.mapRequired("Name", Record.Name);

-  IO.mapRequired("UniqueName", Record.UniqueName);

-  IO.mapRequired("UnderlyingType", Record.UnderlyingType);

-}

-

-template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {

-  IO.mapRequired("Type", Record.Type);

-  IO.mapRequired("BitSize", Record.BitSize);

-  IO.mapRequired("BitOffset", Record.BitOffset);

-}

-

-template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {

-  IO.mapRequired("Slots", Record.Slots);

-}

-

-template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {

-  IO.mapRequired("Guid", Record.Guid);

-  IO.mapRequired("Age", Record.Age);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {

-  IO.mapRequired("Id", Record.Id);

-  IO.mapRequired("String", Record.String);

-}

-

-template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {

-  IO.mapRequired("ParentScope", Record.ParentScope);

-  IO.mapRequired("FunctionType", Record.FunctionType);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {

-  IO.mapRequired("UDT", Record.UDT);

-  IO.mapRequired("SourceFile", Record.SourceFile);

-  IO.mapRequired("LineNumber", Record.LineNumber);

-}

-

-template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {

-  IO.mapRequired("UDT", Record.UDT);

-  IO.mapRequired("SourceFile", Record.SourceFile);

-  IO.mapRequired("LineNumber", Record.LineNumber);

-  IO.mapRequired("Module", Record.Module);

-}

-

-template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {

-  IO.mapRequired("ArgIndices", Record.ArgIndices);

-}

-

-template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {

-  IO.mapRequired("CompleteClass", Record.CompleteClass);

-  IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);

-  IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);

-  IO.mapRequired("MethodNames", Record.MethodNames);

-}

-

-template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {

-  IO.mapRequired("Methods", Record.Methods);

-}

-

-template <> void LeafRecordImpl<PrecompRecord>::map(IO &IO) {

-  IO.mapRequired("StartTypeIndex", Record.StartTypeIndex);

-  IO.mapRequired("TypesCount", Record.TypesCount);

-  IO.mapRequired("Signature", Record.Signature);

-  IO.mapRequired("PrecompFilePath", Record.PrecompFilePath);

-}

-

-template <> void LeafRecordImpl<EndPrecompRecord>::map(IO &IO) {

-  IO.mapRequired("Signature", Record.Signature);

-}

-

-template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {

-  MappingTraits<OneMethodRecord>::mapping(IO, Record);

-}

-

-template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {

-  IO.mapRequired("NumOverloads", Record.NumOverloads);

-  IO.mapRequired("MethodList", Record.MethodList);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {

-  IO.mapRequired("Type", Record.Type);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {

-  IO.mapRequired("Attrs", Record.Attrs.Attrs);

-  IO.mapRequired("Type", Record.Type);

-  IO.mapRequired("FieldOffset", Record.FieldOffset);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {

-  IO.mapRequired("Attrs", Record.Attrs.Attrs);

-  IO.mapRequired("Type", Record.Type);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {

-  IO.mapRequired("Attrs", Record.Attrs.Attrs);

-  IO.mapRequired("Value", Record.Value);

-  IO.mapRequired("Name", Record.Name);

-}

-

-template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {

-  IO.mapRequired("Type", Record.Type);

-}

-

-template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {

-  IO.mapRequired("Attrs", Record.Attrs.Attrs);

-  IO.mapRequired("Type", Record.Type);

-  IO.mapRequired("Offset", Record.Offset);

-}

-

-template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {

-  IO.mapRequired("Attrs", Record.Attrs.Attrs);

-  IO.mapRequired("BaseType", Record.BaseType);

-  IO.mapRequired("VBPtrType", Record.VBPtrType);

-  IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);

-  IO.mapRequired("VTableIndex", Record.VTableIndex);

-}

-

-template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {

-  IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);

-}

-

-} // end namespace detail

-} // end namespace CodeViewYAML

-} // end namespace llvm

-

-template <typename T>

-static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {

-  LeafRecord Result;

-

-  auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());

-  if (auto EC = Impl->fromCodeViewRecord(Type))

-    return std::move(EC);

-  Result.Leaf = Impl;

-  return Result;

-}

-

-Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {

-#define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \

-  case EnumName:                                                               \

-    return fromCodeViewRecordImpl<ClassName##Record>(Type);

-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)             \

-  TYPE_RECORD(EnumName, EnumVal, ClassName)

-#define MEMBER_RECORD(EnumName, EnumVal, ClassName)

-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)

-  switch (Type.kind()) {

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-  default:

-      llvm_unreachable("Unknown leaf kind!");

-  }

-  return make_error<CodeViewError>(cv_error_code::corrupt_record);

-}

-

-CVType

-LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {

-  return Leaf->toCodeViewRecord(Serializer);

-}

-

-namespace llvm {

-namespace yaml {

-

-template <> struct MappingTraits<LeafRecordBase> {

-  static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }

-};

-

-template <> struct MappingTraits<MemberRecordBase> {

-  static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }

-};

-

-} // end namespace yaml

-} // end namespace llvm

-

-template <typename ConcreteType>

-static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,

-                              LeafRecord &Obj) {

-  if (!IO.outputting())

-    Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);

-

-  if (Kind == LF_FIELDLIST)

-    Obj.Leaf->map(IO);

-  else

-    IO.mapRequired(Class, *Obj.Leaf);

-}

-

-void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {

-  TypeLeafKind Kind;

-  if (IO.outputting())

-    Kind = Obj.Leaf->Kind;

-  IO.mapRequired("Kind", Kind);

-

-#define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \

-  case EnumName:                                                               \

-    mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj);           \

-    break;

-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)             \

-  TYPE_RECORD(EnumName, EnumVal, ClassName)

-#define MEMBER_RECORD(EnumName, EnumVal, ClassName)

-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)

-  switch (Kind) {

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-  default: { llvm_unreachable("Unknown leaf kind!"); }

-  }

-}

-

-template <typename ConcreteType>

-static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,

-                                MemberRecord &Obj) {

-  if (!IO.outputting())

-    Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);

-

-  IO.mapRequired(Class, *Obj.Member);

-}

-

-void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {

-  TypeLeafKind Kind;

-  if (IO.outputting())

-    Kind = Obj.Member->Kind;

-  IO.mapRequired("Kind", Kind);

-

-#define MEMBER_RECORD(EnumName, EnumVal, ClassName)                            \

-  case EnumName:                                                               \

-    mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj);         \

-    break;

-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)           \

-  MEMBER_RECORD(EnumName, EnumVal, ClassName)

-#define TYPE_RECORD(EnumName, EnumVal, ClassName)

-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)

-  switch (Kind) {

-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

-  default: { llvm_unreachable("Unknown member kind!"); }

-  }

-}

-

-std::vector<LeafRecord>

-llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugTorP,

-                               StringRef SectionName) {

-  ExitOnError Err("Invalid " + std::string(SectionName) + " section!");

-  BinaryStreamReader Reader(DebugTorP, support::little);

-  CVTypeArray Types;

-  uint32_t Magic;

-

-  Err(Reader.readInteger(Magic));

-  assert(Magic == COFF::DEBUG_SECTION_MAGIC &&

-         "Invalid .debug$T or .debug$P section!");

-

-  std::vector<LeafRecord> Result;

-  Err(Reader.readArray(Types, Reader.bytesRemaining()));

-  for (const auto &T : Types) {

-    auto CVT = Err(LeafRecord::fromCodeViewRecord(T));

-    Result.push_back(CVT);

-  }

-  return Result;

-}

-

-ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,

-                                               BumpPtrAllocator &Alloc,

-                                               StringRef SectionName) {

-  AppendingTypeTableBuilder TS(Alloc);

-  uint32_t Size = sizeof(uint32_t);

-  for (const auto &Leaf : Leafs) {

-    CVType T = Leaf.Leaf->toCodeViewRecord(TS);

-    Size += T.length();

-    assert(T.length() % 4 == 0 && "Improper type record alignment!");

-  }

-  uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);

-  MutableArrayRef<uint8_t> Output(ResultBuffer, Size);

-  BinaryStreamWriter Writer(Output, support::little);

-  ExitOnError Err("Error writing type record to " + std::string(SectionName) +

-                  " section");

-  Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));

-  for (const auto &R : TS.records()) {

-    Err(Writer.writeBytes(R));

-  }

-  assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!");

-  return Output;

-}

+//===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines classes for handling the YAML representation of CodeView
+// Debug Info.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/COFF.h"
+#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/CodeViewError.h"
+#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/BinaryStreamWriter.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::CodeViewYAML;
+using namespace llvm::CodeViewYAML::detail;
+using namespace llvm::yaml;
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
+LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
+
+LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)
+LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)
+
+LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)
+LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)
+LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)
+LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)
+LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)
+LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)
+LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)
+LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)
+LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)
+LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)
+LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)
+
+LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)
+LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)
+LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)
+LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)
+LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)
+
+LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)
+
+namespace llvm {
+namespace CodeViewYAML {
+namespace detail {
+
+struct LeafRecordBase {
+  TypeLeafKind Kind;
+
+  explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}
+  virtual ~LeafRecordBase() = default;
+
+  virtual void map(yaml::IO &io) = 0;
+  virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;
+  virtual Error fromCodeViewRecord(CVType Type) = 0;
+};
+
+template <typename T> struct LeafRecordImpl : public LeafRecordBase {
+  explicit LeafRecordImpl(TypeLeafKind K)
+      : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
+
+  void map(yaml::IO &io) override;
+
+  Error fromCodeViewRecord(CVType Type) override {
+    return TypeDeserializer::deserializeAs<T>(Type, Record);
+  }
+
+  CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
+    TS.writeLeafType(Record);
+    return CVType(Kind, TS.records().back());
+  }
+
+  mutable T Record;
+};
+
+template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {
+  explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}
+
+  void map(yaml::IO &io) override;
+  CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;
+  Error fromCodeViewRecord(CVType Type) override;
+
+  std::vector<MemberRecord> Members;
+};
+
+struct MemberRecordBase {
+  TypeLeafKind Kind;
+
+  explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}
+  virtual ~MemberRecordBase() = default;
+
+  virtual void map(yaml::IO &io) = 0;
+  virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;
+};
+
+template <typename T> struct MemberRecordImpl : public MemberRecordBase {
+  explicit MemberRecordImpl(TypeLeafKind K)
+      : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
+
+  void map(yaml::IO &io) override;
+
+  void writeTo(ContinuationRecordBuilder &CRB) override {
+    CRB.writeMemberType(Record);
+  }
+
+  mutable T Record;
+};
+
+} // end namespace detail
+} // end namespace CodeViewYAML
+} // end namespace llvm
+
+void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {
+  OS << G;
+}
+
+StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {
+  if (Scalar.size() != 38)
+    return "GUID strings are 38 characters long";
+  if (Scalar[0] != '{' || Scalar[37] != '}')
+    return "GUID is not enclosed in {}";
+  if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
+      Scalar[24] != '-')
+    return "GUID sections are not properly delineated with dashes";
+
+  uint8_t *OutBuffer = S.Guid;
+  for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
+    if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
+      ++Iter;
+      continue;
+    }
+    uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);
+    Value |= llvm::hexDigitValue(*Iter++);
+    *OutBuffer++ = Value;
+  }
+
+  return "";
+}
+
+void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
+                                     raw_ostream &OS) {
+  OS << S.getIndex();
+}
+
+StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,
+                                         TypeIndex &S) {
+  uint32_t I;
+  StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);
+  S.setIndex(I);
+  return Result;
+}
+
+void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {
+  S.print(OS, S.isSigned());
+}
+
+StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {
+  S = APSInt(Scalar);
+  return "";
+}
+
+void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
+                                                        TypeLeafKind &Value) {
+#define CV_TYPE(name, val) io.enumCase(Value, #name, name);
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+#undef CV_TYPE
+}
+
+void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(
+    IO &IO, PointerToMemberRepresentation &Value) {
+  IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
+  IO.enumCase(Value, "SingleInheritanceData",
+              PointerToMemberRepresentation::SingleInheritanceData);
+  IO.enumCase(Value, "MultipleInheritanceData",
+              PointerToMemberRepresentation::MultipleInheritanceData);
+  IO.enumCase(Value, "VirtualInheritanceData",
+              PointerToMemberRepresentation::VirtualInheritanceData);
+  IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);
+  IO.enumCase(Value, "SingleInheritanceFunction",
+              PointerToMemberRepresentation::SingleInheritanceFunction);
+  IO.enumCase(Value, "MultipleInheritanceFunction",
+              PointerToMemberRepresentation::MultipleInheritanceFunction);
+  IO.enumCase(Value, "VirtualInheritanceFunction",
+              PointerToMemberRepresentation::VirtualInheritanceFunction);
+  IO.enumCase(Value, "GeneralFunction",
+              PointerToMemberRepresentation::GeneralFunction);
+}
+
+void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(
+    IO &IO, VFTableSlotKind &Kind) {
+  IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);
+  IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);
+  IO.enumCase(Kind, "This", VFTableSlotKind::This);
+  IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);
+  IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);
+  IO.enumCase(Kind, "Near", VFTableSlotKind::Near);
+  IO.enumCase(Kind, "Far", VFTableSlotKind::Far);
+}
+
+void ScalarEnumerationTraits<CallingConvention>::enumeration(
+    IO &IO, CallingConvention &Value) {
+  IO.enumCase(Value, "NearC", CallingConvention::NearC);
+  IO.enumCase(Value, "FarC", CallingConvention::FarC);
+  IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);
+  IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);
+  IO.enumCase(Value, "NearFast", CallingConvention::NearFast);
+  IO.enumCase(Value, "FarFast", CallingConvention::FarFast);
+  IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);
+  IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);
+  IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);
+  IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);
+  IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);
+  IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);
+  IO.enumCase(Value, "Generic", CallingConvention::Generic);
+  IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);
+  IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);
+  IO.enumCase(Value, "SHCall", CallingConvention::SHCall);
+  IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);
+  IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);
+  IO.enumCase(Value, "TriCall", CallingConvention::TriCall);
+  IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);
+  IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);
+  IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);
+  IO.enumCase(Value, "Inline", CallingConvention::Inline);
+  IO.enumCase(Value, "NearVector", CallingConvention::NearVector);
+}
+
+void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,
+                                                       PointerKind &Kind) {
+  IO.enumCase(Kind, "Near16", PointerKind::Near16);
+  IO.enumCase(Kind, "Far16", PointerKind::Far16);
+  IO.enumCase(Kind, "Huge16", PointerKind::Huge16);
+  IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);
+  IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);
+  IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);
+  IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);
+  IO.enumCase(Kind, "BasedOnSegmentAddress",
+              PointerKind::BasedOnSegmentAddress);
+  IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);
+  IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);
+  IO.enumCase(Kind, "Near32", PointerKind::Near32);
+  IO.enumCase(Kind, "Far32", PointerKind::Far32);
+  IO.enumCase(Kind, "Near64", PointerKind::Near64);
+}
+
+void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,
+                                                       PointerMode &Mode) {
+  IO.enumCase(Mode, "Pointer", PointerMode::Pointer);
+  IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);
+  IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);
+  IO.enumCase(Mode, "PointerToMemberFunction",
+              PointerMode::PointerToMemberFunction);
+  IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);
+}
+
+void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {
+  IO.enumCase(Value, "None", HfaKind::None);
+  IO.enumCase(Value, "Float", HfaKind::Float);
+  IO.enumCase(Value, "Double", HfaKind::Double);
+  IO.enumCase(Value, "Other", HfaKind::Other);
+}
+
+void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,
+                                                        MemberAccess &Access) {
+  IO.enumCase(Access, "None", MemberAccess::None);
+  IO.enumCase(Access, "Private", MemberAccess::Private);
+  IO.enumCase(Access, "Protected", MemberAccess::Protected);
+  IO.enumCase(Access, "Public", MemberAccess::Public);
+}
+
+void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,
+                                                      MethodKind &Kind) {
+  IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);
+  IO.enumCase(Kind, "Virtual", MethodKind::Virtual);
+  IO.enumCase(Kind, "Static", MethodKind::Static);
+  IO.enumCase(Kind, "Friend", MethodKind::Friend);
+  IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);
+  IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);
+  IO.enumCase(Kind, "PureIntroducingVirtual",
+              MethodKind::PureIntroducingVirtual);
+}
+
+void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(
+    IO &IO, WindowsRTClassKind &Value) {
+  IO.enumCase(Value, "None", WindowsRTClassKind::None);
+  IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);
+  IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);
+  IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);
+}
+
+void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {
+  IO.enumCase(Value, "Near", LabelType::Near);
+  IO.enumCase(Value, "Far", LabelType::Far);
+}
+
+void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
+                                                PointerOptions &Options) {
+  IO.bitSetCase(Options, "None", PointerOptions::None);
+  IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
+  IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
+  IO.bitSetCase(Options, "Const", PointerOptions::Const);
+  IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
+  IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
+  IO.bitSetCase(Options, "WinRTSmartPointer",
+                PointerOptions::WinRTSmartPointer);
+}
+
+void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
+                                                 ModifierOptions &Options) {
+  IO.bitSetCase(Options, "None", ModifierOptions::None);
+  IO.bitSetCase(Options, "Const", ModifierOptions::Const);
+  IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
+  IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);
+}
+
+void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,
+                                                 FunctionOptions &Options) {
+  IO.bitSetCase(Options, "None", FunctionOptions::None);
+  IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
+  IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
+  IO.bitSetCase(Options, "ConstructorWithVirtualBases",
+                FunctionOptions::ConstructorWithVirtualBases);
+}
+
+void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {
+  IO.bitSetCase(Options, "None", ClassOptions::None);
+  IO.bitSetCase(Options, "HasConstructorOrDestructor",
+                ClassOptions::HasConstructorOrDestructor);
+  IO.bitSetCase(Options, "HasOverloadedOperator",
+                ClassOptions::HasOverloadedOperator);
+  IO.bitSetCase(Options, "Nested", ClassOptions::Nested);
+  IO.bitSetCase(Options, "ContainsNestedClass",
+                ClassOptions::ContainsNestedClass);
+  IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",
+                ClassOptions::HasOverloadedAssignmentOperator);
+  IO.bitSetCase(Options, "HasConversionOperator",
+                ClassOptions::HasConversionOperator);
+  IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);
+  IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);
+  IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);
+  IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);
+  IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);
+}
+
+void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {
+  IO.bitSetCase(Options, "None", MethodOptions::None);
+  IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);
+  IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);
+  IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);
+  IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);
+  IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
+}
+
+void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
+  IO.mapRequired("ContainingType", MPI.ContainingType);
+  IO.mapRequired("Representation", MPI.Representation);
+}
+
+namespace llvm {
+namespace CodeViewYAML {
+namespace detail {
+
+template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {
+  IO.mapRequired("ModifiedType", Record.ModifiedType);
+  IO.mapRequired("Modifiers", Record.Modifiers);
+}
+
+template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {
+  IO.mapRequired("ReturnType", Record.ReturnType);
+  IO.mapRequired("CallConv", Record.CallConv);
+  IO.mapRequired("Options", Record.Options);
+  IO.mapRequired("ParameterCount", Record.ParameterCount);
+  IO.mapRequired("ArgumentList", Record.ArgumentList);
+}
+
+template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {
+  IO.mapRequired("ReturnType", Record.ReturnType);
+  IO.mapRequired("ClassType", Record.ClassType);
+  IO.mapRequired("ThisType", Record.ThisType);
+  IO.mapRequired("CallConv", Record.CallConv);
+  IO.mapRequired("Options", Record.Options);
+  IO.mapRequired("ParameterCount", Record.ParameterCount);
+  IO.mapRequired("ArgumentList", Record.ArgumentList);
+  IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);
+}
+
+template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {
+  IO.mapRequired("Mode", Record.Mode);
+}
+
+template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {
+  IO.mapRequired("ClassType", Record.ClassType);
+  IO.mapRequired("FunctionType", Record.FunctionType);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {
+  IO.mapRequired("ArgIndices", Record.ArgIndices);
+}
+
+template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {
+  IO.mapRequired("StringIndices", Record.StringIndices);
+}
+
+template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {
+  IO.mapRequired("ReferentType", Record.ReferentType);
+  IO.mapRequired("Attrs", Record.Attrs);
+  IO.mapOptional("MemberInfo", Record.MemberInfo);
+}
+
+template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {
+  IO.mapRequired("ElementType", Record.ElementType);
+  IO.mapRequired("IndexType", Record.IndexType);
+  IO.mapRequired("Size", Record.Size);
+  IO.mapRequired("Name", Record.Name);
+}
+
+void LeafRecordImpl<FieldListRecord>::map(IO &IO) {
+  IO.mapRequired("FieldList", Members);
+}
+
+} // end namespace detail
+} // end namespace CodeViewYAML
+} // end namespace llvm
+
+namespace {
+
+class MemberRecordConversionVisitor : public TypeVisitorCallbacks {
+public:
+  explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)
+      : Records(Records) {}
+
+#define TYPE_RECORD(EnumName, EnumVal, Name)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
+    return visitKnownMemberImpl(Record);                                       \
+  }
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+private:
+  template <typename T> Error visitKnownMemberImpl(T &Record) {
+    TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());
+    auto Impl = std::make_shared<MemberRecordImpl<T>>(K);
+    Impl->Record = Record;
+    Records.push_back(MemberRecord{Impl});
+    return Error::success();
+  }
+
+  std::vector<MemberRecord> &Records;
+};
+
+} // end anonymous namespace
+
+Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {
+  MemberRecordConversionVisitor V(Members);
+  return visitMemberRecordStream(Type.content(), V);
+}
+
+CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(
+    AppendingTypeTableBuilder &TS) const {
+  ContinuationRecordBuilder CRB;
+  CRB.begin(ContinuationRecordKind::FieldList);
+  for (const auto &Member : Members) {
+    Member.Member->writeTo(CRB);
+  }
+  TS.insertRecord(CRB);
+  return CVType(Kind, TS.records().back());
+}
+
+void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {
+  io.mapRequired("Type", Record.Type);
+  io.mapRequired("Attrs", Record.Attrs.Attrs);
+  io.mapRequired("VFTableOffset", Record.VFTableOffset);
+  io.mapRequired("Name", Record.Name);
+}
+
+namespace llvm {
+namespace CodeViewYAML {
+namespace detail {
+
+template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {
+  IO.mapRequired("MemberCount", Record.MemberCount);
+  IO.mapRequired("Options", Record.Options);
+  IO.mapRequired("FieldList", Record.FieldList);
+  IO.mapRequired("Name", Record.Name);
+  IO.mapRequired("UniqueName", Record.UniqueName);
+  IO.mapRequired("DerivationList", Record.DerivationList);
+  IO.mapRequired("VTableShape", Record.VTableShape);
+  IO.mapRequired("Size", Record.Size);
+}
+
+template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {
+  IO.mapRequired("MemberCount", Record.MemberCount);
+  IO.mapRequired("Options", Record.Options);
+  IO.mapRequired("FieldList", Record.FieldList);
+  IO.mapRequired("Name", Record.Name);
+  IO.mapRequired("UniqueName", Record.UniqueName);
+  IO.mapRequired("Size", Record.Size);
+}
+
+template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {
+  IO.mapRequired("NumEnumerators", Record.MemberCount);
+  IO.mapRequired("Options", Record.Options);
+  IO.mapRequired("FieldList", Record.FieldList);
+  IO.mapRequired("Name", Record.Name);
+  IO.mapRequired("UniqueName", Record.UniqueName);
+  IO.mapRequired("UnderlyingType", Record.UnderlyingType);
+}
+
+template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {
+  IO.mapRequired("Type", Record.Type);
+  IO.mapRequired("BitSize", Record.BitSize);
+  IO.mapRequired("BitOffset", Record.BitOffset);
+}
+
+template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {
+  IO.mapRequired("Slots", Record.Slots);
+}
+
+template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {
+  IO.mapRequired("Guid", Record.Guid);
+  IO.mapRequired("Age", Record.Age);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {
+  IO.mapRequired("Id", Record.Id);
+  IO.mapRequired("String", Record.String);
+}
+
+template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {
+  IO.mapRequired("ParentScope", Record.ParentScope);
+  IO.mapRequired("FunctionType", Record.FunctionType);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {
+  IO.mapRequired("UDT", Record.UDT);
+  IO.mapRequired("SourceFile", Record.SourceFile);
+  IO.mapRequired("LineNumber", Record.LineNumber);
+}
+
+template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {
+  IO.mapRequired("UDT", Record.UDT);
+  IO.mapRequired("SourceFile", Record.SourceFile);
+  IO.mapRequired("LineNumber", Record.LineNumber);
+  IO.mapRequired("Module", Record.Module);
+}
+
+template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {
+  IO.mapRequired("ArgIndices", Record.ArgIndices);
+}
+
+template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {
+  IO.mapRequired("CompleteClass", Record.CompleteClass);
+  IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);
+  IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);
+  IO.mapRequired("MethodNames", Record.MethodNames);
+}
+
+template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {
+  IO.mapRequired("Methods", Record.Methods);
+}
+
+template <> void LeafRecordImpl<PrecompRecord>::map(IO &IO) {
+  IO.mapRequired("StartTypeIndex", Record.StartTypeIndex);
+  IO.mapRequired("TypesCount", Record.TypesCount);
+  IO.mapRequired("Signature", Record.Signature);
+  IO.mapRequired("PrecompFilePath", Record.PrecompFilePath);
+}
+
+template <> void LeafRecordImpl<EndPrecompRecord>::map(IO &IO) {
+  IO.mapRequired("Signature", Record.Signature);
+}
+
+template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {
+  MappingTraits<OneMethodRecord>::mapping(IO, Record);
+}
+
+template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {
+  IO.mapRequired("NumOverloads", Record.NumOverloads);
+  IO.mapRequired("MethodList", Record.MethodList);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {
+  IO.mapRequired("Type", Record.Type);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {
+  IO.mapRequired("Attrs", Record.Attrs.Attrs);
+  IO.mapRequired("Type", Record.Type);
+  IO.mapRequired("FieldOffset", Record.FieldOffset);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {
+  IO.mapRequired("Attrs", Record.Attrs.Attrs);
+  IO.mapRequired("Type", Record.Type);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {
+  IO.mapRequired("Attrs", Record.Attrs.Attrs);
+  IO.mapRequired("Value", Record.Value);
+  IO.mapRequired("Name", Record.Name);
+}
+
+template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {
+  IO.mapRequired("Type", Record.Type);
+}
+
+template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {
+  IO.mapRequired("Attrs", Record.Attrs.Attrs);
+  IO.mapRequired("Type", Record.Type);
+  IO.mapRequired("Offset", Record.Offset);
+}
+
+template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {
+  IO.mapRequired("Attrs", Record.Attrs.Attrs);
+  IO.mapRequired("BaseType", Record.BaseType);
+  IO.mapRequired("VBPtrType", Record.VBPtrType);
+  IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);
+  IO.mapRequired("VTableIndex", Record.VTableIndex);
+}
+
+template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {
+  IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);
+}
+
+} // end namespace detail
+} // end namespace CodeViewYAML
+} // end namespace llvm
+
+template <typename T>
+static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
+  LeafRecord Result;
+
+  auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
+  if (auto EC = Impl->fromCodeViewRecord(Type))
+    return std::move(EC);
+  Result.Leaf = Impl;
+  return Result;
+}
+
+Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {
+#define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \
+  case EnumName:                                                               \
+    return fromCodeViewRecordImpl<ClassName##Record>(Type);
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)             \
+  TYPE_RECORD(EnumName, EnumVal, ClassName)
+#define MEMBER_RECORD(EnumName, EnumVal, ClassName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
+  switch (Type.kind()) {
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+  default:
+      llvm_unreachable("Unknown leaf kind!");
+  }
+  return make_error<CodeViewError>(cv_error_code::corrupt_record);
+}
+
+CVType
+LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {
+  return Leaf->toCodeViewRecord(Serializer);
+}
+
+namespace llvm {
+namespace yaml {
+
+template <> struct MappingTraits<LeafRecordBase> {
+  static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }
+};
+
+template <> struct MappingTraits<MemberRecordBase> {
+  static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+template <typename ConcreteType>
+static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
+                              LeafRecord &Obj) {
+  if (!IO.outputting())
+    Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);
+
+  if (Kind == LF_FIELDLIST)
+    Obj.Leaf->map(IO);
+  else
+    IO.mapRequired(Class, *Obj.Leaf);
+}
+
+void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {
+  TypeLeafKind Kind;
+  if (IO.outputting())
+    Kind = Obj.Leaf->Kind;
+  IO.mapRequired("Kind", Kind);
+
+#define TYPE_RECORD(EnumName, EnumVal, ClassName)                              \
+  case EnumName:                                                               \
+    mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj);           \
+    break;
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)             \
+  TYPE_RECORD(EnumName, EnumVal, ClassName)
+#define MEMBER_RECORD(EnumName, EnumVal, ClassName)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
+  switch (Kind) {
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+  default: { llvm_unreachable("Unknown leaf kind!"); }
+  }
+}
+
+template <typename ConcreteType>
+static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
+                                MemberRecord &Obj) {
+  if (!IO.outputting())
+    Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);
+
+  IO.mapRequired(Class, *Obj.Member);
+}
+
+void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {
+  TypeLeafKind Kind;
+  if (IO.outputting())
+    Kind = Obj.Member->Kind;
+  IO.mapRequired("Kind", Kind);
+
+#define MEMBER_RECORD(EnumName, EnumVal, ClassName)                            \
+  case EnumName:                                                               \
+    mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj);         \
+    break;
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)           \
+  MEMBER_RECORD(EnumName, EnumVal, ClassName)
+#define TYPE_RECORD(EnumName, EnumVal, ClassName)
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
+  switch (Kind) {
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+  default: { llvm_unreachable("Unknown member kind!"); }
+  }
+}
+
+std::vector<LeafRecord>
+llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugTorP,
+                               StringRef SectionName) {
+  ExitOnError Err("Invalid " + std::string(SectionName) + " section!");
+  BinaryStreamReader Reader(DebugTorP, support::little);
+  CVTypeArray Types;
+  uint32_t Magic;
+
+  Err(Reader.readInteger(Magic));
+  assert(Magic == COFF::DEBUG_SECTION_MAGIC &&
+         "Invalid .debug$T or .debug$P section!");
+
+  std::vector<LeafRecord> Result;
+  Err(Reader.readArray(Types, Reader.bytesRemaining()));
+  for (const auto &T : Types) {
+    auto CVT = Err(LeafRecord::fromCodeViewRecord(T));
+    Result.push_back(CVT);
+  }
+  return Result;
+}
+
+ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,
+                                               BumpPtrAllocator &Alloc,
+                                               StringRef SectionName) {
+  AppendingTypeTableBuilder TS(Alloc);
+  uint32_t Size = sizeof(uint32_t);
+  for (const auto &Leaf : Leafs) {
+    CVType T = Leaf.Leaf->toCodeViewRecord(TS);
+    Size += T.length();
+    assert(T.length() % 4 == 0 && "Improper type record alignment!");
+  }
+  uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);
+  MutableArrayRef<uint8_t> Output(ResultBuffer, Size);
+  BinaryStreamWriter Writer(Output, support::little);
+  ExitOnError Err("Error writing type record to " + std::string(SectionName) +
+                  " section");
+  Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));
+  for (const auto &R : TS.records()) {
+    Err(Writer.writeBytes(R));
+  }
+  assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!");
+  return Output;
+}