[COFF] Minimal serialization support for precompiled types records

[aganea]

Summary

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.

Side-note: the LF_PRECOMP and LF_ENDPRECOMP records are only used in .obj; they
are subsequently dropped during the PDB type merging phase. In the same way,
the .debug$P section is merged with the other .debug$T sections in the PDB.

[rnk]

Looks good to me, but let's ask @zturner too.

include/llvm/DebugInfo/CodeView/TypeRecord.h

910 ↗

(On Diff #141031)

That sounds like it'll be fun to implement in type merging. =/

[aganea]

include/llvm/DebugInfo/CodeView/TypeRecord.h

910 ↗

(On Diff #141031)

Well in practice, it is not as bad as it seems. It boils down to replacing the LF_PRECOMP record with a copy of precomp.obj, up to LF_ENDRECORD.

Consider a.obj, which has a reference to precomp.obj:

0x1000 | LF_PRECOMP [size = 60] start index = 4096, types count = 1031, signature = 0x1116980E, precomp path = f:\svn\lld\test\coff\precomp\precomp.obj
0x1407 | LF_ARGLIST [size = 12]
         0x0070 (char): `char`
0x1408 | LF_PROCEDURE [size = 16]
         return type = 0x0074 (int), # args = 1, param list = 0x1407
         calling conv = cdecl, options = None
0x1409 | LF_FUNC_ID [size = 20]
         name = main, type = 0x1029, parent scope = <no type>

and precomp.obj:

0x1000 | LF_STRUCTURE [size = 64] `_s__CatchableType`
         unique name: `.?AU_s__CatchableType@@`
         vtable: <no type>, base list: <no type>, field list: <no type>
         options: forward ref | has unique name
0x1001 | LF_MODIFIER [size = 12]
         referent = 0x1000, modifiers = const
...
0x1406 | LF_UDT_SRC_LINE [size = 16]
         udt = 0x1405, file = 4180, line = 759
0x1407 | LF_ENDPRECOMP [size = 8] signature = 0x1116980E

Prior to merging a.obj, you simply append the contents of precomp.obj into LF_PRECOMP, up to LF_ENDPRECOMP (but not including it)
As you can see the type records IDs jump after LF_PRECOMP from 0x1000 to 0x1407. The data is just here for back-reference, so a.obj can be remapped properly. We only merge/remap precomp.obj once.

Currently, llvm-pdbutil does not jump from 0x1000 to 0x1407 after printing LF_PRECOMP, I will fix that in a subsequent change as it doesn't seem like a trivial change.

[zturner]

I'm going to look at this today.

test/DebugInfo/precomp.test

15 ↗

(On Diff #141031)

Can you put some spaces here to line it up?

[zturner]

I was trying to play around with some precompiled header object files to make sure I understand how it all works, and I noticed our tools don't handle dumping types in .debug$P sections. So I added this in r329326. Just fyi.

[zturner]

test/DebugInfo/precomp.test

10–11 ↗

(On Diff #141031)

Can you change this to just dump -types instead of dump -all?

29–33 ↗

(On Diff #141031)

You can delete all of this Cross Module Exports stuff as it confuses the user (I originally thought these were XME records). In a recent patch I added a new header for types that appear in object files, so you can change this to something like:

PDB-PRECOMP:         Precompiled Types (.debug$P)
PDB-PRECOMP-NEXT: ============================================================
PDB-PRECOMP-NEXT: Showing 0 records
PDB-PRECOMP-NEXT: 0x1000 | LF_PRECOMP [size = 60] start index = 4096, types count = 1031, signature = 0x1116980E, precomp path = f:\svn\lld\test\coff\precomp\precomp.obj

[zturner]

include/llvm/DebugInfo/CodeView/TypeRecord.h

910 ↗

(On Diff #141031)

Currently, llvm-pdbutil does not jump from 0x1000 to 0x1407 after printing LF_PRECOMP, I will fix that in a subsequent change as it doesn't seem like a trivial change.

It seems like we could do a similar thing to what we do for LF_TYPESERVER records. But you're right it might not be trivial.

[aganea]

I rebased on latest trunk. Adressed issues raised by @zturner.
Also, add CodeViewTypes.def which I forgot previously. Changed LF_PRECOMP record .StartIndex and .Count to print out in hex format.

[zturner]

tools/llvm-pdbutil/MinimalTypeDumper.cpp

475–478 ↗

(On Diff #141359)

You can do {0:X+} instead of converting each of them manually. The X means print uppercase hex digits, and the + means print the 0x prefix.

llvm/trunk/include/llvm/DebugInfo/CodeView/CodeView.h

 #include <cinttypes>
 #include <type_traits>
 
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace codeview {
 
-/// Distinguishes individual records in .debug$T section or PDB type stream. The
-/// documentation and headers talk about this as the "leaf" type.
+/// Distinguishes individual records in .debug$T or .debug$P section or PDB type
+/// stream. The documentation and headers talk about this as the "leaf" type.
 enum class TypeRecordKind : uint16_t {
 #define TYPE_RECORD(lf_ename, value, name) name = value,
 #include "CodeViewTypes.def"
 };
 
 /// Duplicate copy of the above enum, but using the official CV names. Useful
 /// for reference purposes and when dealing with unknown record types.
 enum TypeLeafKind : uint16_t {

llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewTypes.def

 TYPE_RECORD(LF_SUBSTR_LIST, 0x1604, StringList)
 TYPE_RECORD(LF_STRING_ID, 0x1605, StringId)
 TYPE_RECORD(LF_UDT_SRC_LINE, 0x1606, UdtSourceLine)
 TYPE_RECORD(LF_UDT_MOD_SRC_LINE, 0x1607, UdtModSourceLine)
 
 
 TYPE_RECORD(LF_METHODLIST, 0x1206, MethodOverloadList)
 
+TYPE_RECORD(LF_PRECOMP, 0x1509, Precomp)
+TYPE_RECORD(LF_ENDPRECOMP, 0x0014, EndPrecomp)
 
 // 16 bit type records.
 CV_TYPE(LF_MODIFIER_16t, 0x0001)
 CV_TYPE(LF_POINTER_16t, 0x0002)
 CV_TYPE(LF_ARRAY_16t, 0x0003)
 CV_TYPE(LF_CLASS_16t, 0x0004)
 CV_TYPE(LF_STRUCTURE_16t, 0x0005)
 CV_TYPE(LF_UNION_16t, 0x0006)
 CV_TYPE(LF_ENUM_16t, 0x0007)
 CV_TYPE(LF_PROCEDURE_16t, 0x0008)
 CV_TYPE(LF_MFUNCTION_16t, 0x0009)
 CV_TYPE(LF_COBOL0_16t, 0x000b)
 CV_TYPE(LF_COBOL1, 0x000c)
 CV_TYPE(LF_BARRAY_16t, 0x000d)
 CV_TYPE(LF_NULLLEAF, 0x000f) // LF_NULL
 CV_TYPE(LF_NOTTRAN, 0x0010)
 CV_TYPE(LF_DIMARRAY_16t, 0x0011)
 CV_TYPE(LF_VFTPATH_16t, 0x0012)
 CV_TYPE(LF_PRECOMP_16t, 0x0013)
-CV_TYPE(LF_ENDPRECOMP, 0x0014)
 CV_TYPE(LF_OEM_16t, 0x0015)
 CV_TYPE(LF_TYPESERVER_ST, 0x0016)
 
 CV_TYPE(LF_SKIP_16t, 0x0200)
 CV_TYPE(LF_ARGLIST_16t, 0x0201)
 CV_TYPE(LF_DEFARG_16t, 0x0202)
 CV_TYPE(LF_LIST, 0x0203)
 CV_TYPE(LF_FIELDLIST_16t, 0x0204)

 CV_TYPE(LF_VFUNCOFF, 0x140c)
 CV_TYPE(LF_NESTTYPEEX_ST, 0x140d)
 CV_TYPE(LF_MEMBERMODIFY_ST, 0x140e)
 CV_TYPE(LF_MANAGED_ST, 0x140f)
 
 CV_TYPE(LF_ST_MAX, 0x1500)
 CV_TYPE(LF_TYPESERVER, 0x1501)
 CV_TYPE(LF_DIMARRAY, 0x1508)
-CV_TYPE(LF_PRECOMP, 0x1509)
 CV_TYPE(LF_ALIAS, 0x150a)
 CV_TYPE(LF_DEFARG, 0x150b)
 CV_TYPE(LF_FRIENDFCN, 0x150c)
 CV_TYPE(LF_NESTTYPEEX, 0x1512)
 CV_TYPE(LF_MEMBERMODIFY, 0x1513)
 CV_TYPE(LF_MANAGED, 0x1514)
 CV_TYPE(LF_STRIDED_ARRAY, 0x1516)
 CV_TYPE(LF_HLSL, 0x1517)

llvm/trunk/include/llvm/DebugInfo/CodeView/TypeRecord.h

-//===- TypeRecord.h ---------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
-#define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
-
-#include "llvm/ADT/APSInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/DebugInfo/CodeView/CVRecord.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/GUID.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/Support/BinaryStreamArray.h"
-#include "llvm/Support/Endian.h"
-#include <algorithm>
-#include <cstdint>
-#include <vector>
-
-namespace llvm {
-namespace codeview {
-
-using support::little32_t;
-using support::ulittle16_t;
-using support::ulittle32_t;
-
-using CVType = CVRecord<TypeLeafKind>;
-using RemappedType = RemappedRecord<TypeLeafKind>;
-
-struct CVMemberRecord {
-  TypeLeafKind Kind;
-  ArrayRef<uint8_t> Data;
-};
-using CVTypeArray = VarStreamArray<CVType>;
-using CVTypeRange = iterator_range<CVTypeArray::Iterator>;
-
-/// Equvalent to CV_fldattr_t in cvinfo.h.
-struct MemberAttributes {
-  uint16_t Attrs = 0;
-
-  enum {
-    MethodKindShift = 2,
-  };
-
-  MemberAttributes() = default;
-
-  explicit MemberAttributes(MemberAccess Access)
-      : Attrs(static_cast<uint16_t>(Access)) {}
-
-  MemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Flags) {
-    Attrs = static_cast<uint16_t>(Access);
-    Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift);
-    Attrs |= static_cast<uint16_t>(Flags);
-  }
-
-  /// Get the access specifier. Valid for any kind of member.
-  MemberAccess getAccess() const {
-    return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
-  }
-
-  /// Indicates if a method is defined with friend, virtual, static, etc.
-  MethodKind getMethodKind() const {
-    return MethodKind(
-        (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >>
-        MethodKindShift);
-  }
-
-  /// Get the flags that are not included in access control or method
-  /// properties.
-  MethodOptions getFlags() const {
-    return MethodOptions(
-        unsigned(Attrs) &
-        ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));
-  }
-
-  /// Is this method virtual.
-  bool isVirtual() const {
-    auto MP = getMethodKind();
-    return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&
-           MP != MethodKind::Static;
-  }
-
-  /// Does this member introduce a new virtual method.
-  bool isIntroducedVirtual() const {
-    auto MP = getMethodKind();
-    return MP == MethodKind::IntroducingVirtual ||
-           MP == MethodKind::PureIntroducingVirtual;
-  }
-};
-
-// Does not correspond to any tag, this is the tail of an LF_POINTER record
-// if it represents a member pointer.
-class MemberPointerInfo {
-public:
-  MemberPointerInfo() = default;
-
-  MemberPointerInfo(TypeIndex ContainingType,
-                    PointerToMemberRepresentation Representation)
-      : ContainingType(ContainingType), Representation(Representation) {}
-
-  TypeIndex getContainingType() const { return ContainingType; }
-  PointerToMemberRepresentation getRepresentation() const {
-    return Representation;
-  }
-
-  TypeIndex ContainingType;
-  PointerToMemberRepresentation Representation;
-};
-
-class TypeRecord {
-protected:
-  TypeRecord() = default;
-  explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
-
-public:
-  TypeRecordKind getKind() const { return Kind; }
-
-  TypeRecordKind Kind;
-};
-
-// LF_MODIFIER
-class ModifierRecord : public TypeRecord {
-public:
-  ModifierRecord() = default;
-  explicit ModifierRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)
-      : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType),
-        Modifiers(Modifiers) {}
-
-  TypeIndex getModifiedType() const { return ModifiedType; }
-  ModifierOptions getModifiers() const { return Modifiers; }
-
-  TypeIndex ModifiedType;
-  ModifierOptions Modifiers;
-};
-
-// LF_PROCEDURE
-class ProcedureRecord : public TypeRecord {
-public:
-  ProcedureRecord() = default;
-  explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
-                  FunctionOptions Options, uint16_t ParameterCount,
-                  TypeIndex ArgumentList)
-      : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType),
-        CallConv(CallConv), Options(Options), ParameterCount(ParameterCount),
-        ArgumentList(ArgumentList) {}
-
-  TypeIndex getReturnType() const { return ReturnType; }
-  CallingConvention getCallConv() const { return CallConv; }
-  FunctionOptions getOptions() const { return Options; }
-  uint16_t getParameterCount() const { return ParameterCount; }
-  TypeIndex getArgumentList() const { return ArgumentList; }
-
-  TypeIndex ReturnType;
-  CallingConvention CallConv;
-  FunctionOptions Options;
-  uint16_t ParameterCount;
-  TypeIndex ArgumentList;
-};
-
-// LF_MFUNCTION
-class MemberFunctionRecord : public TypeRecord {
-public:
-  MemberFunctionRecord() = default;
-  explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
-  MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
-                       TypeIndex ThisType, CallingConvention CallConv,
-                       FunctionOptions Options, uint16_t ParameterCount,
-                       TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
-      : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType),
-        ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),
-        Options(Options), ParameterCount(ParameterCount),
-        ArgumentList(ArgumentList),
-        ThisPointerAdjustment(ThisPointerAdjustment) {}
-
-  TypeIndex getReturnType() const { return ReturnType; }
-  TypeIndex getClassType() const { return ClassType; }
-  TypeIndex getThisType() const { return ThisType; }
-  CallingConvention getCallConv() const { return CallConv; }
-  FunctionOptions getOptions() const { return Options; }
-  uint16_t getParameterCount() const { return ParameterCount; }
-  TypeIndex getArgumentList() const { return ArgumentList; }
-  int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; }
-
-  TypeIndex ReturnType;
-  TypeIndex ClassType;
-  TypeIndex ThisType;
-  CallingConvention CallConv;
-  FunctionOptions Options;
-  uint16_t ParameterCount;
-  TypeIndex ArgumentList;
-  int32_t ThisPointerAdjustment;
-};
-
-// LF_LABEL
-class LabelRecord : public TypeRecord {
-public:
-  LabelRecord() = default;
-  explicit LabelRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
-  LabelRecord(LabelType Mode) : TypeRecord(TypeRecordKind::Label), Mode(Mode) {}
-
-  LabelType Mode;
-};
-
-// LF_MFUNC_ID
-class MemberFuncIdRecord : public TypeRecord {
-public:
-  MemberFuncIdRecord() = default;
-  explicit MemberFuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
-                         StringRef Name)
-      : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),
-        FunctionType(FunctionType), Name(Name) {}
-
-  TypeIndex getClassType() const { return ClassType; }
-  TypeIndex getFunctionType() const { return FunctionType; }
-  StringRef getName() const { return Name; }
-
-  TypeIndex ClassType;
-  TypeIndex FunctionType;
-  StringRef Name;
-};
-
-// LF_ARGLIST
-class ArgListRecord : public TypeRecord {
-public:
-  ArgListRecord() = default;
-  explicit ArgListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
-  ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
-      : TypeRecord(Kind), ArgIndices(Indices) {}
-
-  ArrayRef<TypeIndex> getIndices() const { return ArgIndices; }
-
-  std::vector<TypeIndex> ArgIndices;
-};
-
-// LF_SUBSTR_LIST
-class StringListRecord : public TypeRecord {
-public:
-  StringListRecord() = default;
-  explicit StringListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
-  StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
-      : TypeRecord(Kind), StringIndices(Indices) {}
-
-  ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
-
-  std::vector<TypeIndex> StringIndices;
-};
-
-// LF_POINTER
-class PointerRecord : public TypeRecord {
-public:
-  static const uint32_t PointerKindShift = 0;
-  static const uint32_t PointerKindMask = 0x1F;
-
-  static const uint32_t PointerModeShift = 5;
-  static const uint32_t PointerModeMask = 0x07;
-
-  static const uint32_t PointerOptionMask = 0xFF;
-
-  static const uint32_t PointerSizeShift = 13;
-  static const uint32_t PointerSizeMask = 0xFF;
-
-  PointerRecord() = default;
-  explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
-  PointerRecord(TypeIndex ReferentType, uint32_t Attrs)
-      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        Attrs(Attrs) {}
-
-  PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
-                PointerOptions PO, uint8_t Size)
-      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        Attrs(calcAttrs(PK, PM, PO, Size)) {}
-
-  PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
-                PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI)
-      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(MPI) {}
-
-  TypeIndex getReferentType() const { return ReferentType; }
-
-  PointerKind getPointerKind() const {
-    return static_cast<PointerKind>((Attrs >> PointerKindShift) &
-                                    PointerKindMask);
-  }
-
-  PointerMode getMode() const {
-    return static_cast<PointerMode>((Attrs >> PointerModeShift) &
-                                    PointerModeMask);
-  }
-
-  PointerOptions getOptions() const {
-    return static_cast<PointerOptions>(Attrs);
-  }
-
-  uint8_t getSize() const {
-    return (Attrs >> PointerSizeShift) & PointerSizeMask;
-  }
-
-  MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
-
-  bool isPointerToMember() const {
-    return getMode() == PointerMode::PointerToDataMember ||
-           getMode() == PointerMode::PointerToMemberFunction;
-  }
-
-  bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }
-  bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }
-
-  bool isVolatile() const {
-    return !!(Attrs & uint32_t(PointerOptions::Volatile));
-  }
-
-  bool isUnaligned() const {
-    return !!(Attrs & uint32_t(PointerOptions::Unaligned));
-  }
-
-  bool isRestrict() const {
-    return !!(Attrs & uint32_t(PointerOptions::Restrict));
-  }
-
-  TypeIndex ReferentType;
-  uint32_t Attrs;
-  Optional<MemberPointerInfo> MemberInfo;
-
-  void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
-                uint8_t Size) {
-    Attrs = calcAttrs(PK, PM, PO, Size);
-  }
-
-private:
-  static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
-                            uint8_t Size) {
-    uint32_t A = 0;
-    A |= static_cast<uint32_t>(PK);
-    A |= static_cast<uint32_t>(PO);
-    A |= (static_cast<uint32_t>(PM) << PointerModeShift);
-    A |= (static_cast<uint32_t>(Size) << PointerSizeShift);
-    return A;
-  }
-};
-
-// LF_NESTTYPE
-class NestedTypeRecord : public TypeRecord {
-public:
-  NestedTypeRecord() = default;
-  explicit NestedTypeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  NestedTypeRecord(TypeIndex Type, StringRef Name)
-      : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}
-
-  TypeIndex getNestedType() const { return Type; }
-  StringRef getName() const { return Name; }
-
-  TypeIndex Type;
-  StringRef Name;
-};
-
-// LF_FIELDLIST
-class FieldListRecord : public TypeRecord {
-public:
-  FieldListRecord() = default;
-  explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  explicit FieldListRecord(ArrayRef<uint8_t> Data)
-      : TypeRecord(TypeRecordKind::FieldList), Data(Data) {}
-
-  ArrayRef<uint8_t> Data;
-};
-
-// LF_ARRAY
-class ArrayRecord : public TypeRecord {
-public:
-  ArrayRecord() = default;
-  explicit ArrayRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
-              StringRef Name)
-      : TypeRecord(TypeRecordKind::Array), ElementType(ElementType),
-        IndexType(IndexType), Size(Size), Name(Name) {}
-
-  TypeIndex getElementType() const { return ElementType; }
-  TypeIndex getIndexType() const { return IndexType; }
-  uint64_t getSize() const { return Size; }
-  StringRef getName() const { return Name; }
-
-  TypeIndex ElementType;
-  TypeIndex IndexType;
-  uint64_t Size;
-  StringRef Name;
-};
-
-class TagRecord : public TypeRecord {
-protected:
-  TagRecord() = default;
-  explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
-            TypeIndex FieldList, StringRef Name, StringRef UniqueName)
-      : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),
-        FieldList(FieldList), Name(Name), UniqueName(UniqueName) {}
-
-public:
-  static const int HfaKindShift = 11;
-  static const int HfaKindMask = 0x1800;
-  static const int WinRTKindShift = 14;
-  static const int WinRTKindMask = 0xC000;
-
-  bool hasUniqueName() const {
-    return (Options & ClassOptions::HasUniqueName) != ClassOptions::None;
-  }
-
-  bool isNested() const {
-    return (Options & ClassOptions::Nested) != ClassOptions::None;
-  }
-
-  bool isForwardRef() const {
-    return (Options & ClassOptions::ForwardReference) != ClassOptions::None;
-  }
-
-  uint16_t getMemberCount() const { return MemberCount; }
-  ClassOptions getOptions() const { return Options; }
-  TypeIndex getFieldList() const { return FieldList; }
-  StringRef getName() const { return Name; }
-  StringRef getUniqueName() const { return UniqueName; }
-
-  uint16_t MemberCount;
-  ClassOptions Options;
-  TypeIndex FieldList;
-  StringRef Name;
-  StringRef UniqueName;
-};
-
-// LF_CLASS, LF_STRUCTURE, LF_INTERFACE
-class ClassRecord : public TagRecord {
-public:
-  ClassRecord() = default;
-  explicit ClassRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
-  ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
-              TypeIndex FieldList, TypeIndex DerivationList,
-              TypeIndex VTableShape, uint64_t Size, StringRef Name,
-              StringRef UniqueName)
-      : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName),
-        DerivationList(DerivationList), VTableShape(VTableShape), Size(Size) {}
-
-  HfaKind getHfa() const {
-    uint16_t Value = static_cast<uint16_t>(Options);
-    Value = (Value & HfaKindMask) >> HfaKindShift;
-    return static_cast<HfaKind>(Value);
-  }
-
-  WindowsRTClassKind getWinRTKind() const {
-    uint16_t Value = static_cast<uint16_t>(Options);
-    Value = (Value & WinRTKindMask) >> WinRTKindShift;
-    return static_cast<WindowsRTClassKind>(Value);
-  }
-
-  TypeIndex getDerivationList() const { return DerivationList; }
-  TypeIndex getVTableShape() const { return VTableShape; }
-  uint64_t getSize() const { return Size; }
-
-  TypeIndex DerivationList;
-  TypeIndex VTableShape;
-  uint64_t Size;
-};
-
-// LF_UNION
-struct UnionRecord : public TagRecord {
-  UnionRecord() = default;
-  explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
-  UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
-              uint64_t Size, StringRef Name, StringRef UniqueName)
-      : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,
-                  UniqueName),
-        Size(Size) {}
-
-  HfaKind getHfa() const {
-    uint16_t Value = static_cast<uint16_t>(Options);
-    Value = (Value & HfaKindMask) >> HfaKindShift;
-    return static_cast<HfaKind>(Value);
-  }
-
-  uint64_t getSize() const { return Size; }
-
-  uint64_t Size;
-};
-
-// LF_ENUM
-class EnumRecord : public TagRecord {
-public:
-  EnumRecord() = default;
-  explicit EnumRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
-  EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
-             StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)
-      : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,
-                  UniqueName),
-        UnderlyingType(UnderlyingType) {}
-
-  TypeIndex getUnderlyingType() const { return UnderlyingType; }
-
-  TypeIndex UnderlyingType;
-};
-
-// LF_BITFIELD
-class BitFieldRecord : public TypeRecord {
-public:
-  BitFieldRecord() = default;
-  explicit BitFieldRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
-      : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize),
-        BitOffset(BitOffset) {}
-
-  TypeIndex getType() const { return Type; }
-  uint8_t getBitOffset() const { return BitOffset; }
-  uint8_t getBitSize() const { return BitSize; }
-
-  TypeIndex Type;
-  uint8_t BitSize;
-  uint8_t BitOffset;
-};
-
-// LF_VTSHAPE
-class VFTableShapeRecord : public TypeRecord {
-public:
-  VFTableShapeRecord() = default;
-  explicit VFTableShapeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)
-      : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}
-  explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
-      : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}
-
-  ArrayRef<VFTableSlotKind> getSlots() const {
-    if (!SlotsRef.empty())
-      return SlotsRef;
-    return Slots;
-  }
-
-  uint32_t getEntryCount() const { return getSlots().size(); }
-
-  ArrayRef<VFTableSlotKind> SlotsRef;
-  std::vector<VFTableSlotKind> Slots;
-};
-
-// LF_TYPESERVER2
-class TypeServer2Record : public TypeRecord {
-public:
-  TypeServer2Record() = default;
-  explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  TypeServer2Record(StringRef GuidStr, uint32_t Age, StringRef Name)
-      : TypeRecord(TypeRecordKind::TypeServer2), Age(Age), Name(Name) {
-    assert(GuidStr.size() == 16 && "guid isn't 16 bytes");
-    ::memcpy(Guid.Guid, GuidStr.data(), 16);
-  }
-
-  const GUID &getGuid() const { return Guid; }
-  uint32_t getAge() const { return Age; }
-  StringRef getName() const { return Name; }
-
-  GUID Guid;
-  uint32_t Age;
-  StringRef Name;
-};
-
-// LF_STRING_ID
-class StringIdRecord : public TypeRecord {
-public:
-  StringIdRecord() = default;
-  explicit StringIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  StringIdRecord(TypeIndex Id, StringRef String)
-      : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}
-
-  TypeIndex getId() const { return Id; }
-  StringRef getString() const { return String; }
-
-  TypeIndex Id;
-  StringRef String;
-};
-
-// LF_FUNC_ID
-class FuncIdRecord : public TypeRecord {
-public:
-  FuncIdRecord() = default;
-  explicit FuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
-      : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),
-        FunctionType(FunctionType), Name(Name) {}
-
-  TypeIndex getParentScope() const { return ParentScope; }
-  TypeIndex getFunctionType() const { return FunctionType; }
-  StringRef getName() const { return Name; }
-
-  TypeIndex ParentScope;
-  TypeIndex FunctionType;
-  StringRef Name;
-};
-
-// LF_UDT_SRC_LINE
-class UdtSourceLineRecord : public TypeRecord {
-public:
-  UdtSourceLineRecord() = default;
-  explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
-      : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
-        SourceFile(SourceFile), LineNumber(LineNumber) {}
-
-  TypeIndex getUDT() const { return UDT; }
-  TypeIndex getSourceFile() const { return SourceFile; }
-  uint32_t getLineNumber() const { return LineNumber; }
-
-  TypeIndex UDT;
-  TypeIndex SourceFile;
-  uint32_t LineNumber;
-};
-
-// LF_UDT_MOD_SRC_LINE
-class UdtModSourceLineRecord : public TypeRecord {
-public:
-  UdtModSourceLineRecord() = default;
-  explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
-                         uint32_t LineNumber, uint16_t Module)
-      : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
-        SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {}
-
-  TypeIndex getUDT() const { return UDT; }
-  TypeIndex getSourceFile() const { return SourceFile; }
-  uint32_t getLineNumber() const { return LineNumber; }
-  uint16_t getModule() const { return Module; }
-
-  TypeIndex UDT;
-  TypeIndex SourceFile;
-  uint32_t LineNumber;
-  uint16_t Module;
-};
-
-// LF_BUILDINFO
-class BuildInfoRecord : public TypeRecord {
-public:
-  BuildInfoRecord() = default;
-  explicit BuildInfoRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
-      : TypeRecord(TypeRecordKind::BuildInfo),
-        ArgIndices(ArgIndices.begin(), ArgIndices.end()) {}
-
-  ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
-
-  SmallVector<TypeIndex, 4> ArgIndices;
-};
-
-// LF_VFTABLE
-class VFTableRecord : public TypeRecord {
-public:
-  VFTableRecord() = default;
-  explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
-                uint32_t VFPtrOffset, StringRef Name,
-                ArrayRef<StringRef> Methods)
-      : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass),
-        OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) {
-    MethodNames.push_back(Name);
-    MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.end());
-  }
-
-  TypeIndex getCompleteClass() const { return CompleteClass; }
-  TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
-  uint32_t getVFPtrOffset() const { return VFPtrOffset; }
-  StringRef getName() const { return makeArrayRef(MethodNames).front(); }
-
-  ArrayRef<StringRef> getMethodNames() const {
-    return makeArrayRef(MethodNames).drop_front();
-  }
-
-  TypeIndex CompleteClass;
-  TypeIndex OverriddenVFTable;
-  uint32_t VFPtrOffset;
-  std::vector<StringRef> MethodNames;
-};
-
-// LF_ONEMETHOD
-class OneMethodRecord : public TypeRecord {
-public:
-  OneMethodRecord() = default;
-  explicit OneMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,
-                  StringRef Name)
-      : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Attrs(Attrs),
-        VFTableOffset(VFTableOffset), Name(Name) {}
-  OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind MK,
-                  MethodOptions Options, int32_t VFTableOffset, StringRef Name)
-      : TypeRecord(TypeRecordKind::OneMethod), Type(Type),
-        Attrs(Access, MK, Options), VFTableOffset(VFTableOffset), Name(Name) {}
-
-  TypeIndex getType() const { return Type; }
-  MethodKind getMethodKind() const { return Attrs.getMethodKind(); }
-  MethodOptions getOptions() const { return Attrs.getFlags(); }
-  MemberAccess getAccess() const { return Attrs.getAccess(); }
-  int32_t getVFTableOffset() const { return VFTableOffset; }
-  StringRef getName() const { return Name; }
-
-  bool isIntroducingVirtual() const {
-    return getMethodKind() == MethodKind::IntroducingVirtual ||
-           getMethodKind() == MethodKind::PureIntroducingVirtual;
-  }
-
-  TypeIndex Type;
-  MemberAttributes Attrs;
-  int32_t VFTableOffset;
-  StringRef Name;
-};
-
-// LF_METHODLIST
-class MethodOverloadListRecord : public TypeRecord {
-public:
-  MethodOverloadListRecord() = default;
-  explicit MethodOverloadListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)
-      : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}
-
-  ArrayRef<OneMethodRecord> getMethods() const { return Methods; }
-
-  std::vector<OneMethodRecord> Methods;
-};
-
-/// For method overload sets.  LF_METHOD
-class OverloadedMethodRecord : public TypeRecord {
-public:
-  OverloadedMethodRecord() = default;
-  explicit OverloadedMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
-                         StringRef Name)
-      : TypeRecord(TypeRecordKind::OverloadedMethod),
-        NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}
-
-  uint16_t getNumOverloads() const { return NumOverloads; }
-  TypeIndex getMethodList() const { return MethodList; }
-  StringRef getName() const { return Name; }
-
-  uint16_t NumOverloads;
-  TypeIndex MethodList;
-  StringRef Name;
-};
-
-// LF_MEMBER
-class DataMemberRecord : public TypeRecord {
-public:
-  DataMemberRecord() = default;
-  explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset,
-                   StringRef Name)
-      : TypeRecord(TypeRecordKind::DataMember), Attrs(Attrs), Type(Type),
-        FieldOffset(Offset), Name(Name) {}
-  DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
-                   StringRef Name)
-      : TypeRecord(TypeRecordKind::DataMember), Attrs(Access), Type(Type),
-        FieldOffset(Offset), Name(Name) {}
-
-  MemberAccess getAccess() const { return Attrs.getAccess(); }
-  TypeIndex getType() const { return Type; }
-  uint64_t getFieldOffset() const { return FieldOffset; }
-  StringRef getName() const { return Name; }
-
-  MemberAttributes Attrs;
-  TypeIndex Type;
-  uint64_t FieldOffset;
-  StringRef Name;
-};
-
-// LF_STMEMBER
-class StaticDataMemberRecord : public TypeRecord {
-public:
-  StaticDataMemberRecord() = default;
-  explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)
-      : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type),
-        Name(Name) {}
-  StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
-      : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Access), Type(Type),
-        Name(Name) {}
-
-  MemberAccess getAccess() const { return Attrs.getAccess(); }
-  TypeIndex getType() const { return Type; }
-  StringRef getName() const { return Name; }
-
-  MemberAttributes Attrs;
-  TypeIndex Type;
-  StringRef Name;
-};
-
-// LF_ENUMERATE
-class EnumeratorRecord : public TypeRecord {
-public:
-  EnumeratorRecord() = default;
-  explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name)
-      : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs),
-        Value(std::move(Value)), Name(Name) {}
-  EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
-      : TypeRecord(TypeRecordKind::Enumerator), Attrs(Access),
-        Value(std::move(Value)), Name(Name) {}
-
-  MemberAccess getAccess() const { return Attrs.getAccess(); }
-  APSInt getValue() const { return Value; }
-  StringRef getName() const { return Name; }
-
-  MemberAttributes Attrs;
-  APSInt Value;
-  StringRef Name;
-};
-
-// LF_VFUNCTAB
-class VFPtrRecord : public TypeRecord {
-public:
-  VFPtrRecord() = default;
-  explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  VFPtrRecord(TypeIndex Type)
-      : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
-
-  TypeIndex getType() const { return Type; }
-
-  TypeIndex Type;
-};
-
-// LF_BCLASS, LF_BINTERFACE
-class BaseClassRecord : public TypeRecord {
-public:
-  BaseClassRecord() = default;
-  explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)
-      : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type),
-        Offset(Offset) {}
-  BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
-      : TypeRecord(TypeRecordKind::BaseClass), Attrs(Access), Type(Type),
-        Offset(Offset) {}
-
-  MemberAccess getAccess() const { return Attrs.getAccess(); }
-  TypeIndex getBaseType() const { return Type; }
-  uint64_t getBaseOffset() const { return Offset; }
-
-  MemberAttributes Attrs;
-  TypeIndex Type;
-  uint64_t Offset;
-};
-
-// LF_VBCLASS, LF_IVBCLASS
-class VirtualBaseClassRecord : public TypeRecord {
-public:
-  VirtualBaseClassRecord() = default;
-  explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  VirtualBaseClassRecord(TypeRecordKind Kind, MemberAttributes Attrs,
-                         TypeIndex BaseType, TypeIndex VBPtrType,
-                         uint64_t Offset, uint64_t Index)
-      : TypeRecord(Kind), Attrs(Attrs), BaseType(BaseType),
-        VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
-  VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access,
-                         TypeIndex BaseType, TypeIndex VBPtrType,
-                         uint64_t Offset, uint64_t Index)
-      : TypeRecord(Kind), Attrs(Access), BaseType(BaseType),
-        VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
-
-  MemberAccess getAccess() const { return Attrs.getAccess(); }
-  TypeIndex getBaseType() const { return BaseType; }
-  TypeIndex getVBPtrType() const { return VBPtrType; }
-  uint64_t getVBPtrOffset() const { return VBPtrOffset; }
-  uint64_t getVTableIndex() const { return VTableIndex; }
-
-  MemberAttributes Attrs;
-  TypeIndex BaseType;
-  TypeIndex VBPtrType;
-  uint64_t VBPtrOffset;
-  uint64_t VTableIndex;
-};
-
-/// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records
-/// together. The first will end in an LF_INDEX record that points to the next.
-class ListContinuationRecord : public TypeRecord {
-public:
-  ListContinuationRecord() = default;
-  explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  ListContinuationRecord(TypeIndex ContinuationIndex)
-      : TypeRecord(TypeRecordKind::ListContinuation),
-        ContinuationIndex(ContinuationIndex) {}
-
-  TypeIndex getContinuationIndex() const { return ContinuationIndex; }
-
-  TypeIndex ContinuationIndex;
-};
-
-} // end namespace codeview
-} // end namespace llvm
-
-#endif // LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
+//===- TypeRecord.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
+#define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
+
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/GUID.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/Support/BinaryStreamArray.h"
+#include "llvm/Support/Endian.h"
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+namespace codeview {
+
+using support::little32_t;
+using support::ulittle16_t;
+using support::ulittle32_t;
+
+using CVType = CVRecord<TypeLeafKind>;
+using RemappedType = RemappedRecord<TypeLeafKind>;
+
+struct CVMemberRecord {
+  TypeLeafKind Kind;
+  ArrayRef<uint8_t> Data;
+};
+using CVTypeArray = VarStreamArray<CVType>;
+using CVTypeRange = iterator_range<CVTypeArray::Iterator>;
+
+/// Equvalent to CV_fldattr_t in cvinfo.h.
+struct MemberAttributes {
+  uint16_t Attrs = 0;
+
+  enum {
+    MethodKindShift = 2,
+  };
+
+  MemberAttributes() = default;
+
+  explicit MemberAttributes(MemberAccess Access)
+      : Attrs(static_cast<uint16_t>(Access)) {}
+
+  MemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Flags) {
+    Attrs = static_cast<uint16_t>(Access);
+    Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift);
+    Attrs |= static_cast<uint16_t>(Flags);
+  }
+
+  /// Get the access specifier. Valid for any kind of member.
+  MemberAccess getAccess() const {
+    return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
+  }
+
+  /// Indicates if a method is defined with friend, virtual, static, etc.
+  MethodKind getMethodKind() const {
+    return MethodKind(
+        (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >>
+        MethodKindShift);
+  }
+
+  /// Get the flags that are not included in access control or method
+  /// properties.
+  MethodOptions getFlags() const {
+    return MethodOptions(
+        unsigned(Attrs) &
+        ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));
+  }
+
+  /// Is this method virtual.
+  bool isVirtual() const {
+    auto MP = getMethodKind();
+    return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&
+           MP != MethodKind::Static;
+  }
+
+  /// Does this member introduce a new virtual method.
+  bool isIntroducedVirtual() const {
+    auto MP = getMethodKind();
+    return MP == MethodKind::IntroducingVirtual ||
+           MP == MethodKind::PureIntroducingVirtual;
+  }
+};
+
+// Does not correspond to any tag, this is the tail of an LF_POINTER record
+// if it represents a member pointer.
+class MemberPointerInfo {
+public:
+  MemberPointerInfo() = default;
+
+  MemberPointerInfo(TypeIndex ContainingType,
+                    PointerToMemberRepresentation Representation)
+      : ContainingType(ContainingType), Representation(Representation) {}
+
+  TypeIndex getContainingType() const { return ContainingType; }
+  PointerToMemberRepresentation getRepresentation() const {
+    return Representation;
+  }
+
+  TypeIndex ContainingType;
+  PointerToMemberRepresentation Representation;
+};
+
+class TypeRecord {
+protected:
+  TypeRecord() = default;
+  explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
+
+public:
+  TypeRecordKind getKind() const { return Kind; }
+
+  TypeRecordKind Kind;
+};
+
+// LF_MODIFIER
+class ModifierRecord : public TypeRecord {
+public:
+  ModifierRecord() = default;
+  explicit ModifierRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)
+      : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType),
+        Modifiers(Modifiers) {}
+
+  TypeIndex getModifiedType() const { return ModifiedType; }
+  ModifierOptions getModifiers() const { return Modifiers; }
+
+  TypeIndex ModifiedType;
+  ModifierOptions Modifiers;
+};
+
+// LF_PROCEDURE
+class ProcedureRecord : public TypeRecord {
+public:
+  ProcedureRecord() = default;
+  explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
+                  FunctionOptions Options, uint16_t ParameterCount,
+                  TypeIndex ArgumentList)
+      : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType),
+        CallConv(CallConv), Options(Options), ParameterCount(ParameterCount),
+        ArgumentList(ArgumentList) {}
+
+  TypeIndex getReturnType() const { return ReturnType; }
+  CallingConvention getCallConv() const { return CallConv; }
+  FunctionOptions getOptions() const { return Options; }
+  uint16_t getParameterCount() const { return ParameterCount; }
+  TypeIndex getArgumentList() const { return ArgumentList; }
+
+  TypeIndex ReturnType;
+  CallingConvention CallConv;
+  FunctionOptions Options;
+  uint16_t ParameterCount;
+  TypeIndex ArgumentList;
+};
+
+// LF_MFUNCTION
+class MemberFunctionRecord : public TypeRecord {
+public:
+  MemberFunctionRecord() = default;
+  explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
+                       TypeIndex ThisType, CallingConvention CallConv,
+                       FunctionOptions Options, uint16_t ParameterCount,
+                       TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
+      : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType),
+        ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),
+        Options(Options), ParameterCount(ParameterCount),
+        ArgumentList(ArgumentList),
+        ThisPointerAdjustment(ThisPointerAdjustment) {}
+
+  TypeIndex getReturnType() const { return ReturnType; }
+  TypeIndex getClassType() const { return ClassType; }
+  TypeIndex getThisType() const { return ThisType; }
+  CallingConvention getCallConv() const { return CallConv; }
+  FunctionOptions getOptions() const { return Options; }
+  uint16_t getParameterCount() const { return ParameterCount; }
+  TypeIndex getArgumentList() const { return ArgumentList; }
+  int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; }
+
+  TypeIndex ReturnType;
+  TypeIndex ClassType;
+  TypeIndex ThisType;
+  CallingConvention CallConv;
+  FunctionOptions Options;
+  uint16_t ParameterCount;
+  TypeIndex ArgumentList;
+  int32_t ThisPointerAdjustment;
+};
+
+// LF_LABEL
+class LabelRecord : public TypeRecord {
+public:
+  LabelRecord() = default;
+  explicit LabelRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  LabelRecord(LabelType Mode) : TypeRecord(TypeRecordKind::Label), Mode(Mode) {}
+
+  LabelType Mode;
+};
+
+// LF_MFUNC_ID
+class MemberFuncIdRecord : public TypeRecord {
+public:
+  MemberFuncIdRecord() = default;
+  explicit MemberFuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
+                         StringRef Name)
+      : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),
+        FunctionType(FunctionType), Name(Name) {}
+
+  TypeIndex getClassType() const { return ClassType; }
+  TypeIndex getFunctionType() const { return FunctionType; }
+  StringRef getName() const { return Name; }
+
+  TypeIndex ClassType;
+  TypeIndex FunctionType;
+  StringRef Name;
+};
+
+// LF_ARGLIST
+class ArgListRecord : public TypeRecord {
+public:
+  ArgListRecord() = default;
+  explicit ArgListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
+      : TypeRecord(Kind), ArgIndices(Indices) {}
+
+  ArrayRef<TypeIndex> getIndices() const { return ArgIndices; }
+
+  std::vector<TypeIndex> ArgIndices;
+};
+
+// LF_SUBSTR_LIST
+class StringListRecord : public TypeRecord {
+public:
+  StringListRecord() = default;
+  explicit StringListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
+      : TypeRecord(Kind), StringIndices(Indices) {}
+
+  ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
+
+  std::vector<TypeIndex> StringIndices;
+};
+
+// LF_POINTER
+class PointerRecord : public TypeRecord {
+public:
+  static const uint32_t PointerKindShift = 0;
+  static const uint32_t PointerKindMask = 0x1F;
+
+  static const uint32_t PointerModeShift = 5;
+  static const uint32_t PointerModeMask = 0x07;
+
+  static const uint32_t PointerOptionMask = 0xFF;
+
+  static const uint32_t PointerSizeShift = 13;
+  static const uint32_t PointerSizeMask = 0xFF;
+
+  PointerRecord() = default;
+  explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  PointerRecord(TypeIndex ReferentType, uint32_t Attrs)
+      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
+        Attrs(Attrs) {}
+
+  PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
+                PointerOptions PO, uint8_t Size)
+      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
+        Attrs(calcAttrs(PK, PM, PO, Size)) {}
+
+  PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
+                PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI)
+      : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
+        Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(MPI) {}
+
+  TypeIndex getReferentType() const { return ReferentType; }
+
+  PointerKind getPointerKind() const {
+    return static_cast<PointerKind>((Attrs >> PointerKindShift) &
+                                    PointerKindMask);
+  }
+
+  PointerMode getMode() const {
+    return static_cast<PointerMode>((Attrs >> PointerModeShift) &
+                                    PointerModeMask);
+  }
+
+  PointerOptions getOptions() const {
+    return static_cast<PointerOptions>(Attrs);
+  }
+
+  uint8_t getSize() const {
+    return (Attrs >> PointerSizeShift) & PointerSizeMask;
+  }
+
+  MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
+
+  bool isPointerToMember() const {
+    return getMode() == PointerMode::PointerToDataMember ||
+           getMode() == PointerMode::PointerToMemberFunction;
+  }
+
+  bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }
+  bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }
+
+  bool isVolatile() const {
+    return !!(Attrs & uint32_t(PointerOptions::Volatile));
+  }
+
+  bool isUnaligned() const {
+    return !!(Attrs & uint32_t(PointerOptions::Unaligned));
+  }
+
+  bool isRestrict() const {
+    return !!(Attrs & uint32_t(PointerOptions::Restrict));
+  }
+
+  TypeIndex ReferentType;
+  uint32_t Attrs;
+  Optional<MemberPointerInfo> MemberInfo;
+
+  void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
+                uint8_t Size) {
+    Attrs = calcAttrs(PK, PM, PO, Size);
+  }
+
+private:
+  static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
+                            uint8_t Size) {
+    uint32_t A = 0;
+    A |= static_cast<uint32_t>(PK);
+    A |= static_cast<uint32_t>(PO);
+    A |= (static_cast<uint32_t>(PM) << PointerModeShift);
+    A |= (static_cast<uint32_t>(Size) << PointerSizeShift);
+    return A;
+  }
+};
+
+// LF_NESTTYPE
+class NestedTypeRecord : public TypeRecord {
+public:
+  NestedTypeRecord() = default;
+  explicit NestedTypeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  NestedTypeRecord(TypeIndex Type, StringRef Name)
+      : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}
+
+  TypeIndex getNestedType() const { return Type; }
+  StringRef getName() const { return Name; }
+
+  TypeIndex Type;
+  StringRef Name;
+};
+
+// LF_FIELDLIST
+class FieldListRecord : public TypeRecord {
+public:
+  FieldListRecord() = default;
+  explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  explicit FieldListRecord(ArrayRef<uint8_t> Data)
+      : TypeRecord(TypeRecordKind::FieldList), Data(Data) {}
+
+  ArrayRef<uint8_t> Data;
+};
+
+// LF_ARRAY
+class ArrayRecord : public TypeRecord {
+public:
+  ArrayRecord() = default;
+  explicit ArrayRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
+              StringRef Name)
+      : TypeRecord(TypeRecordKind::Array), ElementType(ElementType),
+        IndexType(IndexType), Size(Size), Name(Name) {}
+
+  TypeIndex getElementType() const { return ElementType; }
+  TypeIndex getIndexType() const { return IndexType; }
+  uint64_t getSize() const { return Size; }
+  StringRef getName() const { return Name; }
+
+  TypeIndex ElementType;
+  TypeIndex IndexType;
+  uint64_t Size;
+  StringRef Name;
+};
+
+class TagRecord : public TypeRecord {
+protected:
+  TagRecord() = default;
+  explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
+            TypeIndex FieldList, StringRef Name, StringRef UniqueName)
+      : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),
+        FieldList(FieldList), Name(Name), UniqueName(UniqueName) {}
+
+public:
+  static const int HfaKindShift = 11;
+  static const int HfaKindMask = 0x1800;
+  static const int WinRTKindShift = 14;
+  static const int WinRTKindMask = 0xC000;
+
+  bool hasUniqueName() const {
+    return (Options & ClassOptions::HasUniqueName) != ClassOptions::None;
+  }
+
+  bool isNested() const {
+    return (Options & ClassOptions::Nested) != ClassOptions::None;
+  }
+
+  bool isForwardRef() const {
+    return (Options & ClassOptions::ForwardReference) != ClassOptions::None;
+  }
+
+  uint16_t getMemberCount() const { return MemberCount; }
+  ClassOptions getOptions() const { return Options; }
+  TypeIndex getFieldList() const { return FieldList; }
+  StringRef getName() const { return Name; }
+  StringRef getUniqueName() const { return UniqueName; }
+
+  uint16_t MemberCount;
+  ClassOptions Options;
+  TypeIndex FieldList;
+  StringRef Name;
+  StringRef UniqueName;
+};
+
+// LF_CLASS, LF_STRUCTURE, LF_INTERFACE
+class ClassRecord : public TagRecord {
+public:
+  ClassRecord() = default;
+  explicit ClassRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
+  ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
+              TypeIndex FieldList, TypeIndex DerivationList,
+              TypeIndex VTableShape, uint64_t Size, StringRef Name,
+              StringRef UniqueName)
+      : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName),
+        DerivationList(DerivationList), VTableShape(VTableShape), Size(Size) {}
+
+  HfaKind getHfa() const {
+    uint16_t Value = static_cast<uint16_t>(Options);
+    Value = (Value & HfaKindMask) >> HfaKindShift;
+    return static_cast<HfaKind>(Value);
+  }
+
+  WindowsRTClassKind getWinRTKind() const {
+    uint16_t Value = static_cast<uint16_t>(Options);
+    Value = (Value & WinRTKindMask) >> WinRTKindShift;
+    return static_cast<WindowsRTClassKind>(Value);
+  }
+
+  TypeIndex getDerivationList() const { return DerivationList; }
+  TypeIndex getVTableShape() const { return VTableShape; }
+  uint64_t getSize() const { return Size; }
+
+  TypeIndex DerivationList;
+  TypeIndex VTableShape;
+  uint64_t Size;
+};
+
+// LF_UNION
+struct UnionRecord : public TagRecord {
+  UnionRecord() = default;
+  explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
+  UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
+              uint64_t Size, StringRef Name, StringRef UniqueName)
+      : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,
+                  UniqueName),
+        Size(Size) {}
+
+  HfaKind getHfa() const {
+    uint16_t Value = static_cast<uint16_t>(Options);
+    Value = (Value & HfaKindMask) >> HfaKindShift;
+    return static_cast<HfaKind>(Value);
+  }
+
+  uint64_t getSize() const { return Size; }
+
+  uint64_t Size;
+};
+
+// LF_ENUM
+class EnumRecord : public TagRecord {
+public:
+  EnumRecord() = default;
+  explicit EnumRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
+  EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
+             StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)
+      : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,
+                  UniqueName),
+        UnderlyingType(UnderlyingType) {}
+
+  TypeIndex getUnderlyingType() const { return UnderlyingType; }
+
+  TypeIndex UnderlyingType;
+};
+
+// LF_BITFIELD
+class BitFieldRecord : public TypeRecord {
+public:
+  BitFieldRecord() = default;
+  explicit BitFieldRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
+      : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize),
+        BitOffset(BitOffset) {}
+
+  TypeIndex getType() const { return Type; }
+  uint8_t getBitOffset() const { return BitOffset; }
+  uint8_t getBitSize() const { return BitSize; }
+
+  TypeIndex Type;
+  uint8_t BitSize;
+  uint8_t BitOffset;
+};
+
+// LF_VTSHAPE
+class VFTableShapeRecord : public TypeRecord {
+public:
+  VFTableShapeRecord() = default;
+  explicit VFTableShapeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)
+      : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}
+  explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
+      : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}
+
+  ArrayRef<VFTableSlotKind> getSlots() const {
+    if (!SlotsRef.empty())
+      return SlotsRef;
+    return Slots;
+  }
+
+  uint32_t getEntryCount() const { return getSlots().size(); }
+
+  ArrayRef<VFTableSlotKind> SlotsRef;
+  std::vector<VFTableSlotKind> Slots;
+};
+
+// LF_TYPESERVER2
+class TypeServer2Record : public TypeRecord {
+public:
+  TypeServer2Record() = default;
+  explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  TypeServer2Record(StringRef GuidStr, uint32_t Age, StringRef Name)
+      : TypeRecord(TypeRecordKind::TypeServer2), Age(Age), Name(Name) {
+    assert(GuidStr.size() == 16 && "guid isn't 16 bytes");
+    ::memcpy(Guid.Guid, GuidStr.data(), 16);
+  }
+
+  const GUID &getGuid() const { return Guid; }
+  uint32_t getAge() const { return Age; }
+  StringRef getName() const { return Name; }
+
+  GUID Guid;
+  uint32_t Age;
+  StringRef Name;
+};
+
+// LF_STRING_ID
+class StringIdRecord : public TypeRecord {
+public:
+  StringIdRecord() = default;
+  explicit StringIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  StringIdRecord(TypeIndex Id, StringRef String)
+      : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}
+
+  TypeIndex getId() const { return Id; }
+  StringRef getString() const { return String; }
+
+  TypeIndex Id;
+  StringRef String;
+};
+
+// LF_FUNC_ID
+class FuncIdRecord : public TypeRecord {
+public:
+  FuncIdRecord() = default;
+  explicit FuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
+      : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),
+        FunctionType(FunctionType), Name(Name) {}
+
+  TypeIndex getParentScope() const { return ParentScope; }
+  TypeIndex getFunctionType() const { return FunctionType; }
+  StringRef getName() const { return Name; }
+
+  TypeIndex ParentScope;
+  TypeIndex FunctionType;
+  StringRef Name;
+};
+
+// LF_UDT_SRC_LINE
+class UdtSourceLineRecord : public TypeRecord {
+public:
+  UdtSourceLineRecord() = default;
+  explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
+      : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
+        SourceFile(SourceFile), LineNumber(LineNumber) {}
+
+  TypeIndex getUDT() const { return UDT; }
+  TypeIndex getSourceFile() const { return SourceFile; }
+  uint32_t getLineNumber() const { return LineNumber; }
+
+  TypeIndex UDT;
+  TypeIndex SourceFile;
+  uint32_t LineNumber;
+};
+
+// LF_UDT_MOD_SRC_LINE
+class UdtModSourceLineRecord : public TypeRecord {
+public:
+  UdtModSourceLineRecord() = default;
+  explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
+                         uint32_t LineNumber, uint16_t Module)
+      : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
+        SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {}
+
+  TypeIndex getUDT() const { return UDT; }
+  TypeIndex getSourceFile() const { return SourceFile; }
+  uint32_t getLineNumber() const { return LineNumber; }
+  uint16_t getModule() const { return Module; }
+
+  TypeIndex UDT;
+  TypeIndex SourceFile;
+  uint32_t LineNumber;
+  uint16_t Module;
+};
+
+// LF_BUILDINFO
+class BuildInfoRecord : public TypeRecord {
+public:
+  BuildInfoRecord() = default;
+  explicit BuildInfoRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
+      : TypeRecord(TypeRecordKind::BuildInfo),
+        ArgIndices(ArgIndices.begin(), ArgIndices.end()) {}
+
+  ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
+
+  SmallVector<TypeIndex, 4> ArgIndices;
+};
+
+// LF_VFTABLE
+class VFTableRecord : public TypeRecord {
+public:
+  VFTableRecord() = default;
+  explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
+                uint32_t VFPtrOffset, StringRef Name,
+                ArrayRef<StringRef> Methods)
+      : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass),
+        OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) {
+    MethodNames.push_back(Name);
+    MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.end());
+  }
+
+  TypeIndex getCompleteClass() const { return CompleteClass; }
+  TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
+  uint32_t getVFPtrOffset() const { return VFPtrOffset; }
+  StringRef getName() const { return makeArrayRef(MethodNames).front(); }
+
+  ArrayRef<StringRef> getMethodNames() const {
+    return makeArrayRef(MethodNames).drop_front();
+  }
+
+  TypeIndex CompleteClass;
+  TypeIndex OverriddenVFTable;
+  uint32_t VFPtrOffset;
+  std::vector<StringRef> MethodNames;
+};
+
+// LF_ONEMETHOD
+class OneMethodRecord : public TypeRecord {
+public:
+  OneMethodRecord() = default;
+  explicit OneMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,
+                  StringRef Name)
+      : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Attrs(Attrs),
+        VFTableOffset(VFTableOffset), Name(Name) {}
+  OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind MK,
+                  MethodOptions Options, int32_t VFTableOffset, StringRef Name)
+      : TypeRecord(TypeRecordKind::OneMethod), Type(Type),
+        Attrs(Access, MK, Options), VFTableOffset(VFTableOffset), Name(Name) {}
+
+  TypeIndex getType() const { return Type; }
+  MethodKind getMethodKind() const { return Attrs.getMethodKind(); }
+  MethodOptions getOptions() const { return Attrs.getFlags(); }
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
+  int32_t getVFTableOffset() const { return VFTableOffset; }
+  StringRef getName() const { return Name; }
+
+  bool isIntroducingVirtual() const {
+    return getMethodKind() == MethodKind::IntroducingVirtual ||
+           getMethodKind() == MethodKind::PureIntroducingVirtual;
+  }
+
+  TypeIndex Type;
+  MemberAttributes Attrs;
+  int32_t VFTableOffset;
+  StringRef Name;
+};
+
+// LF_METHODLIST
+class MethodOverloadListRecord : public TypeRecord {
+public:
+  MethodOverloadListRecord() = default;
+  explicit MethodOverloadListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)
+      : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}
+
+  ArrayRef<OneMethodRecord> getMethods() const { return Methods; }
+
+  std::vector<OneMethodRecord> Methods;
+};
+
+/// For method overload sets.  LF_METHOD
+class OverloadedMethodRecord : public TypeRecord {
+public:
+  OverloadedMethodRecord() = default;
+  explicit OverloadedMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
+                         StringRef Name)
+      : TypeRecord(TypeRecordKind::OverloadedMethod),
+        NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}
+
+  uint16_t getNumOverloads() const { return NumOverloads; }
+  TypeIndex getMethodList() const { return MethodList; }
+  StringRef getName() const { return Name; }
+
+  uint16_t NumOverloads;
+  TypeIndex MethodList;
+  StringRef Name;
+};
+
+// LF_MEMBER
+class DataMemberRecord : public TypeRecord {
+public:
+  DataMemberRecord() = default;
+  explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset,
+                   StringRef Name)
+      : TypeRecord(TypeRecordKind::DataMember), Attrs(Attrs), Type(Type),
+        FieldOffset(Offset), Name(Name) {}
+  DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
+                   StringRef Name)
+      : TypeRecord(TypeRecordKind::DataMember), Attrs(Access), Type(Type),
+        FieldOffset(Offset), Name(Name) {}
+
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
+  TypeIndex getType() const { return Type; }
+  uint64_t getFieldOffset() const { return FieldOffset; }
+  StringRef getName() const { return Name; }
+
+  MemberAttributes Attrs;
+  TypeIndex Type;
+  uint64_t FieldOffset;
+  StringRef Name;
+};
+
+// LF_STMEMBER
+class StaticDataMemberRecord : public TypeRecord {
+public:
+  StaticDataMemberRecord() = default;
+  explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)
+      : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type),
+        Name(Name) {}
+  StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
+      : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Access), Type(Type),
+        Name(Name) {}
+
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
+  TypeIndex getType() const { return Type; }
+  StringRef getName() const { return Name; }
+
+  MemberAttributes Attrs;
+  TypeIndex Type;
+  StringRef Name;
+};
+
+// LF_ENUMERATE
+class EnumeratorRecord : public TypeRecord {
+public:
+  EnumeratorRecord() = default;
+  explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name)
+      : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs),
+        Value(std::move(Value)), Name(Name) {}
+  EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
+      : TypeRecord(TypeRecordKind::Enumerator), Attrs(Access),
+        Value(std::move(Value)), Name(Name) {}
+
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
+  APSInt getValue() const { return Value; }
+  StringRef getName() const { return Name; }
+
+  MemberAttributes Attrs;
+  APSInt Value;
+  StringRef Name;
+};
+
+// LF_VFUNCTAB
+class VFPtrRecord : public TypeRecord {
+public:
+  VFPtrRecord() = default;
+  explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  VFPtrRecord(TypeIndex Type)
+      : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
+
+  TypeIndex getType() const { return Type; }
+
+  TypeIndex Type;
+};
+
+// LF_BCLASS, LF_BINTERFACE
+class BaseClassRecord : public TypeRecord {
+public:
+  BaseClassRecord() = default;
+  explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)
+      : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type),
+        Offset(Offset) {}
+  BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
+      : TypeRecord(TypeRecordKind::BaseClass), Attrs(Access), Type(Type),
+        Offset(Offset) {}
+
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
+  TypeIndex getBaseType() const { return Type; }
+  uint64_t getBaseOffset() const { return Offset; }
+
+  MemberAttributes Attrs;
+  TypeIndex Type;
+  uint64_t Offset;
+};
+
+// LF_VBCLASS, LF_IVBCLASS
+class VirtualBaseClassRecord : public TypeRecord {
+public:
+  VirtualBaseClassRecord() = default;
+  explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  VirtualBaseClassRecord(TypeRecordKind Kind, MemberAttributes Attrs,
+                         TypeIndex BaseType, TypeIndex VBPtrType,
+                         uint64_t Offset, uint64_t Index)
+      : TypeRecord(Kind), Attrs(Attrs), BaseType(BaseType),
+        VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
+  VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access,
+                         TypeIndex BaseType, TypeIndex VBPtrType,
+                         uint64_t Offset, uint64_t Index)
+      : TypeRecord(Kind), Attrs(Access), BaseType(BaseType),
+        VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
+
+  MemberAccess getAccess() const { return Attrs.getAccess(); }
+  TypeIndex getBaseType() const { return BaseType; }
+  TypeIndex getVBPtrType() const { return VBPtrType; }
+  uint64_t getVBPtrOffset() const { return VBPtrOffset; }
+  uint64_t getVTableIndex() const { return VTableIndex; }
+
+  MemberAttributes Attrs;
+  TypeIndex BaseType;
+  TypeIndex VBPtrType;
+  uint64_t VBPtrOffset;
+  uint64_t VTableIndex;
+};
+
+/// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records
+/// together. The first will end in an LF_INDEX record that points to the next.
+class ListContinuationRecord : public TypeRecord {
+public:
+  ListContinuationRecord() = default;
+  explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+  ListContinuationRecord(TypeIndex ContinuationIndex)
+      : TypeRecord(TypeRecordKind::ListContinuation),
+        ContinuationIndex(ContinuationIndex) {}
+
+  TypeIndex getContinuationIndex() const { return ContinuationIndex; }
+
+  TypeIndex ContinuationIndex;
+};
+
+// LF_PRECOMP
+class PrecompRecord : public TypeRecord {
+public:
+  PrecompRecord() = default;
+  explicit PrecompRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  uint32_t getStartTypeIndex() const { return StartTypeIndex; }
+  uint32_t getTypesCount() const { return TypesCount; }
+  uint32_t getSignature() const { return Signature; }
+  StringRef getPrecompFilePath() const { return PrecompFilePath; }
+
+  uint32_t StartTypeIndex;
+  uint32_t TypesCount;
+  uint32_t Signature;
+  StringRef PrecompFilePath;
+};
+
+// LF_ENDPRECOMP
+class EndPrecompRecord : public TypeRecord {
+public:
+  EndPrecompRecord() = default;
+  explicit EndPrecompRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
+
+  uint32_t getSignature() const { return Signature; }
+
+  uint32_t Signature;
+};
+} // end namespace codeview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H

