[Debuginfo][COFF] Minimal serialization support for precompiled types records

This change adds support for the LF_PRECOMP and LF_ENDPRECOMP records required
to read/write Microsoft precompiled types .objs.
See https://en.wikipedia.org/wiki/Precompiled_header#Microsoft_Visual_C_and_C++

This also adds handling for the .debug$P section, which is actually a .debug$T
section in disguise, found only in precompiled .objs.

Differential Revision: https://reviews.llvm.org/D45283

llvm-svn: 329613

7 files changed, 2226 insertions, 2168 deletions

diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
index fa3fd17d629..f8cd01abddd 100644
--- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
@@ -524,7 +524,7 @@ void CodeViewDebug::emitTypeInformation() {
   if (TypeTable.empty())
     return;
 
-  // Start the .debug$T section with 0x4.
+  // Start the .debug$T or .debug$P section with 0x4.
   OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
   emitCodeViewMagicVersion();
 
diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h
index 236a70ef15d..e58c4c666f2 100644
--- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h
+++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h
@@ -239,7 +239,8 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   }
 
   /// Emit the magic version number at the start of a CodeView type or symbol
-  /// section. Appears at the front of every .debug$S or .debug$T section.
+  /// section. Appears at the front of every .debug$S or .debug$T or .debug$P
+  /// section.
   void emitCodeViewMagicVersion();
 
   void emitTypeInformation();
diff --git a/llvm/lib/DebugInfo/CodeView/RecordName.cpp b/llvm/lib/DebugInfo/CodeView/RecordName.cpp
index e6fd7cd3d28..d18d346e86a 100644
--- a/llvm/lib/DebugInfo/CodeView/RecordName.cpp
+++ b/llvm/lib/DebugInfo/CodeView/RecordName.cpp
@@ -1,323 +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();
-}
-
-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 2482c9ef332..f6e0b5b998e 100644
--- a/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp
+++ b/llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp
@@ -1,555 +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();
-}
+//===-- 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 9b8a6053da8..b1d51b25d3b 100644
--- a/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp
+++ b/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp
@@ -1,482 +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();
-}
+//===- 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/COFFYAML.cpp b/llvm/lib/ObjectYAML/COFFYAML.cpp
index 937b8dc029f..9351ef96beb 100644
--- a/llvm/lib/ObjectYAML/COFFYAML.cpp
+++ b/llvm/lib/ObjectYAML/COFFYAML.cpp
@@ -562,14 +562,16 @@ void MappingTraits<COFFYAML::Section>::mapping(IO &IO, COFFYAML::Section &Sec) {
   IO.mapOptional("VirtualSize", Sec.Header.VirtualSize, 0U);
   IO.mapOptional("Alignment", Sec.Alignment, 0U);
 
-  // If this is a .debug$S .debug$T, or .debug$H section parse the semantic
-  // representation of the symbols/types.  If it is any other kind of section,
-  // just deal in raw bytes.
+  // If this is a .debug$S .debug$T .debug$P, or .debug$H section parse the
+  // semantic representation of the symbols/types.  If it is any other kind
+  // of section, just deal in raw bytes.
   IO.mapOptional("SectionData", Sec.SectionData);
   if (Sec.Name == ".debug$S")
     IO.mapOptional("Subsections", Sec.DebugS);
   else if (Sec.Name == ".debug$T")
     IO.mapOptional("Types", Sec.DebugT);
+  else if (Sec.Name == ".debug$P")
+    IO.mapOptional("PrecompTypes", Sec.DebugP);
   else if (Sec.Name == ".debug$H")
     IO.mapOptional("GlobalHashes", Sec.DebugH);
 
diff --git a/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp b/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp
index ba4ad9382ce..06aeb6d4df7 100644
--- a/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp
+++ b/llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp
@@ -1,803 +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 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> DebugT) {
-  ExitOnError Err("Invalid .debug$T section!");
-  BinaryStreamReader Reader(DebugT, support::little);
-  CVTypeArray Types;
-  uint32_t Magic;
-
-  Err(Reader.readInteger(Magic));
-  assert(Magic == COFF::DEBUG_SECTION_MAGIC && "Invalid .debug$T 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) {
-  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 .debug$T 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;

+}