llvm/trunk/include/llvm/ObjectYAML/COFFYAML.h

 };
 
 struct Section {
   COFF::section Header;
   unsigned Alignment = 0;
   yaml::BinaryRef SectionData;
   std::vector<CodeViewYAML::YAMLDebugSubsection> DebugS;
   std::vector<CodeViewYAML::LeafRecord> DebugT;
+  std::vector<CodeViewYAML::LeafRecord> DebugP;
   Optional<CodeViewYAML::DebugHSection> DebugH;
   std::vector<Relocation> Relocations;
   StringRef Name;
 
   Section();
 };
 
 struct Symbol {

llvm/trunk/include/llvm/ObjectYAML/CodeViewYAMLTypeHashing.h

 
 struct DebugHSection {
   uint32_t Magic;
   uint16_t Version;
   uint16_t HashAlgorithm;
   std::vector<GlobalHash> Hashes;
 };
 
-DebugHSection fromDebugH(ArrayRef<uint8_t> DebugT);
+DebugHSection fromDebugH(ArrayRef<uint8_t> DebugH);
 ArrayRef<uint8_t> toDebugH(const DebugHSection &DebugH,
                            BumpPtrAllocator &Alloc);
 
 } // end namespace CodeViewYAML
 
 } // end namespace llvm
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::DebugHSection)
 LLVM_YAML_DECLARE_SCALAR_TRAITS(CodeViewYAML::GlobalHash, QuotingType::None)
 LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::GlobalHash)
 
 #endif // LLVM_OBJECTYAML_CODEVIEWYAMLTYPES_H

llvm/trunk/include/llvm/ObjectYAML/CodeViewYAMLTypes.h

 struct LeafRecord {
   std::shared_ptr<detail::LeafRecordBase> Leaf;
 
   codeview::CVType
   toCodeViewRecord(codeview::AppendingTypeTableBuilder &Serializer) const;
   static Expected<LeafRecord> fromCodeViewRecord(codeview::CVType Type);
 };
 
-std::vector<LeafRecord> fromDebugT(ArrayRef<uint8_t> DebugT);
-ArrayRef<uint8_t> toDebugT(ArrayRef<LeafRecord>, BumpPtrAllocator &Alloc);
+std::vector<LeafRecord> fromDebugT(ArrayRef<uint8_t> DebugTorP,
+                                   StringRef SectionName);
+ArrayRef<uint8_t> toDebugT(ArrayRef<LeafRecord>, BumpPtrAllocator &Alloc,
+                           StringRef SectionName);
 
 } // end namespace CodeViewYAML
 
 } // end namespace llvm
 
 LLVM_YAML_DECLARE_SCALAR_TRAITS(codeview::GUID, QuotingType::Single)
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::LeafRecord)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::MemberRecord)
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::LeafRecord)
 LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::MemberRecord)
 
 #endif // LLVM_OBJECTYAML_CODEVIEWYAMLTYPES_H

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   void clear();
 
   void setCurrentSubprogram(const DISubprogram *SP) {
     CurrentSubprogram = SP;
     LocalUDTs.clear();
   }
 
   /// 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();
 
   void emitTypeGlobalHashes();
 
   void emitCompilerInformation();
 

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S,
   NullTerminatedString.push_back('\0');
   OS.EmitBytes(NullTerminatedString);
 }
 
 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();
 
   SmallString<8> CommentPrefix;
   if (OS.isVerboseAsm()) {
     CommentPrefix += '\t';
     CommentPrefix += Asm->MAI->getCommentString();
     CommentPrefix += ' ';

llvm/trunk/lib/DebugInfo/CodeView/RecordName.cpp

-//===- 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;
+}

llvm/trunk/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

-//===-- 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();
+}

llvm/trunk/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

-//===- 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();
+}

llvm/trunk/lib/ObjectYAML/COFFYAML.cpp

void MappingTraits<COFFYAML::Section>::mapping(IO &IO, COFFYAML::Section &Sec) {
   MappingNormalization<NSectionCharacteristics, uint32_t> NC(
       IO, Sec.Header.Characteristics);
   IO.mapRequired("Name", Sec.Name);
   IO.mapRequired("Characteristics", NC->Characteristics);
   IO.mapOptional("VirtualAddress", Sec.Header.VirtualAddress, 0U);
   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);
 
   IO.mapOptional("Relocations", Sec.Relocations);
 }
 
 void MappingTraits<COFFYAML::Object>::mapping(IO &IO, COFFYAML::Object &Obj) {
   IO.mapTag("!COFF", true);

llvm/trunk/lib/ObjectYAML/CodeViewYAMLTypes.cpp

-//===- 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;
+}

llvm/trunk/test/DebugInfo/precomp.test

+
+RUN: rm -rf %t1/
+RUN: mkdir %t1
+RUN: obj2yaml %S/Inputs/precomp-a.obj > %t1/precomp-a.yaml
+RUN: obj2yaml %S/Inputs/precomp.obj > %t1/precomp.yaml
+RUN: yaml2obj %t1/precomp-a.yaml > %t1/a.obj
+RUN: yaml2obj %t1/precomp.yaml > %t1/precomp.obj
+RUN: llvm-readobj -codeview %t1/a.obj | FileCheck %s -check-prefix PRECOMP
+RUN: llvm-readobj -codeview %t1/precomp.obj | FileCheck %s -check-prefix ENDPRECOMP
+RUN: llvm-pdbutil dump -types %t1/a.obj | FileCheck %s -check-prefix PDB-PRECOMP
+RUN: llvm-pdbutil dump -types %t1/precomp.obj | FileCheck %s -check-prefix PDB-ENDPRECOMP
+
+ENDPRECOMP:      CodeViewTypes [
+ENDPRECOMP-NEXT:   Section: .debug$P (3)
+ENDPRECOMP:        EndPrecomp (0x1407) {
+ENDPRECOMP-NEXT:     TypeLeafKind: LF_ENDPRECOMP (0x14)
+ENDPRECOMP-NEXT:     Signature: 0x1116980E
+ENDPRECOMP-NEXT:   }
+
+PRECOMP:      CodeViewTypes [
+PRECOMP-NEXT:   Section: .debug$T (3)
+PRECOMP-NEXT:   Magic: 0x4
+PRECOMP-NEXT:   Precomp (0x1000) {
+PRECOMP-NEXT:     TypeLeafKind: LF_PRECOMP (0x1509)
+PRECOMP-NEXT:     StartIndex: 0x1000
+PRECOMP-NEXT:     Count: 0x407
+PRECOMP-NEXT:     Signature: 0x1116980E
+
+PDB-PRECOMP:                              Types (.debug$T)
+PDB-PRECOMP-NEXT: ============================================================
+PDB-PRECOMP-NEXT: Showing 0 records
+PDB-PRECOMP-NEXT: 0x1000 | LF_PRECOMP [size = 60] start index = 0x1000, types count = 0x407, signature = 0x1116980E, precomp path = f:\svn\lld\test\coff\precomp\precomp.obj
+
+PDB-ENDPRECOMP:                     Precompiled Types (.debug$P)
+PDB-ENDPRECOMP-NEXT: ============================================================
+PDB-ENDPRECOMP-NEXT: Showing 0 records
+PDB-ENDPRECOMP:      0x1407 | LF_ENDPRECOMP [size = 8] signature = 0x1116980E
+
+# // precomp.h
+# #pragma once
+# int Function(char A);
+#
+# // precomp.cpp
+# // cl.exe precomp.cpp /Z7 /Ycprecomp.h /c
+# #include "precomp.h"
+#
+# // a.cpp
+# #include "precomp.h"
+# int main(void) {
+#   Function('a');
+#   return 0;
+# }
+#
+# // cl.exe a.cpp /Z7 /Yuprecomp.h /c
+#
+# // obj2yaml precomp.obj >precomp-precomp.yaml
+# // obj2yaml a.obj >precomp-a.yaml

llvm/trunk/tools/llvm-pdbutil/InputFile.cpp

if (!isCodeViewDebugSubsection(Section, ".debug$S", Reader))
     return false;
 
   cantFail(Reader.readArray(Subsections, Reader.bytesRemaining()));
   return true;
 }
 
 static bool isDebugTSection(SectionRef Section, CVTypeArray &Types) {
   BinaryStreamReader Reader;
-  if (!isCodeViewDebugSubsection(Section, ".debug$T", Reader))
+  if (!isCodeViewDebugSubsection(Section, ".debug$T", Reader) &&
+      !isCodeViewDebugSubsection(Section, ".debug$P", Reader))
     return false;
   cantFail(Reader.readArray(Types, Reader.bytesRemaining()));
   return true;
 }
 
 static std::string formatChecksumKind(FileChecksumKind Kind) {
   switch (Kind) {
     RETURN_CASE(FileChecksumKind, None, "None");

llvm/trunk/tools/llvm-pdbutil/MinimalTypeDumper.cpp

-//===- MinimalTypeDumper.cpp ---------------------------------- *- C++ --*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "MinimalTypeDumper.h"
-
-#include "FormatUtil.h"
-#include "LinePrinter.h"
-
-#include "llvm/DebugInfo/CodeView/CVRecord.h"
-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/Formatters.h"
-#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
-#include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/MathExtras.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-using namespace llvm::pdb;
-
-static std::string formatClassOptions(uint32_t IndentLevel,
-                                      ClassOptions Options) {
-  std::vector<std::string> Opts;
-  PUSH_FLAG(ClassOptions, HasConstructorOrDestructor, Options,
-            "has ctor / dtor");
-  PUSH_FLAG(ClassOptions, ContainsNestedClass, Options,
-            "contains nested class");
-  PUSH_FLAG(ClassOptions, HasConversionOperator, Options,
-            "conversion operator");
-  PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref");
-  PUSH_FLAG(ClassOptions, HasUniqueName, Options, "has unique name");
-  PUSH_FLAG(ClassOptions, Intrinsic, Options, "intrin");
-  PUSH_FLAG(ClassOptions, Nested, Options, "is nested");
-  PUSH_FLAG(ClassOptions, HasOverloadedOperator, Options,
-            "overloaded operator");
-  PUSH_FLAG(ClassOptions, HasOverloadedAssignmentOperator, Options,
-            "overloaded operator=");
-  PUSH_FLAG(ClassOptions, Packed, Options, "packed");
-  PUSH_FLAG(ClassOptions, Scoped, Options, "scoped");
-  PUSH_FLAG(ClassOptions, Sealed, Options, "sealed");
-
-  return typesetItemList(Opts, 4, IndentLevel, " | ");
-}
-
-static std::string pointerOptions(PointerOptions Options) {
-  std::vector<std::string> Opts;
-  PUSH_FLAG(PointerOptions, Flat32, Options, "flat32");
-  PUSH_FLAG(PointerOptions, Volatile, Options, "volatile");
-  PUSH_FLAG(PointerOptions, Const, Options, "const");
-  PUSH_FLAG(PointerOptions, Unaligned, Options, "unaligned");
-  PUSH_FLAG(PointerOptions, Restrict, Options, "restrict");
-  PUSH_FLAG(PointerOptions, WinRTSmartPointer, Options, "winrt");
-  if (Opts.empty())
-    return "None";
-  return join(Opts, " | ");
-}
-
-static std::string modifierOptions(ModifierOptions Options) {
-  std::vector<std::string> Opts;
-  PUSH_FLAG(ModifierOptions, Const, Options, "const");
-  PUSH_FLAG(ModifierOptions, Volatile, Options, "volatile");
-  PUSH_FLAG(ModifierOptions, Unaligned, Options, "unaligned");
-  if (Opts.empty())
-    return "None";
-  return join(Opts, " | ");
-}
-
-static std::string formatCallingConvention(CallingConvention Convention) {
-  switch (Convention) {
-    RETURN_CASE(CallingConvention, AlphaCall, "alphacall");
-    RETURN_CASE(CallingConvention, AM33Call, "am33call");
-    RETURN_CASE(CallingConvention, ArmCall, "armcall");
-    RETURN_CASE(CallingConvention, ClrCall, "clrcall");
-    RETURN_CASE(CallingConvention, FarC, "far cdecl");
-    RETURN_CASE(CallingConvention, FarFast, "far fastcall");
-    RETURN_CASE(CallingConvention, FarPascal, "far pascal");
-    RETURN_CASE(CallingConvention, FarStdCall, "far stdcall");
-    RETURN_CASE(CallingConvention, FarSysCall, "far syscall");
-    RETURN_CASE(CallingConvention, Generic, "generic");
-    RETURN_CASE(CallingConvention, Inline, "inline");
-    RETURN_CASE(CallingConvention, M32RCall, "m32rcall");
-    RETURN_CASE(CallingConvention, MipsCall, "mipscall");
-    RETURN_CASE(CallingConvention, NearC, "cdecl");
-    RETURN_CASE(CallingConvention, NearFast, "fastcall");
-    RETURN_CASE(CallingConvention, NearPascal, "pascal");
-    RETURN_CASE(CallingConvention, NearStdCall, "stdcall");
-    RETURN_CASE(CallingConvention, NearSysCall, "near syscall");
-    RETURN_CASE(CallingConvention, NearVector, "vectorcall");
-    RETURN_CASE(CallingConvention, PpcCall, "ppccall");
-    RETURN_CASE(CallingConvention, SHCall, "shcall");
-    RETURN_CASE(CallingConvention, SH5Call, "sh5call");
-    RETURN_CASE(CallingConvention, ThisCall, "thiscall");
-    RETURN_CASE(CallingConvention, TriCall, "tricall");
-  }
-  return formatUnknownEnum(Convention);
-}
-
-static std::string formatPointerMode(PointerMode Mode) {
-  switch (Mode) {
-    RETURN_CASE(PointerMode, LValueReference, "ref");
-    RETURN_CASE(PointerMode, Pointer, "pointer");
-    RETURN_CASE(PointerMode, PointerToDataMember, "data member pointer");
-    RETURN_CASE(PointerMode, PointerToMemberFunction, "member fn pointer");
-    RETURN_CASE(PointerMode, RValueReference, "rvalue ref");
-  }
-  return formatUnknownEnum(Mode);
-}
-
-static std::string memberAccess(MemberAccess Access) {
-  switch (Access) {
-    RETURN_CASE(MemberAccess, None, "");
-    RETURN_CASE(MemberAccess, Private, "private");
-    RETURN_CASE(MemberAccess, Protected, "protected");
-    RETURN_CASE(MemberAccess, Public, "public");
-  }
-  return formatUnknownEnum(Access);
-}
-
-static std::string methodKind(MethodKind Kind) {
-  switch (Kind) {
-    RETURN_CASE(MethodKind, Vanilla, "");
-    RETURN_CASE(MethodKind, Virtual, "virtual");
-    RETURN_CASE(MethodKind, Static, "static");
-    RETURN_CASE(MethodKind, Friend, "friend");
-    RETURN_CASE(MethodKind, IntroducingVirtual, "intro virtual");
-    RETURN_CASE(MethodKind, PureVirtual, "pure virtual");
-    RETURN_CASE(MethodKind, PureIntroducingVirtual, "pure intro virtual");
-  }
-  return formatUnknownEnum(Kind);
-}
-
-static std::string pointerKind(PointerKind Kind) {
-  switch (Kind) {
-    RETURN_CASE(PointerKind, Near16, "ptr16");
-    RETURN_CASE(PointerKind, Far16, "far ptr16");
-    RETURN_CASE(PointerKind, Huge16, "huge ptr16");
-    RETURN_CASE(PointerKind, BasedOnSegment, "segment based");
-    RETURN_CASE(PointerKind, BasedOnValue, "value based");
-    RETURN_CASE(PointerKind, BasedOnSegmentValue, "segment value based");
-    RETURN_CASE(PointerKind, BasedOnAddress, "address based");
-    RETURN_CASE(PointerKind, BasedOnSegmentAddress, "segment address based");
-    RETURN_CASE(PointerKind, BasedOnType, "type based");
-    RETURN_CASE(PointerKind, BasedOnSelf, "self based");
-    RETURN_CASE(PointerKind, Near32, "ptr32");
-    RETURN_CASE(PointerKind, Far32, "far ptr32");
-    RETURN_CASE(PointerKind, Near64, "ptr64");
-  }
-  return formatUnknownEnum(Kind);
-}
-
-static std::string memberAttributes(const MemberAttributes &Attrs) {
-  std::vector<std::string> Opts;
-  std::string Access = memberAccess(Attrs.getAccess());
-  std::string Kind = methodKind(Attrs.getMethodKind());
-  if (!Access.empty())
-    Opts.push_back(Access);
-  if (!Kind.empty())
-    Opts.push_back(Kind);
-  MethodOptions Flags = Attrs.getFlags();
-  PUSH_FLAG(MethodOptions, Pseudo, Flags, "pseudo");
-  PUSH_FLAG(MethodOptions, NoInherit, Flags, "noinherit");
-  PUSH_FLAG(MethodOptions, NoConstruct, Flags, "noconstruct");
-  PUSH_FLAG(MethodOptions, CompilerGenerated, Flags, "compiler-generated");
-  PUSH_FLAG(MethodOptions, Sealed, Flags, "sealed");
-  return join(Opts, " ");
-}
-
-static std::string formatPointerAttrs(const PointerRecord &Record) {
-  PointerMode Mode = Record.getMode();
-  PointerOptions Opts = Record.getOptions();
-  PointerKind Kind = Record.getPointerKind();
-  return formatv("mode = {0}, opts = {1}, kind = {2}", formatPointerMode(Mode),
-                 pointerOptions(Opts), pointerKind(Kind));
-}
-
-static std::string formatFunctionOptions(FunctionOptions Options) {
-  std::vector<std::string> Opts;
-
-  PUSH_FLAG(FunctionOptions, CxxReturnUdt, Options, "returns cxx udt");
-  PUSH_FLAG(FunctionOptions, ConstructorWithVirtualBases, Options,
-            "constructor with virtual bases");
-  PUSH_FLAG(FunctionOptions, Constructor, Options, "constructor");
-  if (Opts.empty())
-    return "None";
-  return join(Opts, " | ");
-}
-
-Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
-  // formatLine puts the newline at the beginning, so we use formatLine here
-  // to start a new line, and then individual visit methods use format to
-  // append to the existing line.
-  if (!Hashes) {
-    P.formatLine("{0} | {1} [size = {2}]",
-                 fmt_align(Index, AlignStyle::Right, Width),
-                 formatTypeLeafKind(Record.Type), Record.length());
-  } else {
-    std::string H;
-    if (Index.toArrayIndex() >= HashValues.size()) {
-      H = "(not present)";
-    } else {
-      uint32_t Hash = HashValues[Index.toArrayIndex()];
-      Expected<uint32_t> MaybeHash = hashTypeRecord(Record);
-      if (!MaybeHash)
-        return MaybeHash.takeError();
-      uint32_t OurHash = *MaybeHash;
-      OurHash %= NumHashBuckets;
-      if (Hash == OurHash)
-        H = "0x" + utohexstr(Hash);
-      else
-        H = "0x" + utohexstr(Hash) + ", our hash = 0x" + utohexstr(OurHash);
-    }
-    P.formatLine("{0} | {1} [size = {2}, hash = {3}]",
-                 fmt_align(Index, AlignStyle::Right, Width),
-                 formatTypeLeafKind(Record.Type), Record.length(), H);
-  }
-  P.Indent(Width + 3);
-  return Error::success();
-}
-Error MinimalTypeDumpVisitor::visitTypeEnd(CVType &Record) {
-  P.Unindent(Width + 3);
-  if (RecordBytes) {
-    AutoIndent Indent(P, 9);
-    P.formatBinary("Bytes", Record.RecordData, 0);
-  }
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
-  P.formatLine("- {0}", formatTypeLeafKind(Record.Kind));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
-  if (RecordBytes) {
-    AutoIndent Indent(P, 2);
-    P.formatBinary("Bytes", Record.Data, 0);
-  }
-  return Error::success();
-}
-
-StringRef MinimalTypeDumpVisitor::getTypeName(TypeIndex TI) const {
-  if (TI.isNoneType())
-    return "";
-  return Types.getTypeName(TI);
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               FieldListRecord &FieldList) {
-  if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
-    return EC;
-
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               StringIdRecord &String) {
-  P.format(" ID: {0}, String: {1}", String.getId(), String.getString());
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               ArgListRecord &Args) {
-  auto Indices = Args.getIndices();
-  if (Indices.empty())
-    return Error::success();
-
-  auto Max = std::max_element(Indices.begin(), Indices.end());
-  uint32_t W = NumDigits(Max->getIndex()) + 2;
-
-  for (auto I : Indices)
-    P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
-                 getTypeName(I));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               StringListRecord &Strings) {
-  auto Indices = Strings.getIndices();
-  if (Indices.empty())
-    return Error::success();
-
-  auto Max = std::max_element(Indices.begin(), Indices.end());
-  uint32_t W = NumDigits(Max->getIndex()) + 2;
-
-  for (auto I : Indices)
-    P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
-                 getTypeName(I));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               ClassRecord &Class) {
-  P.format(" `{0}`", Class.Name);
-  if (Class.hasUniqueName())
-    P.formatLine("unique name: `{0}`", Class.UniqueName);
-  P.formatLine("vtable: {0}, base list: {1}, field list: {2}",
-               Class.VTableShape, Class.DerivationList, Class.FieldList);
-  P.formatLine("options: {0}",
-               formatClassOptions(P.getIndentLevel(), Class.Options));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               UnionRecord &Union) {
-  P.format(" `{0}`", Union.Name);
-  if (Union.hasUniqueName())
-    P.formatLine("unique name: `{0}`", Union.UniqueName);
-  P.formatLine("field list: {0}", Union.FieldList);
-  P.formatLine("options: {0}",
-               formatClassOptions(P.getIndentLevel(), Union.Options));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
-  P.format(" `{0}`", Enum.Name);
-  if (Enum.hasUniqueName())
-    P.formatLine("unique name: `{0}`", Enum.UniqueName);
-  P.formatLine("field list: {0}, underlying type: {1}", Enum.FieldList,
-               Enum.UnderlyingType);
-  P.formatLine("options: {0}",
-               formatClassOptions(P.getIndentLevel(), Enum.Options));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
-  if (AT.Name.empty()) {
-    P.formatLine("size: {0}, index type: {1}, element type: {2}", AT.Size,
-                 AT.IndexType, AT.ElementType);
-  } else {
-    P.formatLine("name: {0}, size: {1}, index type: {2}, element type: {3}",
-                 AT.Name, AT.Size, AT.IndexType, AT.ElementType);
-  }
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               VFTableRecord &VFT) {
-  P.formatLine("offset: {0}, complete class: {1}, overridden vftable: {2}",
-               VFT.VFPtrOffset, VFT.CompleteClass, VFT.OverriddenVFTable);
-  P.formatLine("method names: ");
-  if (!VFT.MethodNames.empty()) {
-    std::string Sep =
-        formatv("\n{0}",
-                fmt_repeat(' ', P.getIndentLevel() + strlen("method names: ")))
-            .str();
-    P.print(join(VFT.MethodNames, Sep));
-  }
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               MemberFuncIdRecord &Id) {
-  P.formatLine("name = {0}, type = {1}, class type = {2}", Id.Name,
-               Id.FunctionType, Id.ClassType);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               ProcedureRecord &Proc) {
-  P.formatLine("return type = {0}, # args = {1}, param list = {2}",
-               Proc.ReturnType, Proc.ParameterCount, Proc.ArgumentList);
-  P.formatLine("calling conv = {0}, options = {1}",
-               formatCallingConvention(Proc.CallConv),
-               formatFunctionOptions(Proc.Options));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               MemberFunctionRecord &MF) {
-  P.formatLine("return type = {0}, # args = {1}, param list = {2}",
-               MF.ReturnType, MF.ParameterCount, MF.ArgumentList);
-  P.formatLine("class type = {0}, this type = {1}, this adjust = {2}",
-               MF.ClassType, MF.ThisType, MF.ThisPointerAdjustment);
-  P.formatLine("calling conv = {0}, options = {1}",
-               formatCallingConvention(MF.CallConv),
-               formatFunctionOptions(MF.Options));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               FuncIdRecord &Func) {
-  P.formatLine("name = {0}, type = {1}, parent scope = {2}", Func.Name,
-               Func.FunctionType, Func.ParentScope);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               TypeServer2Record &TS) {
-  P.formatLine("name = {0}, age = {1}, guid = {2}", TS.Name, TS.Age, TS.Guid);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               PointerRecord &Ptr) {
-  P.formatLine("referent = {0}, {1}", Ptr.ReferentType,
-               formatPointerAttrs(Ptr));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               ModifierRecord &Mod) {
-  P.formatLine("referent = {0}, modifiers = {1}", Mod.ModifiedType,
-               modifierOptions(Mod.Modifiers));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               VFTableShapeRecord &Shape) {
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               UdtModSourceLineRecord &U) {
-  P.formatLine("udt = {0}, mod = {1}, file = {2}, line = {3}", U.UDT, U.Module,
-               U.SourceFile.getIndex(), U.LineNumber);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               UdtSourceLineRecord &U) {
-  P.formatLine("udt = {0}, file = {1}, line = {2}", U.UDT,
-               U.SourceFile.getIndex(), U.LineNumber);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               BitFieldRecord &BF) {
-  P.formatLine("type = {0}, bit offset = {1}, # bits = {2}", BF.Type,
-               BF.BitOffset, BF.BitSize);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(
-    CVType &CVR, MethodOverloadListRecord &Overloads) {
-  for (auto &M : Overloads.Methods)
-    P.formatLine("- Method [type = {0}, vftable offset = {1}, attrs = {2}]",
-                 M.Type, M.VFTableOffset, memberAttributes(M.Attrs));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
-                                               BuildInfoRecord &BI) {
-  auto Indices = BI.ArgIndices;
-  if (Indices.empty())
-    return Error::success();
-
-  auto Max = std::max_element(Indices.begin(), Indices.end());
-  uint32_t W = NumDigits(Max->getIndex()) + 2;
-
-  for (auto I : Indices)
-    P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
-                 getTypeName(I));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &R) {
-  std::string Type = (R.Mode == LabelType::Far) ? "far" : "near";
-  P.format(" type = {0}", Type);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               NestedTypeRecord &Nested) {
-  P.format(" [name = `{0}`, parent = {1}]", Nested.Name, Nested.Type);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               OneMethodRecord &Method) {
-  P.format(" [name = `{0}`]", Method.Name);
-  AutoIndent Indent(P);
-  P.formatLine("type = {0}, vftable offset = {1}, attrs = {2}", Method.Type,
-               Method.VFTableOffset, memberAttributes(Method.Attrs));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               OverloadedMethodRecord &Method) {
-  P.format(" [name = `{0}`, # overloads = {1}, overload list = {2}]",
-           Method.Name, Method.NumOverloads, Method.MethodList);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               DataMemberRecord &Field) {
-  P.format(" [name = `{0}`, Type = {1}, offset = {2}, attrs = {3}]", Field.Name,
-           Field.Type, Field.FieldOffset, memberAttributes(Field.Attrs));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               StaticDataMemberRecord &Field) {
-  P.format(" [name = `{0}`, type = {1}, attrs = {2}]", Field.Name, Field.Type,
-           memberAttributes(Field.Attrs));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               EnumeratorRecord &Enum) {
-  P.format(" [{0} = {1}]", Enum.Name,
-           Enum.Value.toString(10, Enum.Value.isSigned()));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               BaseClassRecord &Base) {
-  AutoIndent Indent(P);
-  P.formatLine("type = {0}, offset = {1}, attrs = {2}", Base.Type, Base.Offset,
-               memberAttributes(Base.Attrs));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               VirtualBaseClassRecord &Base) {
-  AutoIndent Indent(P);
-  P.formatLine(
-      "base = {0}, vbptr = {1}, vbptr offset = {2}, vtable index = {3}",
-      Base.BaseType, Base.VBPtrType, Base.VBPtrOffset, Base.VTableIndex);
-  P.formatLine("attrs = {0}", memberAttributes(Base.Attrs));
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               ListContinuationRecord &Cont) {
-  P.format(" continuation = {0}", Cont.ContinuationIndex);
-  return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
-                                               VFPtrRecord &VFP) {
-  P.format(" type = {0}", VFP.Type);
-  return Error::success();
-}
+//===- MinimalTypeDumper.cpp ---------------------------------- *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MinimalTypeDumper.h"
+
+#include "FormatUtil.h"
+#include "LinePrinter.h"
+
+#include "llvm/DebugInfo/CodeView/CVRecord.h"
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/DebugInfo/CodeView/Formatters.h"
+#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/MathExtras.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+using namespace llvm::pdb;
+
+static std::string formatClassOptions(uint32_t IndentLevel,
+                                      ClassOptions Options) {
+  std::vector<std::string> Opts;
+  PUSH_FLAG(ClassOptions, HasConstructorOrDestructor, Options,
+            "has ctor / dtor");
+  PUSH_FLAG(ClassOptions, ContainsNestedClass, Options,
+            "contains nested class");
+  PUSH_FLAG(ClassOptions, HasConversionOperator, Options,
+            "conversion operator");
+  PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref");
+  PUSH_FLAG(ClassOptions, HasUniqueName, Options, "has unique name");
+  PUSH_FLAG(ClassOptions, Intrinsic, Options, "intrin");
+  PUSH_FLAG(ClassOptions, Nested, Options, "is nested");
+  PUSH_FLAG(ClassOptions, HasOverloadedOperator, Options,
+            "overloaded operator");
+  PUSH_FLAG(ClassOptions, HasOverloadedAssignmentOperator, Options,
+            "overloaded operator=");
+  PUSH_FLAG(ClassOptions, Packed, Options, "packed");
+  PUSH_FLAG(ClassOptions, Scoped, Options, "scoped");
+  PUSH_FLAG(ClassOptions, Sealed, Options, "sealed");
+
+  return typesetItemList(Opts, 4, IndentLevel, " | ");
+}
+
+static std::string pointerOptions(PointerOptions Options) {
+  std::vector<std::string> Opts;
+  PUSH_FLAG(PointerOptions, Flat32, Options, "flat32");
+  PUSH_FLAG(PointerOptions, Volatile, Options, "volatile");
+  PUSH_FLAG(PointerOptions, Const, Options, "const");
+  PUSH_FLAG(PointerOptions, Unaligned, Options, "unaligned");
+  PUSH_FLAG(PointerOptions, Restrict, Options, "restrict");
+  PUSH_FLAG(PointerOptions, WinRTSmartPointer, Options, "winrt");
+  if (Opts.empty())
+    return "None";
+  return join(Opts, " | ");
+}
+
+static std::string modifierOptions(ModifierOptions Options) {
+  std::vector<std::string> Opts;
+  PUSH_FLAG(ModifierOptions, Const, Options, "const");
+  PUSH_FLAG(ModifierOptions, Volatile, Options, "volatile");
+  PUSH_FLAG(ModifierOptions, Unaligned, Options, "unaligned");
+  if (Opts.empty())
+    return "None";
+  return join(Opts, " | ");
+}
+
+static std::string formatCallingConvention(CallingConvention Convention) {
+  switch (Convention) {
+    RETURN_CASE(CallingConvention, AlphaCall, "alphacall");
+    RETURN_CASE(CallingConvention, AM33Call, "am33call");
+    RETURN_CASE(CallingConvention, ArmCall, "armcall");
+    RETURN_CASE(CallingConvention, ClrCall, "clrcall");
+    RETURN_CASE(CallingConvention, FarC, "far cdecl");
+    RETURN_CASE(CallingConvention, FarFast, "far fastcall");
+    RETURN_CASE(CallingConvention, FarPascal, "far pascal");
+    RETURN_CASE(CallingConvention, FarStdCall, "far stdcall");
+    RETURN_CASE(CallingConvention, FarSysCall, "far syscall");
+    RETURN_CASE(CallingConvention, Generic, "generic");
+    RETURN_CASE(CallingConvention, Inline, "inline");
+    RETURN_CASE(CallingConvention, M32RCall, "m32rcall");
+    RETURN_CASE(CallingConvention, MipsCall, "mipscall");
+    RETURN_CASE(CallingConvention, NearC, "cdecl");
+    RETURN_CASE(CallingConvention, NearFast, "fastcall");
+    RETURN_CASE(CallingConvention, NearPascal, "pascal");
+    RETURN_CASE(CallingConvention, NearStdCall, "stdcall");
+    RETURN_CASE(CallingConvention, NearSysCall, "near syscall");
+    RETURN_CASE(CallingConvention, NearVector, "vectorcall");
+    RETURN_CASE(CallingConvention, PpcCall, "ppccall");
+    RETURN_CASE(CallingConvention, SHCall, "shcall");
+    RETURN_CASE(CallingConvention, SH5Call, "sh5call");
+    RETURN_CASE(CallingConvention, ThisCall, "thiscall");
+    RETURN_CASE(CallingConvention, TriCall, "tricall");
+  }
+  return formatUnknownEnum(Convention);
+}
+
+static std::string formatPointerMode(PointerMode Mode) {
+  switch (Mode) {
+    RETURN_CASE(PointerMode, LValueReference, "ref");
+    RETURN_CASE(PointerMode, Pointer, "pointer");
+    RETURN_CASE(PointerMode, PointerToDataMember, "data member pointer");
+    RETURN_CASE(PointerMode, PointerToMemberFunction, "member fn pointer");
+    RETURN_CASE(PointerMode, RValueReference, "rvalue ref");
+  }
+  return formatUnknownEnum(Mode);
+}
+
+static std::string memberAccess(MemberAccess Access) {
+  switch (Access) {
+    RETURN_CASE(MemberAccess, None, "");
+    RETURN_CASE(MemberAccess, Private, "private");
+    RETURN_CASE(MemberAccess, Protected, "protected");
+    RETURN_CASE(MemberAccess, Public, "public");
+  }
+  return formatUnknownEnum(Access);
+}
+
+static std::string methodKind(MethodKind Kind) {
+  switch (Kind) {
+    RETURN_CASE(MethodKind, Vanilla, "");
+    RETURN_CASE(MethodKind, Virtual, "virtual");
+    RETURN_CASE(MethodKind, Static, "static");
+    RETURN_CASE(MethodKind, Friend, "friend");
+    RETURN_CASE(MethodKind, IntroducingVirtual, "intro virtual");
+    RETURN_CASE(MethodKind, PureVirtual, "pure virtual");
+    RETURN_CASE(MethodKind, PureIntroducingVirtual, "pure intro virtual");
+  }
+  return formatUnknownEnum(Kind);
+}
+
+static std::string pointerKind(PointerKind Kind) {
+  switch (Kind) {
+    RETURN_CASE(PointerKind, Near16, "ptr16");
+    RETURN_CASE(PointerKind, Far16, "far ptr16");
+    RETURN_CASE(PointerKind, Huge16, "huge ptr16");
+    RETURN_CASE(PointerKind, BasedOnSegment, "segment based");
+    RETURN_CASE(PointerKind, BasedOnValue, "value based");
+    RETURN_CASE(PointerKind, BasedOnSegmentValue, "segment value based");
+    RETURN_CASE(PointerKind, BasedOnAddress, "address based");
+    RETURN_CASE(PointerKind, BasedOnSegmentAddress, "segment address based");
+    RETURN_CASE(PointerKind, BasedOnType, "type based");
+    RETURN_CASE(PointerKind, BasedOnSelf, "self based");
+    RETURN_CASE(PointerKind, Near32, "ptr32");
+    RETURN_CASE(PointerKind, Far32, "far ptr32");
+    RETURN_CASE(PointerKind, Near64, "ptr64");
+  }
+  return formatUnknownEnum(Kind);
+}
+
+static std::string memberAttributes(const MemberAttributes &Attrs) {
+  std::vector<std::string> Opts;
+  std::string Access = memberAccess(Attrs.getAccess());
+  std::string Kind = methodKind(Attrs.getMethodKind());
+  if (!Access.empty())
+    Opts.push_back(Access);
+  if (!Kind.empty())
+    Opts.push_back(Kind);
+  MethodOptions Flags = Attrs.getFlags();
+  PUSH_FLAG(MethodOptions, Pseudo, Flags, "pseudo");
+  PUSH_FLAG(MethodOptions, NoInherit, Flags, "noinherit");
+  PUSH_FLAG(MethodOptions, NoConstruct, Flags, "noconstruct");
+  PUSH_FLAG(MethodOptions, CompilerGenerated, Flags, "compiler-generated");
+  PUSH_FLAG(MethodOptions, Sealed, Flags, "sealed");
+  return join(Opts, " ");
+}
+
+static std::string formatPointerAttrs(const PointerRecord &Record) {
+  PointerMode Mode = Record.getMode();
+  PointerOptions Opts = Record.getOptions();
+  PointerKind Kind = Record.getPointerKind();
+  return formatv("mode = {0}, opts = {1}, kind = {2}", formatPointerMode(Mode),
+                 pointerOptions(Opts), pointerKind(Kind));
+}
+
+static std::string formatFunctionOptions(FunctionOptions Options) {
+  std::vector<std::string> Opts;
+
+  PUSH_FLAG(FunctionOptions, CxxReturnUdt, Options, "returns cxx udt");
+  PUSH_FLAG(FunctionOptions, ConstructorWithVirtualBases, Options,
+            "constructor with virtual bases");
+  PUSH_FLAG(FunctionOptions, Constructor, Options, "constructor");
+  if (Opts.empty())
+    return "None";
+  return join(Opts, " | ");
+}
+
+Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
+  // formatLine puts the newline at the beginning, so we use formatLine here
+  // to start a new line, and then individual visit methods use format to
+  // append to the existing line.
+  if (!Hashes) {
+    P.formatLine("{0} | {1} [size = {2}]",
+                 fmt_align(Index, AlignStyle::Right, Width),
+                 formatTypeLeafKind(Record.Type), Record.length());
+  } else {
+    std::string H;
+    if (Index.toArrayIndex() >= HashValues.size()) {
+      H = "(not present)";
+    } else {
+      uint32_t Hash = HashValues[Index.toArrayIndex()];
+      Expected<uint32_t> MaybeHash = hashTypeRecord(Record);
+      if (!MaybeHash)
+        return MaybeHash.takeError();
+      uint32_t OurHash = *MaybeHash;
+      OurHash %= NumHashBuckets;
+      if (Hash == OurHash)
+        H = "0x" + utohexstr(Hash);
+      else
+        H = "0x" + utohexstr(Hash) + ", our hash = 0x" + utohexstr(OurHash);
+    }
+    P.formatLine("{0} | {1} [size = {2}, hash = {3}]",
+                 fmt_align(Index, AlignStyle::Right, Width),
+                 formatTypeLeafKind(Record.Type), Record.length(), H);
+  }
+  P.Indent(Width + 3);
+  return Error::success();
+}
+Error MinimalTypeDumpVisitor::visitTypeEnd(CVType &Record) {
+  P.Unindent(Width + 3);
+  if (RecordBytes) {
+    AutoIndent Indent(P, 9);
+    P.formatBinary("Bytes", Record.RecordData, 0);
+  }
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
+  P.formatLine("- {0}", formatTypeLeafKind(Record.Kind));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
+  if (RecordBytes) {
+    AutoIndent Indent(P, 2);
+    P.formatBinary("Bytes", Record.Data, 0);
+  }
+  return Error::success();
+}
+
+StringRef MinimalTypeDumpVisitor::getTypeName(TypeIndex TI) const {
+  if (TI.isNoneType())
+    return "";
+  return Types.getTypeName(TI);
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               FieldListRecord &FieldList) {
+  if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
+    return EC;
+
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               StringIdRecord &String) {
+  P.format(" ID: {0}, String: {1}", String.getId(), String.getString());
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               ArgListRecord &Args) {
+  auto Indices = Args.getIndices();
+  if (Indices.empty())
+    return Error::success();
+
+  auto Max = std::max_element(Indices.begin(), Indices.end());
+  uint32_t W = NumDigits(Max->getIndex()) + 2;
+
+  for (auto I : Indices)
+    P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
+                 getTypeName(I));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               StringListRecord &Strings) {
+  auto Indices = Strings.getIndices();
+  if (Indices.empty())
+    return Error::success();
+
+  auto Max = std::max_element(Indices.begin(), Indices.end());
+  uint32_t W = NumDigits(Max->getIndex()) + 2;
+
+  for (auto I : Indices)
+    P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
+                 getTypeName(I));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               ClassRecord &Class) {
+  P.format(" `{0}`", Class.Name);
+  if (Class.hasUniqueName())
+    P.formatLine("unique name: `{0}`", Class.UniqueName);
+  P.formatLine("vtable: {0}, base list: {1}, field list: {2}",
+               Class.VTableShape, Class.DerivationList, Class.FieldList);
+  P.formatLine("options: {0}",
+               formatClassOptions(P.getIndentLevel(), Class.Options));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               UnionRecord &Union) {
+  P.format(" `{0}`", Union.Name);
+  if (Union.hasUniqueName())
+    P.formatLine("unique name: `{0}`", Union.UniqueName);
+  P.formatLine("field list: {0}", Union.FieldList);
+  P.formatLine("options: {0}",
+               formatClassOptions(P.getIndentLevel(), Union.Options));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
+  P.format(" `{0}`", Enum.Name);
+  if (Enum.hasUniqueName())
+    P.formatLine("unique name: `{0}`", Enum.UniqueName);
+  P.formatLine("field list: {0}, underlying type: {1}", Enum.FieldList,
+               Enum.UnderlyingType);
+  P.formatLine("options: {0}",
+               formatClassOptions(P.getIndentLevel(), Enum.Options));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
+  if (AT.Name.empty()) {
+    P.formatLine("size: {0}, index type: {1}, element type: {2}", AT.Size,
+                 AT.IndexType, AT.ElementType);
+  } else {
+    P.formatLine("name: {0}, size: {1}, index type: {2}, element type: {3}",
+                 AT.Name, AT.Size, AT.IndexType, AT.ElementType);
+  }
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               VFTableRecord &VFT) {
+  P.formatLine("offset: {0}, complete class: {1}, overridden vftable: {2}",
+               VFT.VFPtrOffset, VFT.CompleteClass, VFT.OverriddenVFTable);
+  P.formatLine("method names: ");
+  if (!VFT.MethodNames.empty()) {
+    std::string Sep =
+        formatv("\n{0}",
+                fmt_repeat(' ', P.getIndentLevel() + strlen("method names: ")))
+            .str();
+    P.print(join(VFT.MethodNames, Sep));
+  }
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               MemberFuncIdRecord &Id) {
+  P.formatLine("name = {0}, type = {1}, class type = {2}", Id.Name,
+               Id.FunctionType, Id.ClassType);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               ProcedureRecord &Proc) {
+  P.formatLine("return type = {0}, # args = {1}, param list = {2}",
+               Proc.ReturnType, Proc.ParameterCount, Proc.ArgumentList);
+  P.formatLine("calling conv = {0}, options = {1}",
+               formatCallingConvention(Proc.CallConv),
+               formatFunctionOptions(Proc.Options));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               MemberFunctionRecord &MF) {
+  P.formatLine("return type = {0}, # args = {1}, param list = {2}",
+               MF.ReturnType, MF.ParameterCount, MF.ArgumentList);
+  P.formatLine("class type = {0}, this type = {1}, this adjust = {2}",
+               MF.ClassType, MF.ThisType, MF.ThisPointerAdjustment);
+  P.formatLine("calling conv = {0}, options = {1}",
+               formatCallingConvention(MF.CallConv),
+               formatFunctionOptions(MF.Options));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               FuncIdRecord &Func) {
+  P.formatLine("name = {0}, type = {1}, parent scope = {2}", Func.Name,
+               Func.FunctionType, Func.ParentScope);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               TypeServer2Record &TS) {
+  P.formatLine("name = {0}, age = {1}, guid = {2}", TS.Name, TS.Age, TS.Guid);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               PointerRecord &Ptr) {
+  P.formatLine("referent = {0}, {1}", Ptr.ReferentType,
+               formatPointerAttrs(Ptr));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               ModifierRecord &Mod) {
+  P.formatLine("referent = {0}, modifiers = {1}", Mod.ModifiedType,
+               modifierOptions(Mod.Modifiers));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               VFTableShapeRecord &Shape) {
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               UdtModSourceLineRecord &U) {
+  P.formatLine("udt = {0}, mod = {1}, file = {2}, line = {3}", U.UDT, U.Module,
+               U.SourceFile.getIndex(), U.LineNumber);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               UdtSourceLineRecord &U) {
+  P.formatLine("udt = {0}, file = {1}, line = {2}", U.UDT,
+               U.SourceFile.getIndex(), U.LineNumber);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               BitFieldRecord &BF) {
+  P.formatLine("type = {0}, bit offset = {1}, # bits = {2}", BF.Type,
+               BF.BitOffset, BF.BitSize);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(
+    CVType &CVR, MethodOverloadListRecord &Overloads) {
+  for (auto &M : Overloads.Methods)
+    P.formatLine("- Method [type = {0}, vftable offset = {1}, attrs = {2}]",
+                 M.Type, M.VFTableOffset, memberAttributes(M.Attrs));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               BuildInfoRecord &BI) {
+  auto Indices = BI.ArgIndices;
+  if (Indices.empty())
+    return Error::success();
+
+  auto Max = std::max_element(Indices.begin(), Indices.end());
+  uint32_t W = NumDigits(Max->getIndex()) + 2;
+
+  for (auto I : Indices)
+    P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
+                 getTypeName(I));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &R) {
+  std::string Type = (R.Mode == LabelType::Far) ? "far" : "near";
+  P.format(" type = {0}", Type);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               PrecompRecord &Precomp) {
+  P.format(" start index = {0:X+}, types count = {1:X+}, signature = {2:X+},"
+           " precomp path = {3}",
+           Precomp.StartTypeIndex, Precomp.TypesCount, Precomp.Signature,
+           Precomp.PrecompFilePath);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
+                                               EndPrecompRecord &EP) {
+  P.format(" signature = {0:X+}", EP.Signature);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               NestedTypeRecord &Nested) {
+  P.format(" [name = `{0}`, parent = {1}]", Nested.Name, Nested.Type);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               OneMethodRecord &Method) {
+  P.format(" [name = `{0}`]", Method.Name);
+  AutoIndent Indent(P);
+  P.formatLine("type = {0}, vftable offset = {1}, attrs = {2}", Method.Type,
+               Method.VFTableOffset, memberAttributes(Method.Attrs));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               OverloadedMethodRecord &Method) {
+  P.format(" [name = `{0}`, # overloads = {1}, overload list = {2}]",
+           Method.Name, Method.NumOverloads, Method.MethodList);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               DataMemberRecord &Field) {
+  P.format(" [name = `{0}`, Type = {1}, offset = {2}, attrs = {3}]", Field.Name,
+           Field.Type, Field.FieldOffset, memberAttributes(Field.Attrs));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               StaticDataMemberRecord &Field) {
+  P.format(" [name = `{0}`, type = {1}, attrs = {2}]", Field.Name, Field.Type,
+           memberAttributes(Field.Attrs));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               EnumeratorRecord &Enum) {
+  P.format(" [{0} = {1}]", Enum.Name,
+           Enum.Value.toString(10, Enum.Value.isSigned()));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               BaseClassRecord &Base) {
+  AutoIndent Indent(P);
+  P.formatLine("type = {0}, offset = {1}, attrs = {2}", Base.Type, Base.Offset,
+               memberAttributes(Base.Attrs));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               VirtualBaseClassRecord &Base) {
+  AutoIndent Indent(P);
+  P.formatLine(
+      "base = {0}, vbptr = {1}, vbptr offset = {2}, vtable index = {3}",
+      Base.BaseType, Base.VBPtrType, Base.VBPtrOffset, Base.VTableIndex);
+  P.formatLine("attrs = {0}", memberAttributes(Base.Attrs));
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               ListContinuationRecord &Cont) {
+  P.format(" continuation = {0}", Cont.ContinuationIndex);
+  return Error::success();
+}
+
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
+                                               VFPtrRecord &VFP) {
+  P.format(" type = {0}", VFP.Type);
+  return Error::success();
+}

llvm/trunk/tools/obj2yaml/coff2yaml.cpp

for (const auto &ObjSection : Obj.sections()) {
     ArrayRef<uint8_t> sectionData;
     if (!ObjSection.isBSS())
       Obj.getSectionContents(COFFSection, sectionData);
     NewYAMLSection.SectionData = yaml::BinaryRef(sectionData);
 
     if (NewYAMLSection.Name == ".debug$S")
       NewYAMLSection.DebugS = CodeViewYAML::fromDebugS(sectionData, SC);
     else if (NewYAMLSection.Name == ".debug$T")
-      NewYAMLSection.DebugT = CodeViewYAML::fromDebugT(sectionData);
+      NewYAMLSection.DebugT = CodeViewYAML::fromDebugT(sectionData,
+                                                       NewYAMLSection.Name);
+    else if (NewYAMLSection.Name == ".debug$P")
+      NewYAMLSection.DebugP = CodeViewYAML::fromDebugT(sectionData,
+                                                       NewYAMLSection.Name);
     else if (NewYAMLSection.Name == ".debug$H")
       NewYAMLSection.DebugH = CodeViewYAML::fromDebugH(sectionData);
 
     std::vector<COFFYAML::Relocation> Relocations;
     for (const auto &Reloc : ObjSection.relocations()) {
       const object::coff_relocation *reloc = Obj.getCOFFRelocation(Reloc);
       COFFYAML::Relocation Rel;
       object::symbol_iterator Sym = Reloc.getSymbol();

llvm/trunk/tools/yaml2obj/yaml2coff.cpp

if (S.Name == ".debug$S") {
         assert(CP.StringsAndChecksums.hasStrings() &&
                "Object file does not have debug string table!");
 
         S.SectionData =
             toDebugS(S.DebugS, CP.StringsAndChecksums, CP.Allocator);
       }
     } else if (S.Name == ".debug$T") {
       if (S.SectionData.binary_size() == 0)
-        S.SectionData = CodeViewYAML::toDebugT(S.DebugT, CP.Allocator);
+        S.SectionData = CodeViewYAML::toDebugT(S.DebugT, CP.Allocator, S.Name);
+    } else if (S.Name == ".debug$P") {
+      if (S.SectionData.binary_size() == 0)
+        S.SectionData = CodeViewYAML::toDebugT(S.DebugP, CP.Allocator, S.Name);
     } else if (S.Name == ".debug$H") {
       if (S.DebugH.hasValue() && S.SectionData.binary_size() == 0)
         S.SectionData = CodeViewYAML::toDebugH(*S.DebugH, CP.Allocator);
     }
 
     if (S.SectionData.binary_size() > 0) {
       CurrentSectionDataOffset = alignTo(CurrentSectionDataOffset,
                                          CP.isPE() ? CP.getFileAlignment() : 4);

llvm/trunk/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp

-//===- llvm/unittest/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp --------===//
-//
-//                     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/TypeIndexDiscovery.h"
-
-#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
-#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
-#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
-#include "llvm/Support/Allocator.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-
-class TypeIndexIteratorTest : public testing::Test {
-public:
-  TypeIndexIteratorTest() {}
-
-  void SetUp() override {
-    Refs.clear();
-    TTB = make_unique<AppendingTypeTableBuilder>(Storage);
-    CRB = make_unique<ContinuationRecordBuilder>();
-    Symbols.clear();
-  }
-
-  void TearDown() override {
-    CRB.reset();
-    TTB.reset();
-  }
-
-protected:
-  template <typename... Indices>
-  bool checkTypeReferences(uint32_t RecordIndex, Indices &&... TIs) const {
-    EXPECT_EQ(sizeof...(Indices), countRefs(RecordIndex));
-
-    // Choose between type or symbol records. The checking code doesn't care
-    // which we have.
-    std::vector<ArrayRef<uint8_t>> CVRecords;
-    if (Symbols.empty()) {
-      CVRecords = TTB->records();
-    } else {
-      for (const CVSymbol &S : Symbols)
-        CVRecords.push_back(S.data());
-    }
-
-    return checkTypeReferencesImpl(RecordIndex, CVRecords,
-                                   std::forward<Indices>(TIs)...);
-  }
-
-  template <typename... T> void writeFieldList(T &&... MemberRecords) {
-    CRB->begin(ContinuationRecordKind::FieldList);
-    writeFieldListImpl(std::forward<T>(MemberRecords)...);
-    auto Records = CRB->end(TTB->nextTypeIndex());
-    ASSERT_EQ(1u, Records.size());
-    TTB->insertRecordBytes(Records.front().RecordData);
-    discoverAllTypeIndices();
-  }
-
-  template <typename... T> void writeTypeRecords(T &&... Records) {
-    writeTypeRecordsImpl(std::forward<T>(Records)...);
-    ASSERT_EQ(sizeof...(T), TTB->records().size());
-    discoverAllTypeIndices();
-  }
-
-  template <typename... T> void writeSymbolRecords(T &&... Records) {
-    writeSymbolRecordsImpl(std::forward<T>(Records)...);
-    ASSERT_EQ(sizeof...(T), Symbols.size());
-    discoverTypeIndicesInSymbols();
-  }
-
-  std::unique_ptr<AppendingTypeTableBuilder> TTB;
-
-private:
-  uint32_t countRefs(uint32_t RecordIndex) const {
-    auto &R = Refs[RecordIndex];
-    uint32_t Count = 0;
-    for (auto &Ref : R) {
-      Count += Ref.Count;
-    }
-    return Count;
-  }
-
-  bool checkOneTypeReference(uint32_t RecordIndex, ArrayRef<uint8_t> RecordData,
-                             TypeIndex TI) const {
-    RecordData = RecordData.drop_front(sizeof(RecordPrefix));
-    auto &RefList = Refs[RecordIndex];
-    for (auto &Ref : RefList) {
-      uint32_t Offset = Ref.Offset;
-      ArrayRef<uint8_t> Loc = RecordData.drop_front(Offset);
-      ArrayRef<TypeIndex> Indices(
-          reinterpret_cast<const TypeIndex *>(Loc.data()), Ref.Count);
-      if (llvm::any_of(Indices,
-                       [TI](const TypeIndex &Other) { return Other == TI; }))
-        return true;
-    }
-    return false;
-  }
-
-  template <typename... Indices>
-  bool checkTypeReferencesImpl(uint32_t RecordIndex,
-                               ArrayRef<ArrayRef<uint8_t>> CVRecords) const {
-    return true;
-  }
-
-  template <typename... Indices>
-  bool checkTypeReferencesImpl(uint32_t RecordIndex,
-                               ArrayRef<ArrayRef<uint8_t>> CVRecords,
-                               TypeIndex TI, Indices &&... Rest) const {
-    ArrayRef<uint8_t> Record = CVRecords[RecordIndex];
-    bool Success = checkOneTypeReference(RecordIndex, Record, TI);
-    EXPECT_TRUE(Success);
-    return Success & checkTypeReferencesImpl(RecordIndex, CVRecords,
-                                             std::forward<Indices>(Rest)...);
-  }
-
-  void discoverAllTypeIndices() {
-    Refs.resize(TTB->records().size());
-    for (uint32_t I = 0; I < TTB->records().size(); ++I) {
-      ArrayRef<uint8_t> Data = TTB->records()[I];
-      discoverTypeIndices(Data, Refs[I]);
-    }
-  }
-
-  void discoverTypeIndicesInSymbols() {
-    Refs.resize(Symbols.size());
-    for (uint32_t I = 0; I < Symbols.size(); ++I)
-      discoverTypeIndicesInSymbol(Symbols[I], Refs[I]);
-  }
-
-  // Helper function to write out a field list record with the given list
-  // of member records.
-  void writeFieldListImpl() {}
-
-  template <typename RecType, typename... Rest>
-  void writeFieldListImpl(RecType &&Record, Rest &&... Records) {
-    CRB->writeMemberType(Record);
-    writeFieldListImpl(std::forward<Rest>(Records)...);
-  }
-
-  // Helper function to write out a list of type records.
-  void writeTypeRecordsImpl() {}
-
-  template <typename RecType, typename... Rest>
-  void writeTypeRecordsImpl(RecType &&Record, Rest &&... Records) {
-    TTB->writeLeafType(Record);
-    writeTypeRecordsImpl(std::forward<Rest>(Records)...);
-  }
-
-  // Helper function to write out a list of symbol records.
-  void writeSymbolRecordsImpl() {}
-
-  template <typename RecType, typename... Rest>
-  void writeSymbolRecordsImpl(RecType &&Record, Rest &&... Records) {
-    Symbols.push_back(SymbolSerializer::writeOneSymbol(Record, Storage,
-                                                       CodeViewContainer::Pdb));
-    writeSymbolRecordsImpl(std::forward<Rest>(Records)...);
-  }
-
-  std::vector<SmallVector<TiReference, 4>> Refs;
-  std::unique_ptr<ContinuationRecordBuilder> CRB;
-  std::vector<CVSymbol> Symbols;
-  BumpPtrAllocator Storage;
-};
-
-namespace leafs {
-static FuncIdRecord FuncId(TypeIndex(1), TypeIndex(2), "FuncId");
-static MemberFuncIdRecord MemFuncId(TypeIndex(3), TypeIndex(4), "FuncId");
-static StringIdRecord StringId(TypeIndex(5), "TheString");
-static struct {
-  std::vector<TypeIndex> Ids = {TypeIndex(6), TypeIndex(7), TypeIndex(8)};
-  StringListRecord Record{TypeRecordKind::StringList, Ids};
-} StringList;
-static struct {
-  std::vector<TypeIndex> Ids = {TypeIndex(9), TypeIndex(10), TypeIndex(11)};
-  BuildInfoRecord Record{Ids};
-} BuildInfo;
-static UdtSourceLineRecord UdtSourceLine(TypeIndex(12), TypeIndex(13), 0);
-static UdtModSourceLineRecord UdtModSourceLine(TypeIndex(14), TypeIndex(15), 0,
-                                               0);
-static ModifierRecord Modifier(TypeIndex(16), ModifierOptions::None);
-static ProcedureRecord Procedure(TypeIndex(17), CallingConvention::PpcCall,
-                                 FunctionOptions::None, 0, TypeIndex(18));
-static MemberFunctionRecord MemberFunction(TypeIndex(19), TypeIndex(20),
-                                           TypeIndex(21),
-                                           CallingConvention::ThisCall,
-                                           FunctionOptions::None, 2,
-                                           TypeIndex(22), 0);
-static struct {
-  std::vector<TypeIndex> Ids = {TypeIndex(23), TypeIndex(24), TypeIndex(25)};
-  ArgListRecord Record{TypeRecordKind::ArgList, Ids};
-} ArgList;
-static ArrayRecord Array(TypeIndex(26), TypeIndex(27), 10, "MyArray");
-static ClassRecord Class(TypeRecordKind::Class, 3, ClassOptions::None,
-                         TypeIndex(28), TypeIndex(29), TypeIndex(30), 10,
-                         "MyClass", "MyClassUniqueName");
-static ClassRecord Struct(TypeRecordKind::Struct, 3, ClassOptions::None,
-                          TypeIndex(31), TypeIndex(32), TypeIndex(33), 10,
-                          "MyClass", "MyClassUniqueName");
-static UnionRecord Union(1, ClassOptions::None, TypeIndex(34), 10, "MyUnion",
-                         "MyUnionUniqueName");
-static EnumRecord Enum(1, ClassOptions::None, TypeIndex(35), "MyEnum",
-                       "EnumUniqueName", TypeIndex(36));
-static BitFieldRecord BitField(TypeIndex(37), 1, 0);
-static VFTableRecord VFTable(TypeIndex(38), TypeIndex(39), 1, "VFT", {});
-static VFTableShapeRecord VTableShape({});
-static struct {
-  const TypeIndex T1{40};
-  const TypeIndex T2{41};
-  const TypeIndex T3{42};
-  const TypeIndex T4{43};
-
-  std::vector<OneMethodRecord> Methods{
-      {T1, MemberAccess::Public, MethodKind::IntroducingVirtual,
-       MethodOptions::None, 0, "Method1"},
-      {T2, MemberAccess::Public, MethodKind::PureVirtual, MethodOptions::None,
-       0, "Method1"},
-      {T3, MemberAccess::Public, MethodKind::PureIntroducingVirtual,
-       MethodOptions::None, 0, "Method1"},
-      {T4, MemberAccess::Public, MethodKind::Static, MethodOptions::None, 0,
-       "Method1"}};
-
-  MethodOverloadListRecord Record{Methods};
-} MethodOverloadList;
-static PointerRecord Pointer(TypeIndex(44), PointerKind::Near32,
-                             PointerMode::Pointer, PointerOptions::Const, 3);
-static PointerRecord MemberPointer(
-    TypeIndex(45), PointerKind::Near32, PointerMode::PointerToDataMember,
-    PointerOptions::Const, 3,
-    MemberPointerInfo(TypeIndex(46),
-                      PointerToMemberRepresentation::GeneralData));
-}
-
-namespace members {
-static BaseClassRecord BaseClass(MemberAccess::Public, TypeIndex(47), 0);
-static EnumeratorRecord Enumerator(MemberAccess::Public,
-                                   APSInt(APInt(8, 3, false)), "Test");
-DataMemberRecord DataMember(MemberAccess::Public, TypeIndex(48), 0, "Test");
-OverloadedMethodRecord OverloadedMethod(3, TypeIndex(49), "MethodList");
-static struct {
-  const TypeIndex T1{50};
-  const TypeIndex T2{51};
-  const TypeIndex T3{52};
-  const TypeIndex T4{53};
-  OneMethodRecord R1{T1,
-                     MemberAccess::Public,
-                     MethodKind::IntroducingVirtual,
-                     MethodOptions::None,
-                     0,
-                     "M1"};
-  OneMethodRecord R2{T2,
-                     MemberAccess::Public,
-                     MethodKind::PureVirtual,
-                     MethodOptions::None,
-                     0,
-                     "M2"};
-  OneMethodRecord R3{T3,
-                     MemberAccess::Public,
-                     MethodKind::PureIntroducingVirtual,
-                     MethodOptions::None,
-                     0,
-                     "M3"};
-  OneMethodRecord R4{T4,
-                     MemberAccess::Protected,
-                     MethodKind::Vanilla,
-                     MethodOptions::CompilerGenerated,
-                     0,
-                     "M4"};
-} OneMethod;
-static NestedTypeRecord NestedType(TypeIndex(54), "MyClass");
-static StaticDataMemberRecord StaticDataMember(MemberAccess::Public,
-                                               TypeIndex(55), "Foo");
-static VirtualBaseClassRecord VirtualBaseClass(TypeRecordKind::VirtualBaseClass,
-                                               MemberAccess::Public,
-                                               TypeIndex(56), TypeIndex(57), 0,
-                                               0);
-static VFPtrRecord VFPtr(TypeIndex(58));
-static ListContinuationRecord Continuation(TypeIndex(59));
-}
-
-TEST_F(TypeIndexIteratorTest, FuncId) {
-  using namespace leafs;
-  writeTypeRecords(FuncId);
-  checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);
-}
-
-TEST_F(TypeIndexIteratorTest, MemFuncId) {
-  using namespace leafs;
-  writeTypeRecords(MemFuncId);
-  checkTypeReferences(0, MemFuncId.ClassType, MemFuncId.FunctionType);
-}
-
-TEST_F(TypeIndexIteratorTest, StringId) {
-  using namespace leafs;
-  writeTypeRecords(StringId);
-  checkTypeReferences(0, StringId.Id);
-}
-
-TEST_F(TypeIndexIteratorTest, SubstrList) {
-  using namespace leafs;
-  writeTypeRecords(StringList.Record);
-  checkTypeReferences(0, StringList.Ids[0], StringList.Ids[1],
-                      StringList.Ids[2]);
-}
-
-TEST_F(TypeIndexIteratorTest, BuildInfo) {
-  using namespace leafs;
-  writeTypeRecords(BuildInfo.Record);
-  checkTypeReferences(0, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);
-}
-
-TEST_F(TypeIndexIteratorTest, UdtSrcLine) {
-  using namespace leafs;
-  writeTypeRecords(UdtSourceLine);
-  checkTypeReferences(0, UdtSourceLine.UDT, UdtSourceLine.SourceFile);
-}
-
-TEST_F(TypeIndexIteratorTest, UdtModSrcLine) {
-  using namespace leafs;
-  writeTypeRecords(UdtModSourceLine);
-  checkTypeReferences(0, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);
-}
-
-TEST_F(TypeIndexIteratorTest, Modifier) {
-  using namespace leafs;
-  writeTypeRecords(Modifier);
-  checkTypeReferences(0, Modifier.ModifiedType);
-}
-
-TEST_F(TypeIndexIteratorTest, Procedure) {
-  using namespace leafs;
-  writeTypeRecords(Procedure);
-  checkTypeReferences(0, Procedure.ReturnType, Procedure.ArgumentList);
-}
-
-TEST_F(TypeIndexIteratorTest, MemFunc) {
-  using namespace leafs;
-  writeTypeRecords(MemberFunction);
-  checkTypeReferences(0, MemberFunction.ReturnType, MemberFunction.ClassType,
-                      MemberFunction.ThisType, MemberFunction.ArgumentList);
-}
-
-TEST_F(TypeIndexIteratorTest, ArgList) {
-  using namespace leafs;
-  writeTypeRecords(ArgList.Record);
-  checkTypeReferences(0, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);
-}
-
-TEST_F(TypeIndexIteratorTest, Array) {
-  using namespace leafs;
-  writeTypeRecords(Array);
-  checkTypeReferences(0, Array.ElementType, Array.IndexType);
-}
-
-TEST_F(TypeIndexIteratorTest, Class) {
-  using namespace leafs;
-  writeTypeRecords(Class);
-  checkTypeReferences(0, Class.FieldList, Class.DerivationList,
-                      Class.VTableShape);
-}
-
-TEST_F(TypeIndexIteratorTest, Struct) {
-  using namespace leafs;
-  writeTypeRecords(Struct);
-  checkTypeReferences(0, Struct.FieldList, Struct.DerivationList,
-                      Struct.VTableShape);
-}
-
-TEST_F(TypeIndexIteratorTest, Union) {
-  using namespace leafs;
-  writeTypeRecords(Union);
-  checkTypeReferences(0, Union.FieldList);
-}
-
-TEST_F(TypeIndexIteratorTest, Enum) {
-  using namespace leafs;
-  writeTypeRecords(Enum);
-  checkTypeReferences(0, Enum.FieldList, Enum.UnderlyingType);
-}
-
-TEST_F(TypeIndexIteratorTest, Bitfield) {
-  using namespace leafs;
-  writeTypeRecords(BitField);
-  checkTypeReferences(0, BitField.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, VTable) {
-  using namespace leafs;
-  writeTypeRecords(VFTable);
-  checkTypeReferences(0, VFTable.CompleteClass, VFTable.OverriddenVFTable);
-}
-
-TEST_F(TypeIndexIteratorTest, VTShape) {
-  using namespace leafs;
-  writeTypeRecords(VTableShape);
-  checkTypeReferences(0);
-}
-
-TEST_F(TypeIndexIteratorTest, OverloadList) {
-  using namespace leafs;
-  writeTypeRecords(MethodOverloadList.Record);
-  checkTypeReferences(0, MethodOverloadList.T1, MethodOverloadList.T2,
-                      MethodOverloadList.T3, MethodOverloadList.T4);
-}
-
-TEST_F(TypeIndexIteratorTest, Pointer) {
-  using namespace leafs;
-  writeTypeRecords(Pointer);
-  checkTypeReferences(0, Pointer.ReferentType);
-}
-
-TEST_F(TypeIndexIteratorTest, MemberPointer) {
-  using namespace leafs;
-  writeTypeRecords(MemberPointer);
-  checkTypeReferences(0, MemberPointer.ReferentType,
-                      MemberPointer.MemberInfo->ContainingType);
-}
-
-TEST_F(TypeIndexIteratorTest, ManyTypes) {
-
-  using namespace leafs;
-  writeTypeRecords(FuncId, MemFuncId, StringId, StringList.Record,
-                   BuildInfo.Record, UdtSourceLine, UdtModSourceLine, Modifier,
-                   Procedure, MemberFunction, ArgList.Record, Array, Class,
-                   Union, Enum, BitField, VFTable, VTableShape,
-                   MethodOverloadList.Record, Pointer, MemberPointer);
-
-  checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);
-  checkTypeReferences(1, MemFuncId.ClassType, MemFuncId.FunctionType);
-  checkTypeReferences(2, StringId.Id);
-  checkTypeReferences(3, StringList.Ids[0], StringList.Ids[1],
-                      StringList.Ids[2]);
-  checkTypeReferences(4, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);
-  checkTypeReferences(5, UdtSourceLine.UDT, UdtSourceLine.SourceFile);
-  checkTypeReferences(6, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);
-  checkTypeReferences(7, Modifier.ModifiedType);
-  checkTypeReferences(8, Procedure.ReturnType, Procedure.ArgumentList);
-  checkTypeReferences(9, MemberFunction.ReturnType, MemberFunction.ClassType,
-                      MemberFunction.ThisType, MemberFunction.ArgumentList);
-  checkTypeReferences(10, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);
-  checkTypeReferences(11, Array.ElementType, Array.IndexType);
-  checkTypeReferences(12, Class.FieldList, Class.DerivationList,
-                      Class.VTableShape);
-  checkTypeReferences(13, Union.FieldList);
-  checkTypeReferences(14, Enum.FieldList, Enum.UnderlyingType);
-  checkTypeReferences(15, BitField.Type);
-  checkTypeReferences(16, VFTable.CompleteClass, VFTable.OverriddenVFTable);
-  checkTypeReferences(17);
-  checkTypeReferences(18, MethodOverloadList.T1, MethodOverloadList.T2,
-                      MethodOverloadList.T3, MethodOverloadList.T4);
-  checkTypeReferences(19, Pointer.ReferentType);
-  checkTypeReferences(20, MemberPointer.ReferentType,
-                      MemberPointer.MemberInfo->ContainingType);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListBaseClass) {
-  using namespace members;
-  writeFieldList(BaseClass);
-  checkTypeReferences(0, BaseClass.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListEnumerator) {
-  using namespace members;
-  writeFieldList(Enumerator);
-  checkTypeReferences(0);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListMember) {
-  using namespace members;
-  writeFieldList(DataMember);
-  checkTypeReferences(0, DataMember.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListMethod) {
-  using namespace members;
-  writeFieldList(OverloadedMethod);
-  checkTypeReferences(0, OverloadedMethod.MethodList);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListOneMethod) {
-  using namespace members;
-  writeFieldList(OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4);
-  checkTypeReferences(0, OneMethod.T1, OneMethod.T2, OneMethod.T3,
-                      OneMethod.T4);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListNestedType) {
-  using namespace members;
-  writeFieldList(NestedType);
-  checkTypeReferences(0, NestedType.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListStaticMember) {
-  using namespace members;
-  writeFieldList(StaticDataMember);
-  checkTypeReferences(0, StaticDataMember.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListVirtualBase) {
-  using namespace members;
-  writeFieldList(VirtualBaseClass);
-  checkTypeReferences(0, VirtualBaseClass.BaseType, VirtualBaseClass.VBPtrType);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListVFTable) {
-  using namespace members;
-  writeFieldList(VFPtr);
-  checkTypeReferences(0, VFPtr.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListContinuation) {
-  using namespace members;
-  writeFieldList(Continuation);
-  checkTypeReferences(0, Continuation.ContinuationIndex);
-}
-
-TEST_F(TypeIndexIteratorTest, ManyMembers) {
-  using namespace members;
-  writeFieldList(BaseClass, Enumerator, DataMember, OverloadedMethod,
-                 OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4,
-                 NestedType, StaticDataMember, VirtualBaseClass, VFPtr,
-                 Continuation);
-
-  checkTypeReferences(
-      0, BaseClass.Type, DataMember.Type, OverloadedMethod.MethodList,
-      OneMethod.T1, OneMethod.T2, OneMethod.T3, OneMethod.T4, NestedType.Type,
-      StaticDataMember.Type, VirtualBaseClass.BaseType,
-      VirtualBaseClass.VBPtrType, VFPtr.Type, Continuation.ContinuationIndex);
-}
-
-TEST_F(TypeIndexIteratorTest, ProcSym) {
-  ProcSym GS(SymbolRecordKind::GlobalProcSym);
-  GS.FunctionType = TypeIndex::Float32();
-  ProcSym LS(SymbolRecordKind::ProcSym);
-  LS.FunctionType = TypeIndex::Float64();
-  writeSymbolRecords(GS, LS);
-  checkTypeReferences(0, GS.FunctionType);
-  checkTypeReferences(1, LS.FunctionType);
-}
-
-TEST_F(TypeIndexIteratorTest, DataSym) {
-  DataSym DS(SymbolRecordKind::GlobalData);
-  DS.Type = TypeIndex::Float32();
-  writeSymbolRecords(DS);
-  checkTypeReferences(0, DS.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, RegisterSym) {
-  RegisterSym Reg(SymbolRecordKind::RegisterSym);
-  Reg.Index = TypeIndex::UInt32();
-  Reg.Register = RegisterId::EAX;
-  Reg.Name = "Target";
-  writeSymbolRecords(Reg);
-  checkTypeReferences(0, Reg.Index);
-}
-
-TEST_F(TypeIndexIteratorTest, CallerSym) {
-  CallerSym Callees(SymbolRecordKind::CalleeSym);
-  Callees.Indices.push_back(TypeIndex(1));
-  Callees.Indices.push_back(TypeIndex(2));
-  Callees.Indices.push_back(TypeIndex(3));
-  CallerSym Callers(SymbolRecordKind::CallerSym);
-  Callers.Indices.push_back(TypeIndex(4));
-  Callers.Indices.push_back(TypeIndex(5));
-  Callers.Indices.push_back(TypeIndex(6));
-  CallerSym Inlinees(SymbolRecordKind::InlineesSym);
-  Inlinees.Indices.push_back(TypeIndex(7));
-  Inlinees.Indices.push_back(TypeIndex(8));
-  Inlinees.Indices.push_back(TypeIndex(9));
-  writeSymbolRecords(Callees, Callers, Inlinees);
-  checkTypeReferences(0, TypeIndex(1), TypeIndex(2), TypeIndex(3));
-  checkTypeReferences(1, TypeIndex(4), TypeIndex(5), TypeIndex(6));
-  checkTypeReferences(2, TypeIndex(7), TypeIndex(8), TypeIndex(9));
-}
-
+//===- llvm/unittest/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp --------===//
+//
+//                     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/TypeIndexDiscovery.h"
+
+#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
+#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
+#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
+#include "llvm/Support/Allocator.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+class TypeIndexIteratorTest : public testing::Test {
+public:
+  TypeIndexIteratorTest() {}
+
+  void SetUp() override {
+    Refs.clear();
+    TTB = make_unique<AppendingTypeTableBuilder>(Storage);
+    CRB = make_unique<ContinuationRecordBuilder>();
+    Symbols.clear();
+  }
+
+  void TearDown() override {
+    CRB.reset();
+    TTB.reset();
+  }
+
+protected:
+  template <typename... Indices>
+  bool checkTypeReferences(uint32_t RecordIndex, Indices &&... TIs) const {
+    EXPECT_EQ(sizeof...(Indices), countRefs(RecordIndex));
+
+    // Choose between type or symbol records. The checking code doesn't care
+    // which we have.
+    std::vector<ArrayRef<uint8_t>> CVRecords;
+    if (Symbols.empty()) {
+      CVRecords = TTB->records();
+    } else {
+      for (const CVSymbol &S : Symbols)
+        CVRecords.push_back(S.data());
+    }
+
+    return checkTypeReferencesImpl(RecordIndex, CVRecords,
+                                   std::forward<Indices>(TIs)...);
+  }
+
+  template <typename... T> void writeFieldList(T &&... MemberRecords) {
+    CRB->begin(ContinuationRecordKind::FieldList);
+    writeFieldListImpl(std::forward<T>(MemberRecords)...);
+    auto Records = CRB->end(TTB->nextTypeIndex());
+    ASSERT_EQ(1u, Records.size());
+    TTB->insertRecordBytes(Records.front().RecordData);
+    discoverAllTypeIndices();
+  }
+
+  template <typename... T> void writeTypeRecords(T &&... Records) {
+    writeTypeRecordsImpl(std::forward<T>(Records)...);
+    ASSERT_EQ(sizeof...(T), TTB->records().size());
+    discoverAllTypeIndices();
+  }
+
+  template <typename... T> void writeSymbolRecords(T &&... Records) {
+    writeSymbolRecordsImpl(std::forward<T>(Records)...);
+    ASSERT_EQ(sizeof...(T), Symbols.size());
+    discoverTypeIndicesInSymbols();
+  }
+
+  std::unique_ptr<AppendingTypeTableBuilder> TTB;
+
+private:
+  uint32_t countRefs(uint32_t RecordIndex) const {
+    auto &R = Refs[RecordIndex];
+    uint32_t Count = 0;
+    for (auto &Ref : R) {
+      Count += Ref.Count;
+    }
+    return Count;
+  }
+
+  bool checkOneTypeReference(uint32_t RecordIndex, ArrayRef<uint8_t> RecordData,
+                             TypeIndex TI) const {
+    RecordData = RecordData.drop_front(sizeof(RecordPrefix));
+    auto &RefList = Refs[RecordIndex];
+    for (auto &Ref : RefList) {
+      uint32_t Offset = Ref.Offset;
+      ArrayRef<uint8_t> Loc = RecordData.drop_front(Offset);
+      ArrayRef<TypeIndex> Indices(
+          reinterpret_cast<const TypeIndex *>(Loc.data()), Ref.Count);
+      if (llvm::any_of(Indices,
+                       [TI](const TypeIndex &Other) { return Other == TI; }))
+        return true;
+    }
+    return false;
+  }
+
+  template <typename... Indices>
+  bool checkTypeReferencesImpl(uint32_t RecordIndex,
+                               ArrayRef<ArrayRef<uint8_t>> CVRecords) const {
+    return true;
+  }
+
+  template <typename... Indices>
+  bool checkTypeReferencesImpl(uint32_t RecordIndex,
+                               ArrayRef<ArrayRef<uint8_t>> CVRecords,
+                               TypeIndex TI, Indices &&... Rest) const {
+    ArrayRef<uint8_t> Record = CVRecords[RecordIndex];
+    bool Success = checkOneTypeReference(RecordIndex, Record, TI);
+    EXPECT_TRUE(Success);
+    return Success & checkTypeReferencesImpl(RecordIndex, CVRecords,
+                                             std::forward<Indices>(Rest)...);
+  }
+
+  void discoverAllTypeIndices() {
+    Refs.resize(TTB->records().size());
+    for (uint32_t I = 0; I < TTB->records().size(); ++I) {
+      ArrayRef<uint8_t> Data = TTB->records()[I];
+      discoverTypeIndices(Data, Refs[I]);
+    }
+  }
+
+  void discoverTypeIndicesInSymbols() {
+    Refs.resize(Symbols.size());
+    for (uint32_t I = 0; I < Symbols.size(); ++I)
+      discoverTypeIndicesInSymbol(Symbols[I], Refs[I]);
+  }
+
+  // Helper function to write out a field list record with the given list
+  // of member records.
+  void writeFieldListImpl() {}
+
+  template <typename RecType, typename... Rest>
+  void writeFieldListImpl(RecType &&Record, Rest &&... Records) {
+    CRB->writeMemberType(Record);
+    writeFieldListImpl(std::forward<Rest>(Records)...);
+  }
+
+  // Helper function to write out a list of type records.
+  void writeTypeRecordsImpl() {}
+
+  template <typename RecType, typename... Rest>
+  void writeTypeRecordsImpl(RecType &&Record, Rest &&... Records) {
+    TTB->writeLeafType(Record);
+    writeTypeRecordsImpl(std::forward<Rest>(Records)...);
+  }
+
+  // Helper function to write out a list of symbol records.
+  void writeSymbolRecordsImpl() {}
+
+  template <typename RecType, typename... Rest>
+  void writeSymbolRecordsImpl(RecType &&Record, Rest &&... Records) {
+    Symbols.push_back(SymbolSerializer::writeOneSymbol(Record, Storage,
+                                                       CodeViewContainer::Pdb));
+    writeSymbolRecordsImpl(std::forward<Rest>(Records)...);
+  }
+
+  std::vector<SmallVector<TiReference, 4>> Refs;
+  std::unique_ptr<ContinuationRecordBuilder> CRB;
+  std::vector<CVSymbol> Symbols;
+  BumpPtrAllocator Storage;
+};
+
+namespace leafs {
+static FuncIdRecord FuncId(TypeIndex(1), TypeIndex(2), "FuncId");
+static MemberFuncIdRecord MemFuncId(TypeIndex(3), TypeIndex(4), "FuncId");
+static StringIdRecord StringId(TypeIndex(5), "TheString");
+static struct {
+  std::vector<TypeIndex> Ids = {TypeIndex(6), TypeIndex(7), TypeIndex(8)};
+  StringListRecord Record{TypeRecordKind::StringList, Ids};
+} StringList;
+static struct {
+  std::vector<TypeIndex> Ids = {TypeIndex(9), TypeIndex(10), TypeIndex(11)};
+  BuildInfoRecord Record{Ids};
+} BuildInfo;
+static UdtSourceLineRecord UdtSourceLine(TypeIndex(12), TypeIndex(13), 0);
+static UdtModSourceLineRecord UdtModSourceLine(TypeIndex(14), TypeIndex(15), 0,
+                                               0);
+static ModifierRecord Modifier(TypeIndex(16), ModifierOptions::None);
+static ProcedureRecord Procedure(TypeIndex(17), CallingConvention::PpcCall,
+                                 FunctionOptions::None, 0, TypeIndex(18));
+static MemberFunctionRecord MemberFunction(TypeIndex(19), TypeIndex(20),
+                                           TypeIndex(21),
+                                           CallingConvention::ThisCall,
+                                           FunctionOptions::None, 2,
+                                           TypeIndex(22), 0);
+static struct {
+  std::vector<TypeIndex> Ids = {TypeIndex(23), TypeIndex(24), TypeIndex(25)};
+  ArgListRecord Record{TypeRecordKind::ArgList, Ids};
+} ArgList;
+static ArrayRecord Array(TypeIndex(26), TypeIndex(27), 10, "MyArray");
+static ClassRecord Class(TypeRecordKind::Class, 3, ClassOptions::None,
+                         TypeIndex(28), TypeIndex(29), TypeIndex(30), 10,
+                         "MyClass", "MyClassUniqueName");
+static ClassRecord Struct(TypeRecordKind::Struct, 3, ClassOptions::None,
+                          TypeIndex(31), TypeIndex(32), TypeIndex(33), 10,
+                          "MyClass", "MyClassUniqueName");
+static UnionRecord Union(1, ClassOptions::None, TypeIndex(34), 10, "MyUnion",
+                         "MyUnionUniqueName");
+static EnumRecord Enum(1, ClassOptions::None, TypeIndex(35), "MyEnum",
+                       "EnumUniqueName", TypeIndex(36));
+static BitFieldRecord BitField(TypeIndex(37), 1, 0);
+static VFTableRecord VFTable(TypeIndex(38), TypeIndex(39), 1, "VFT", {});
+static VFTableShapeRecord VTableShape({});
+static struct {
+  const TypeIndex T1{40};
+  const TypeIndex T2{41};
+  const TypeIndex T3{42};
+  const TypeIndex T4{43};
+
+  std::vector<OneMethodRecord> Methods{
+      {T1, MemberAccess::Public, MethodKind::IntroducingVirtual,
+       MethodOptions::None, 0, "Method1"},
+      {T2, MemberAccess::Public, MethodKind::PureVirtual, MethodOptions::None,
+       0, "Method1"},
+      {T3, MemberAccess::Public, MethodKind::PureIntroducingVirtual,
+       MethodOptions::None, 0, "Method1"},
+      {T4, MemberAccess::Public, MethodKind::Static, MethodOptions::None, 0,
+       "Method1"}};
+
+  MethodOverloadListRecord Record{Methods};
+} MethodOverloadList;
+static PointerRecord Pointer(TypeIndex(44), PointerKind::Near32,
+                             PointerMode::Pointer, PointerOptions::Const, 3);
+static PointerRecord MemberPointer(
+    TypeIndex(45), PointerKind::Near32, PointerMode::PointerToDataMember,
+    PointerOptions::Const, 3,
+    MemberPointerInfo(TypeIndex(46),
+                      PointerToMemberRepresentation::GeneralData));
+}
+
+namespace members {
+static BaseClassRecord BaseClass(MemberAccess::Public, TypeIndex(47), 0);
+static EnumeratorRecord Enumerator(MemberAccess::Public,
+                                   APSInt(APInt(8, 3, false)), "Test");
+DataMemberRecord DataMember(MemberAccess::Public, TypeIndex(48), 0, "Test");
+OverloadedMethodRecord OverloadedMethod(3, TypeIndex(49), "MethodList");
+static struct {
+  const TypeIndex T1{50};
+  const TypeIndex T2{51};
+  const TypeIndex T3{52};
+  const TypeIndex T4{53};
+  OneMethodRecord R1{T1,
+                     MemberAccess::Public,
+                     MethodKind::IntroducingVirtual,
+                     MethodOptions::None,
+                     0,
+                     "M1"};
+  OneMethodRecord R2{T2,
+                     MemberAccess::Public,
+                     MethodKind::PureVirtual,
+                     MethodOptions::None,
+                     0,
+                     "M2"};
+  OneMethodRecord R3{T3,
+                     MemberAccess::Public,
+                     MethodKind::PureIntroducingVirtual,
+                     MethodOptions::None,
+                     0,
+                     "M3"};
+  OneMethodRecord R4{T4,
+                     MemberAccess::Protected,
+                     MethodKind::Vanilla,
+                     MethodOptions::CompilerGenerated,
+                     0,
+                     "M4"};
+} OneMethod;
+static NestedTypeRecord NestedType(TypeIndex(54), "MyClass");
+static StaticDataMemberRecord StaticDataMember(MemberAccess::Public,
+                                               TypeIndex(55), "Foo");
+static VirtualBaseClassRecord VirtualBaseClass(TypeRecordKind::VirtualBaseClass,
+                                               MemberAccess::Public,
+                                               TypeIndex(56), TypeIndex(57), 0,
+                                               0);
+static VFPtrRecord VFPtr(TypeIndex(58));
+static ListContinuationRecord Continuation(TypeIndex(59));
+}
+
+TEST_F(TypeIndexIteratorTest, FuncId) {
+  using namespace leafs;
+  writeTypeRecords(FuncId);
+  checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);
+}
+
+TEST_F(TypeIndexIteratorTest, MemFuncId) {
+  using namespace leafs;
+  writeTypeRecords(MemFuncId);
+  checkTypeReferences(0, MemFuncId.ClassType, MemFuncId.FunctionType);
+}
+
+TEST_F(TypeIndexIteratorTest, StringId) {
+  using namespace leafs;
+  writeTypeRecords(StringId);
+  checkTypeReferences(0, StringId.Id);
+}
+
+TEST_F(TypeIndexIteratorTest, SubstrList) {
+  using namespace leafs;
+  writeTypeRecords(StringList.Record);
+  checkTypeReferences(0, StringList.Ids[0], StringList.Ids[1],
+                      StringList.Ids[2]);
+}
+
+TEST_F(TypeIndexIteratorTest, BuildInfo) {
+  using namespace leafs;
+  writeTypeRecords(BuildInfo.Record);
+  checkTypeReferences(0, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);
+}
+
+TEST_F(TypeIndexIteratorTest, UdtSrcLine) {
+  using namespace leafs;
+  writeTypeRecords(UdtSourceLine);
+  checkTypeReferences(0, UdtSourceLine.UDT, UdtSourceLine.SourceFile);
+}
+
+TEST_F(TypeIndexIteratorTest, UdtModSrcLine) {
+  using namespace leafs;
+  writeTypeRecords(UdtModSourceLine);
+  checkTypeReferences(0, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);
+}
+
+TEST_F(TypeIndexIteratorTest, Modifier) {
+  using namespace leafs;
+  writeTypeRecords(Modifier);
+  checkTypeReferences(0, Modifier.ModifiedType);
+}
+
+TEST_F(TypeIndexIteratorTest, Procedure) {
+  using namespace leafs;
+  writeTypeRecords(Procedure);
+  checkTypeReferences(0, Procedure.ReturnType, Procedure.ArgumentList);
+}
+
+TEST_F(TypeIndexIteratorTest, MemFunc) {
+  using namespace leafs;
+  writeTypeRecords(MemberFunction);
+  checkTypeReferences(0, MemberFunction.ReturnType, MemberFunction.ClassType,
+                      MemberFunction.ThisType, MemberFunction.ArgumentList);
+}
+
+TEST_F(TypeIndexIteratorTest, ArgList) {
+  using namespace leafs;
+  writeTypeRecords(ArgList.Record);
+  checkTypeReferences(0, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);
+}
+
+TEST_F(TypeIndexIteratorTest, Array) {
+  using namespace leafs;
+  writeTypeRecords(Array);
+  checkTypeReferences(0, Array.ElementType, Array.IndexType);
+}
+
+TEST_F(TypeIndexIteratorTest, Class) {
+  using namespace leafs;
+  writeTypeRecords(Class);
+  checkTypeReferences(0, Class.FieldList, Class.DerivationList,
+                      Class.VTableShape);
+}
+
+TEST_F(TypeIndexIteratorTest, Struct) {
+  using namespace leafs;
+  writeTypeRecords(Struct);
+  checkTypeReferences(0, Struct.FieldList, Struct.DerivationList,
+                      Struct.VTableShape);
+}
+
+TEST_F(TypeIndexIteratorTest, Union) {
+  using namespace leafs;
+  writeTypeRecords(Union);
+  checkTypeReferences(0, Union.FieldList);
+}
+
+TEST_F(TypeIndexIteratorTest, Enum) {
+  using namespace leafs;
+  writeTypeRecords(Enum);
+  checkTypeReferences(0, Enum.FieldList, Enum.UnderlyingType);
+}
+
+TEST_F(TypeIndexIteratorTest, Bitfield) {
+  using namespace leafs;
+  writeTypeRecords(BitField);
+  checkTypeReferences(0, BitField.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, VTable) {
+  using namespace leafs;
+  writeTypeRecords(VFTable);
+  checkTypeReferences(0, VFTable.CompleteClass, VFTable.OverriddenVFTable);
+}
+
+TEST_F(TypeIndexIteratorTest, VTShape) {
+  using namespace leafs;
+  writeTypeRecords(VTableShape);
+  checkTypeReferences(0);
+}
+
+TEST_F(TypeIndexIteratorTest, OverloadList) {
+  using namespace leafs;
+  writeTypeRecords(MethodOverloadList.Record);
+  checkTypeReferences(0, MethodOverloadList.T1, MethodOverloadList.T2,
+                      MethodOverloadList.T3, MethodOverloadList.T4);
+}
+
+TEST_F(TypeIndexIteratorTest, Pointer) {
+  using namespace leafs;
+  writeTypeRecords(Pointer);
+  checkTypeReferences(0, Pointer.ReferentType);
+}
+
+TEST_F(TypeIndexIteratorTest, MemberPointer) {
+  using namespace leafs;
+  writeTypeRecords(MemberPointer);
+  checkTypeReferences(0, MemberPointer.ReferentType,
+                      MemberPointer.MemberInfo->ContainingType);
+}
+
+TEST_F(TypeIndexIteratorTest, ManyTypes) {
+
+  using namespace leafs;
+  writeTypeRecords(FuncId, MemFuncId, StringId, StringList.Record,
+                   BuildInfo.Record, UdtSourceLine, UdtModSourceLine, Modifier,
+                   Procedure, MemberFunction, ArgList.Record, Array, Class,
+                   Union, Enum, BitField, VFTable, VTableShape,
+                   MethodOverloadList.Record, Pointer, MemberPointer);
+
+  checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);
+  checkTypeReferences(1, MemFuncId.ClassType, MemFuncId.FunctionType);
+  checkTypeReferences(2, StringId.Id);
+  checkTypeReferences(3, StringList.Ids[0], StringList.Ids[1],
+                      StringList.Ids[2]);
+  checkTypeReferences(4, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);
+  checkTypeReferences(5, UdtSourceLine.UDT, UdtSourceLine.SourceFile);
+  checkTypeReferences(6, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);
+  checkTypeReferences(7, Modifier.ModifiedType);
+  checkTypeReferences(8, Procedure.ReturnType, Procedure.ArgumentList);
+  checkTypeReferences(9, MemberFunction.ReturnType, MemberFunction.ClassType,
+                      MemberFunction.ThisType, MemberFunction.ArgumentList);
+  checkTypeReferences(10, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);
+  checkTypeReferences(11, Array.ElementType, Array.IndexType);
+  checkTypeReferences(12, Class.FieldList, Class.DerivationList,
+                      Class.VTableShape);
+  checkTypeReferences(13, Union.FieldList);
+  checkTypeReferences(14, Enum.FieldList, Enum.UnderlyingType);
+  checkTypeReferences(15, BitField.Type);
+  checkTypeReferences(16, VFTable.CompleteClass, VFTable.OverriddenVFTable);
+  checkTypeReferences(17);
+  checkTypeReferences(18, MethodOverloadList.T1, MethodOverloadList.T2,
+                      MethodOverloadList.T3, MethodOverloadList.T4);
+  checkTypeReferences(19, Pointer.ReferentType);
+  checkTypeReferences(20, MemberPointer.ReferentType,
+                      MemberPointer.MemberInfo->ContainingType);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListBaseClass) {
+  using namespace members;
+  writeFieldList(BaseClass);
+  checkTypeReferences(0, BaseClass.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListEnumerator) {
+  using namespace members;
+  writeFieldList(Enumerator);
+  checkTypeReferences(0);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListMember) {
+  using namespace members;
+  writeFieldList(DataMember);
+  checkTypeReferences(0, DataMember.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListMethod) {
+  using namespace members;
+  writeFieldList(OverloadedMethod);
+  checkTypeReferences(0, OverloadedMethod.MethodList);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListOneMethod) {
+  using namespace members;
+  writeFieldList(OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4);
+  checkTypeReferences(0, OneMethod.T1, OneMethod.T2, OneMethod.T3,
+                      OneMethod.T4);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListNestedType) {
+  using namespace members;
+  writeFieldList(NestedType);
+  checkTypeReferences(0, NestedType.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListStaticMember) {
+  using namespace members;
+  writeFieldList(StaticDataMember);
+  checkTypeReferences(0, StaticDataMember.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListVirtualBase) {
+  using namespace members;
+  writeFieldList(VirtualBaseClass);
+  checkTypeReferences(0, VirtualBaseClass.BaseType, VirtualBaseClass.VBPtrType);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListVFTable) {
+  using namespace members;
+  writeFieldList(VFPtr);
+  checkTypeReferences(0, VFPtr.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, FieldListContinuation) {
+  using namespace members;
+  writeFieldList(Continuation);
+  checkTypeReferences(0, Continuation.ContinuationIndex);
+}
+
+TEST_F(TypeIndexIteratorTest, ManyMembers) {
+  using namespace members;
+  writeFieldList(BaseClass, Enumerator, DataMember, OverloadedMethod,
+                 OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4,
+                 NestedType, StaticDataMember, VirtualBaseClass, VFPtr,
+                 Continuation);
+
+  checkTypeReferences(
+      0, BaseClass.Type, DataMember.Type, OverloadedMethod.MethodList,
+      OneMethod.T1, OneMethod.T2, OneMethod.T3, OneMethod.T4, NestedType.Type,
+      StaticDataMember.Type, VirtualBaseClass.BaseType,
+      VirtualBaseClass.VBPtrType, VFPtr.Type, Continuation.ContinuationIndex);
+}
+
+TEST_F(TypeIndexIteratorTest, ProcSym) {
+  ProcSym GS(SymbolRecordKind::GlobalProcSym);
+  GS.FunctionType = TypeIndex::Float32();
+  ProcSym LS(SymbolRecordKind::ProcSym);
+  LS.FunctionType = TypeIndex::Float64();
+  writeSymbolRecords(GS, LS);
+  checkTypeReferences(0, GS.FunctionType);
+  checkTypeReferences(1, LS.FunctionType);
+}
+
+TEST_F(TypeIndexIteratorTest, DataSym) {
+  DataSym DS(SymbolRecordKind::GlobalData);
+  DS.Type = TypeIndex::Float32();
+  writeSymbolRecords(DS);
+  checkTypeReferences(0, DS.Type);
+}
+
+TEST_F(TypeIndexIteratorTest, RegisterSym) {
+  RegisterSym Reg(SymbolRecordKind::RegisterSym);
+  Reg.Index = TypeIndex::UInt32();
+  Reg.Register = RegisterId::EAX;
+  Reg.Name = "Target";
+  writeSymbolRecords(Reg);
+  checkTypeReferences(0, Reg.Index);
+}
+
+TEST_F(TypeIndexIteratorTest, CallerSym) {
+  CallerSym Callees(SymbolRecordKind::CalleeSym);
+  Callees.Indices.push_back(TypeIndex(1));
+  Callees.Indices.push_back(TypeIndex(2));
+  Callees.Indices.push_back(TypeIndex(3));
+  CallerSym Callers(SymbolRecordKind::CallerSym);
+  Callers.Indices.push_back(TypeIndex(4));
+  Callers.Indices.push_back(TypeIndex(5));
+  Callers.Indices.push_back(TypeIndex(6));
+  CallerSym Inlinees(SymbolRecordKind::InlineesSym);
+  Inlinees.Indices.push_back(TypeIndex(7));
+  Inlinees.Indices.push_back(TypeIndex(8));
+  Inlinees.Indices.push_back(TypeIndex(9));
+  writeSymbolRecords(Callees, Callers, Inlinees);
+  checkTypeReferences(0, TypeIndex(1), TypeIndex(2), TypeIndex(3));
+  checkTypeReferences(1, TypeIndex(4), TypeIndex(5), TypeIndex(6));
+  checkTypeReferences(2, TypeIndex(7), TypeIndex(8), TypeIndex(9));
+}
+
+TEST_F(TypeIndexIteratorTest, Precomp) {
+    PrecompRecord P(TypeRecordKind::Precomp);
+    P.StartTypeIndex = TypeIndex::FirstNonSimpleIndex;
+    P.TypesCount = 100;
+    P.Signature = 0x12345678;
+    P.PrecompFilePath = "C:/precomp.obj";
+
+    EndPrecompRecord EP(TypeRecordKind::EndPrecomp);
+    EP.Signature = P.Signature;
+
+    writeTypeRecords(P, EP);
+    checkTypeReferences(0);
+}