[codeview] Align class and print names of types

[rnk]

Summary

This way we can get rid of one of the fields in the .def file.

include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

bool consumeObject(ArrayRef<uint8_t> &Data, const T *&Res) {
     return true;
   }
 
   /// Actions to take on known types. By default, they do nothing. Visit methods
   /// for member records take the FieldData by non-const reference and are
   /// expected to consume the trailing bytes used by the field.
   /// FIXME: Make the visitor interpret the trailing bytes so that clients don't
   /// need to.
-#define TYPE_RECORD(EnumName, EnumVal, ClassName, PrintName)                   \
-  void visit##ClassName(TypeLeafKind LeafType, ClassName &Record) {}
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, ClassName, PrintName)
-#define MEMBER_RECORD(EnumName, EnumVal, ClassName, PrintName)                 \
-  void visit##ClassName(TypeLeafKind LeafType, ClassName &Record) {}
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, ClassName, PrintName)
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  void visit##Name(TypeLeafKind LeafType, Name##Record &Record) {}
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  void visit##Name(TypeLeafKind LeafType, Name##Record &Record) {}
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
   void visitTypeRecord(const TypeIterator::Record &Record) {
     ArrayRef<uint8_t> LeafData = Record.Data;
     ArrayRef<uint8_t> RecordData = LeafData;
     auto *DerivedThis = static_cast<Derived *>(this);
     DerivedThis->visitTypeBegin(Record.Type, RecordData);
     switch (Record.Type) {
     default:
       DerivedThis->visitUnknownType(Record.Type);
       break;
     case LF_FIELDLIST:
       DerivedThis->visitFieldList(Record.Type, LeafData);
       break;
-#define TYPE_RECORD(EnumName, EnumVal, ClassName, PrintName)                   \
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   case EnumName: {                                                             \
     TypeRecordKind RK = static_cast<TypeRecordKind>(EnumName);                 \
-    auto Result = ClassName::deserialize(RK, LeafData);                        \
+    auto Result = Name##Record::deserialize(RK, LeafData);                     \
     if (Result.getError())                                                     \
       return parseError();                                                     \
-    DerivedThis->visit##ClassName(Record.Type, *Result);                       \
+    DerivedThis->visit##Name(Record.Type, *Result);                            \
     break;                                                                     \
   }
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                  \
+  TYPE_RECORD(EnumVal, EnumVal, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)
 #include "TypeRecords.def"
       }
       DerivedThis->visitTypeEnd(Record.Type, RecordData);
   }
 
   /// Visits the type records in Data. Sets the error flag on parse failures.
   void visitTypeStream(ArrayRef<uint8_t> Data) {
     for (const auto &I : makeTypeRange(Data, &HadError)) {
while (!FieldData.empty()) {
         return;
       TypeLeafKind Leaf = TypeLeafKind(unsigned(*LeafPtr));
       switch (Leaf) {
       default:
         // Field list records do not describe their own length, so we cannot
         // continue parsing past an unknown member type.
         visitUnknownMember(Leaf);
         return parseError();
-#define MEMBER_RECORD(EnumName, EnumVal, ClassName, PrintName)                 \
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   case EnumName: {                                                             \
     TypeRecordKind RK = static_cast<TypeRecordKind>(EnumName);                 \
-    auto Result = ClassName::deserialize(RK, FieldData);                       \
+    auto Result = Name##Record::deserialize(RK, FieldData);                    \
     if (Result.getError())                                                     \
       return parseError();                                                     \
-    static_cast<Derived *>(this)->visit##ClassName(Leaf, *Result);             \
+    static_cast<Derived *>(this)->visit##Name(Leaf, *Result);                  \
     break;                                                                     \
   }
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
+  MEMBER_RECORD(EnumVal, EnumVal, AliasName)
 #include "TypeRecords.def"
       }
       FieldData = skipPadding(FieldData);
     }
   }
 
   /// Action to take on unknown members. By default, they are ignored. Member
   /// record parsing cannot recover from an unknown member record, so this

include/llvm/DebugInfo/CodeView/CodeView.h

enum class PointerToMemberRepresentation : uint16_t {
   SingleInheritanceFunction = 0x05,   // member function, single inheritance
   MultipleInheritanceFunction = 0x06, // member function, multiple inheritance
   VirtualInheritanceFunction = 0x07,  // member function, virtual inheritance
   GeneralFunction = 0x08              // member function, most general
 };
 
 /// Distinguishes individual records in .debug$T section or PDB type stream. The
 /// documentation and headers talk about this as the "leaf" type.
-enum TypeLeafKind : uint16_t {
-#define CV_TYPE(name, val) name = val,
-#include "TypeRecords.def"
-};
-
 enum class TypeRecordKind : uint16_t {
-  None = 0,
-
-  VirtualTableShape = 0x000a,
-  Label = 0x000e,
-  EndPrecompiledHeader = 0x0014,
-
-  Modifier = 0x1001,
-  Pointer = 0x1002,
-  Procedure = 0x1008,
-  MemberFunction = 0x1009,
-
-  Oem = 0x100f,
-  Oem2 = 0x1011,
-
-  ArgumentList = 0x1201,
+#define TYPE_RECORD(lf_ename, value, name) name = value,
+#include "TypeRecords.def"
+  // FIXME: Add serialization support
   FieldList = 0x1203,
   BitField = 0x1205,
-  MethodList = 0x1206,
-
-  BaseClass = 0x1400,
-  VirtualBaseClass = 0x1401,
-  IndirectVirtualBaseClass = 0x1402,
-  Index = 0x1404,
-  VirtualFunctionTablePointer = 0x1409,
-
-  Enumerate = 0x1502,
-  Array = 0x1503,
-  Class = 0x1504,
-  Structure = 0x1505,
-  Union = 0x1506,
-  Enum = 0x1507,
-  Alias = 0x150a,
-  Member = 0x150d,
-  StaticMember = 0x150e,
-  OverloadedMethod = 0x150f,
-  NestedType = 0x1510,
-  OneMethod = 0x1511,
-  TypeServer2 = 0x1515,
-  VirtualFunctionTable = 0x151d,
-
-  FunctionId = 0x1601,
-  MemberFunctionId = 0x1602,
-  BuildInfo = 0x1603,
-  SubstringList = 0x1604,
-  StringId = 0x1605,
-  UdtSourceLine = 0x1606,
-
-  SByte = 0x8000,
-  Int16 = 0x8001,
-  UInt16 = 0x8002,
-  Int32 = 0x8003,
-  UInt32 = 0x8004,
-  Single = 0x8005,
-  Double = 0x8006,
-  Float80 = 0x8007,
-  Float128 = 0x8008,
-  Int64 = 0x8009,
-  UInt64 = 0x800a,
-  Float48 = 0x800b,
-  Complex32 = 0x800c,
-  Complex64 = 0x800d,
-  Complex80 = 0x800e,
-  Complex128 = 0x800f,
-  VarString = 0x8010,
-
-  Int128 = 0x8017,
-  UInt128 = 0x8018,
-
-  Decimal = 0x8019,
-  Date = 0x801a,
-  Utf8String = 0x801b,
+};
 
-  Float16 = 0x801c
+/// 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 {
+#define CV_TYPE(name, val) name = val,
+#include "TypeRecords.def"
 };
 
-enum class VirtualTableSlotKind : uint8_t {
+enum class VFTableSlotKind : uint8_t {
   Near16 = 0x00,
   Far16 = 0x01,
   This = 0x02,
   Outer = 0x03,
   Meta = 0x04,
   Near = 0x05,
   Far = 0x06
 };

include/llvm/DebugInfo/CodeView/TypeRecord.h

private:
   CallingConvention CallConv;
   FunctionOptions Options;
   uint16_t ParameterCount;
   TypeIndex ArgumentList;
   int32_t ThisPointerAdjustment;
 };
 
 // LF_MFUNC_ID
-class MemberFunctionIdRecord : public TypeRecord {
+class MemberFuncIdRecord : public TypeRecord {
 public:
-  MemberFunctionIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
+  MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
                          StringRef Name)
-      : TypeRecord(TypeRecordKind::MemberFunctionId), ClassType(ClassType),
+      : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),
         FunctionType(FunctionType), Name(Name) {}
 
-  static ErrorOr<MemberFunctionIdRecord> deserialize(TypeRecordKind Kind,
+  static ErrorOr<MemberFuncIdRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
-    return MemberFunctionIdRecord(L->ClassType, L->FunctionType, Name);
+    return MemberFuncIdRecord(L->ClassType, L->FunctionType, Name);
   }
 
   TypeIndex getClassType() const { return ClassType; }
   TypeIndex getFunctionType() const { return FunctionType; }
   StringRef getName() const { return Name; }
 
 private:
   struct Layout {
     TypeIndex ClassType;
     TypeIndex FunctionType;
     // Name: The null-terminated name follows.
   };
   TypeIndex ClassType;
   TypeIndex FunctionType;
   StringRef Name;
 };
 
 // LF_ARGLIST, LF_SUBSTR_LIST
-class StringListRecord : public TypeRecord {
+class ArgListRecord : public TypeRecord {
 public:
-  StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
+  ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
       : TypeRecord(Kind), StringIndices(Indices) {}
 
-  static ErrorOr<StringListRecord> deserialize(TypeRecordKind Kind,
+  static ErrorOr<ArgListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
-    if (Kind != TypeRecordKind::SubstringList &&
-        Kind != TypeRecordKind::ArgumentList)
+    if (Kind != TypeRecordKind::StringList && Kind != TypeRecordKind::ArgList)
       return std::make_error_code(std::errc::illegal_byte_sequence);
 
     const Layout *L = nullptr;
     ArrayRef<TypeIndex> Indices;
     CV_DESERIALIZE(Data, L, CV_ARRAY_FIELD_N(Indices, L->NumArgs));
 
-    return StringListRecord(Kind, Indices);
+    return ArgListRecord(Kind, Indices);
   }
 
   ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
 
   static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
 
 private:
   struct Layout {
struct Layout {
     TypeIndex UnderlyingType;
     TypeIndex FieldListType;
     // Name: The null-terminated name follows.
   };
 
   TypeIndex UnderlyingType;
 };
 
-class BitFieldRecord : TypeRecord {
+class BitFieldRecord : public TypeRecord {
 public:
   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; }
 
 private:
   TypeIndex Type;
   uint8_t BitSize;
   uint8_t BitOffset;
 };
 
 // LF_VTSHAPE
-class VirtualTableShapeRecord : TypeRecord {
+class VFTableShapeRecord : public TypeRecord {
 public:
-  explicit VirtualTableShapeRecord(ArrayRef<VirtualTableSlotKind> Slots)
-      : TypeRecord(TypeRecordKind::VirtualTableShape), SlotsRef(Slots) {}
-  explicit VirtualTableShapeRecord(std::vector<VirtualTableSlotKind> Slots)
-      : TypeRecord(TypeRecordKind::VirtualTableShape), Slots(Slots) {}
+  explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)
+      : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}
+  explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
+      : TypeRecord(TypeRecordKind::VFTableShape), Slots(Slots) {}
 
-  static ErrorOr<VirtualTableShapeRecord> deserialize(TypeRecordKind Kind,
+  static ErrorOr<VFTableShapeRecord> deserialize(TypeRecordKind Kind,
                                                       ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
-    std::vector<VirtualTableSlotKind> Slots;
+    std::vector<VFTableSlotKind> Slots;
     uint16_t Count = L->VFEntryCount;
     while (Count > 0) {
       if (Data.empty())
         return std::make_error_code(std::errc::illegal_byte_sequence);
 
       // Process up to 2 nibbles at a time (if there are at least 2 remaining)
       uint8_t Value = Data[0] & 0x0F;
-      Slots.push_back(static_cast<VirtualTableSlotKind>(Value));
+      Slots.push_back(static_cast<VFTableSlotKind>(Value));
       if (--Count > 0) {
         Value = (Data[0] & 0xF0) >> 4;
-        Slots.push_back(static_cast<VirtualTableSlotKind>(Value));
+        Slots.push_back(static_cast<VFTableSlotKind>(Value));
         --Count;
       }
       Data = Data.slice(1);
     }
 
-    return VirtualTableShapeRecord(Slots);
+    return VFTableShapeRecord(Slots);
   }
 
-  ArrayRef<VirtualTableSlotKind> getSlots() const {
+  ArrayRef<VFTableSlotKind> getSlots() const {
     if (!SlotsRef.empty())
       return SlotsRef;
     return Slots;
   }
   uint32_t getEntryCount() const { return getSlots().size(); }
 
 private:
   struct Layout {
     // Number of vftable entries. Each method may have more than one entry due
     // to
     // things like covariant return types.
     ulittle16_t VFEntryCount;
     // Descriptors[]: 4-bit virtual method descriptors of type CV_VTS_desc_e.
   };
 
 private:
-  ArrayRef<VirtualTableSlotKind> SlotsRef;
-  std::vector<VirtualTableSlotKind> Slots;
+  ArrayRef<VFTableSlotKind> SlotsRef;
+  std::vector<VFTableSlotKind> Slots;
 };
 
 // LF_TYPESERVER2
-class TypeServer2Record : TypeRecord {
+class TypeServer2Record : public TypeRecord {
 public:
   TypeServer2Record(StringRef Guid, uint32_t Age, StringRef Name)
       : TypeRecord(TypeRecordKind::TypeServer2), Guid(Guid), Age(Age),
         Name(Name) {}
 
   static ErrorOr<TypeServer2Record> deserialize(TypeRecordKind Kind,
                                                 ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
private:
   TypeIndex Id;
   StringRef String;
 };
 
 // LF_FUNC_ID
 class FuncIdRecord : public TypeRecord {
 public:
   FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
-      : TypeRecord(TypeRecordKind::FunctionId), ParentScope(ParentScope),
+      : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),
         FunctionType(FunctionType), Name(Name) {}
 
   static ErrorOr<FuncIdRecord> deserialize(TypeRecordKind Kind,
                                            ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
private:
   struct Layout {
     ulittle16_t NumArgs; // Number of arguments
                          // ArgTypes[]: Type indicies of arguments
   };
   ArrayRef<TypeIndex> ArgIndices;
 };
 
 // LF_VFTABLE
-class VirtualTableRecord : public TypeRecord {
+class VFTableRecord : public TypeRecord {
 public:
-  VirtualTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
-                     uint32_t VFPtrOffset, StringRef Name,
-                     ArrayRef<StringRef> Methods)
-      : TypeRecord(TypeRecordKind::VirtualFunctionTable),
+  VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
+      : TypeRecord(TypeRecordKind::VFTable),
         CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
         VFPtrOffset(VFPtrOffset), Name(Name), MethodNamesRef(Methods) {}
-  VirtualTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
-                     uint32_t VFPtrOffset, StringRef Name,
-                     const std::vector<StringRef> &Methods)
-      : TypeRecord(TypeRecordKind::VirtualFunctionTable),
+  VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
+      : TypeRecord(TypeRecordKind::VFTable),
         CompleteClass(CompleteClass), OverriddenVFTable(OverriddenVFTable),
         VFPtrOffset(VFPtrOffset), Name(Name), MethodNames(Methods) {}
 
-  static ErrorOr<VirtualTableRecord> deserialize(TypeRecordKind Kind,
-                                                 ArrayRef<uint8_t> &Data) {
+  static ErrorOr<VFTableRecord> deserialize(TypeRecordKind Kind,
     const Layout *L = nullptr;
     StringRef Name;
     std::vector<StringRef> Names;
     CV_DESERIALIZE(Data, L, Name, CV_ARRAY_FIELD_TAIL(Names));
 
-    return VirtualTableRecord(L->CompleteClass, L->OverriddenVFTable,
-                              L->VFPtrOffset, Name, Names);
+    return VFTableRecord(L->CompleteClass, L->OverriddenVFTable, L->VFPtrOffset,
+                         Name, Names);
   }
 
   TypeIndex getCompleteClass() const { return CompleteClass; }
   TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
   uint32_t getVFPtrOffset() const { return VFPtrOffset; }
   StringRef getName() const { return Name; }
   ArrayRef<StringRef> getMethodNames() const {
     if (!MethodNamesRef.empty())
private:
   int32_t VFTableOffset;
   StringRef Name;
 };
 
 // LF_METHODLIST
 class MethodOverloadListRecord : public TypeRecord {
 public:
   MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)
-      : TypeRecord(TypeRecordKind::MethodList), MethodsRef(Methods) {}
+      : TypeRecord(TypeRecordKind::MethodOverloadList), MethodsRef(Methods) {}
   MethodOverloadListRecord(std::vector<OneMethodRecord> &Methods)
-      : TypeRecord(TypeRecordKind::MethodList), Methods(Methods) {}
+      : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}
 
   static ErrorOr<MethodOverloadListRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     std::vector<OneMethodRecord> Methods;
     while (!Data.empty()) {
       const Layout *L = nullptr;
       int32_t VFTableOffset = 0;
       CV_DESERIALIZE(
private:
   StringRef Name;
 };
 
 // LF_MEMBER
 class DataMemberRecord : public TypeRecord {
 public:
   DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
                    StringRef Name)
-      : TypeRecord(TypeRecordKind::Member), Access(Access), Type(Type),
+      : TypeRecord(TypeRecordKind::DataMember), Access(Access), Type(Type),
         FieldOffset(Offset), Name(Name) {}
 
   static ErrorOr<DataMemberRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     uint64_t Offset;
     StringRef Name;
     CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), Name);
private:
   uint64_t FieldOffset;
   StringRef Name;
 };
 
 // LF_STMEMBER
 class StaticDataMemberRecord : public TypeRecord {
 public:
   StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
-      : TypeRecord(TypeRecordKind::StaticMember), Access(Access), Type(Type),
-        Name(Name) {}
+      : TypeRecord(TypeRecordKind::StaticDataMember), Access(Access),
+        Type(Type), Name(Name) {}
 
   static ErrorOr<StaticDataMemberRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Name);
 
     return StaticDataMemberRecord(L->Attrs.getAccess(), L->Type, Name);
private:
   TypeIndex Type;
   StringRef Name;
 };
 
 // LF_ENUMERATE
 class EnumeratorRecord : public TypeRecord {
 public:
   EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
-      : TypeRecord(TypeRecordKind::Enumerate), Access(Access), Value(Value),
+      : TypeRecord(TypeRecordKind::Enumerator), Access(Access), Value(Value),
         Name(Name) {}
 
   static ErrorOr<EnumeratorRecord> deserialize(TypeRecordKind Kind,
                                                ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     APSInt Value;
     StringRef Name;
     CV_DESERIALIZE(Data, L, Value, Name);
private:
   };
 
   MemberAccess Access;
   APSInt Value;
   StringRef Name;
 };
 
 // LF_VFUNCTAB
-class VirtualFunctionPointerRecord : public TypeRecord {
+class VFPtrRecord : public TypeRecord {
 public:
-  VirtualFunctionPointerRecord(TypeIndex Type)
-      : TypeRecord(TypeRecordKind::VirtualFunctionTablePointer), Type(Type) {}
-  static ErrorOr<VirtualFunctionPointerRecord>
+  VFPtrRecord(TypeIndex Type)
+      : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
+  static ErrorOr<VFPtrRecord>
   deserialize(TypeRecordKind Kind, ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     if (auto EC = consumeObject(Data, L))
       return EC;
 
-    return VirtualFunctionPointerRecord(L->Type);
+    return VFPtrRecord(L->Type);
   }
 
   TypeIndex getType() const { return Type; }
 
 private:
   struct Layout {
     ulittle16_t Pad0;
     TypeIndex Type; // Type of vfptr

include/llvm/DebugInfo/CodeView/TypeRecords.def

 //
 // See LEAF_ENUM_e in cvinfo.h. This should match the constants there.
 //
 //===----------------------------------------------------------------------===//
 
 // If the type is known, then we have a record describing it in TypeRecord.h.
 
 #ifndef CV_TYPE
-#define CV_TYPE(ename, value)
+#define CV_TYPE(lf_ename, value)
 #endif
 
 // If the type is known, then we have a record describing it in TypeRecord.h.
 #ifndef TYPE_RECORD
-#define TYPE_RECORD(ename, value, class_name, print_name) CV_TYPE(ename, value)
+#define TYPE_RECORD(lf_ename, value, name) CV_TYPE(lf_ename, value)
 #endif
 
 #ifndef TYPE_RECORD_ALIAS
-#define TYPE_RECORD_ALIAS(ename, value, class_name, print_name) TYPE_RECORD(ename, value, class_name, print_name)
+#define TYPE_RECORD_ALIAS(lf_ename, value, name, alias_name)                   \
+  TYPE_RECORD(lf_ename, value, name)
 #endif
 
 #ifndef MEMBER_RECORD
-#define MEMBER_RECORD(ename, value, class_name, print_name) TYPE_RECORD(ename, value, class_name, print_name)
+#define MEMBER_RECORD(lf_ename, value, name) TYPE_RECORD(lf_ename, value, name)
 #endif
 
 #ifndef MEMBER_RECORD_ALIAS
-#define MEMBER_RECORD_ALIAS(ename, value, class_name, print_name) MEMBER_RECORD(ename, value, class_name, print_name)
+#define MEMBER_RECORD_ALIAS(lf_ename, value, name, alias_name)                 \
+  MEMBER_RECORD(lf_ename, value, name)
 #endif
 
-TYPE_RECORD(LF_POINTER, 0x1002, PointerRecord, PointerType)
-TYPE_RECORD(LF_MODIFIER, 0x1001, ModifierRecord, TypeModifier)
-TYPE_RECORD(LF_PROCEDURE, 0x1008, ProcedureRecord, ProcedureType)
-TYPE_RECORD(LF_MFUNCTION, 0x1009, MemberFunctionRecord, MemberFunctionType)
-TYPE_RECORD(LF_ARGLIST, 0x1201, StringListRecord, ArgList)
-
-TYPE_RECORD(LF_ARRAY, 0x1503, ArrayRecord, ArrayType)
-TYPE_RECORD(LF_CLASS, 0x1504, ClassRecord, ClassType)
-TYPE_RECORD_ALIAS(LF_STRUCTURE, 0x1505, ClassRecord, ClassType)
-TYPE_RECORD_ALIAS(LF_INTERFACE, 0x1519, ClassRecord, ClassType)
-TYPE_RECORD(LF_UNION, 0x1506, UnionRecord, UnionType)
-TYPE_RECORD(LF_ENUM, 0x1507, EnumRecord, EnumType)
-TYPE_RECORD(LF_TYPESERVER2, 0x1515, TypeServer2Record, TypeServer2)
-TYPE_RECORD(LF_VFTABLE, 0x151d, VirtualTableRecord, VFTableType)
-TYPE_RECORD(LF_VTSHAPE, 0x000a, VirtualTableShapeRecord, VTableShape)
+TYPE_RECORD(LF_POINTER, 0x1002, Pointer)
+TYPE_RECORD(LF_MODIFIER, 0x1001, Modifier)
+TYPE_RECORD(LF_PROCEDURE, 0x1008, Procedure)
+TYPE_RECORD(LF_MFUNCTION, 0x1009, MemberFunction)
+TYPE_RECORD(LF_ARGLIST, 0x1201, ArgList)
+
+TYPE_RECORD(LF_ARRAY, 0x1503, Array)
+TYPE_RECORD(LF_CLASS, 0x1504, Class)
+TYPE_RECORD_ALIAS(LF_STRUCTURE, 0x1505, Struct, Class)
+TYPE_RECORD_ALIAS(LF_INTERFACE, 0x1519, Interface, Class)
+TYPE_RECORD(LF_UNION, 0x1506, Union)
+TYPE_RECORD(LF_ENUM, 0x1507, Enum)
+TYPE_RECORD(LF_TYPESERVER2, 0x1515, TypeServer2)
+TYPE_RECORD(LF_VFTABLE, 0x151d, VFTable)
+TYPE_RECORD(LF_VTSHAPE, 0x000a, VFTableShape)
 
 // Member type records. These are generally not length prefixed, and appear
 // inside of a field list record.
-MEMBER_RECORD(LF_BCLASS, 0x1400, BaseClassRecord, BaseClass)
-MEMBER_RECORD_ALIAS(LF_BINTERFACE, 0x151a, BaseClassRecord, BaseClass)
+MEMBER_RECORD(LF_BCLASS, 0x1400, BaseClass)
+MEMBER_RECORD_ALIAS(LF_BINTERFACE, 0x151a, BaseInterface, BaseClass)
 
-MEMBER_RECORD(LF_VBCLASS, 0x1401, VirtualBaseClassRecord, VirtualBaseClass)
-MEMBER_RECORD_ALIAS(LF_IVBCLASS, 0x1402, VirtualBaseClassRecord, VirtualBaseClass)
-
-MEMBER_RECORD(LF_VFUNCTAB, 0x1409, VirtualFunctionPointerRecord, VirtualFunctionPointer)
-MEMBER_RECORD(LF_STMEMBER, 0x150e, StaticDataMemberRecord, StaticDataMember)
-MEMBER_RECORD(LF_METHOD, 0x150f, OverloadedMethodRecord, OverloadedMethod)
-MEMBER_RECORD(LF_MEMBER, 0x150d, DataMemberRecord, DataMember)
-MEMBER_RECORD(LF_NESTTYPE, 0x1510, NestedTypeRecord, NestedType)
-MEMBER_RECORD(LF_ONEMETHOD, 0x1511, OneMethodRecord, OneMethod)
-MEMBER_RECORD(LF_ENUMERATE, 0x1502, EnumeratorRecord, Enumerator)
+MEMBER_RECORD(LF_VBCLASS, 0x1401, VirtualBaseClass)
+MEMBER_RECORD_ALIAS(LF_IVBCLASS, 0x1402, IndirectVirtualBaseClass,
+                    VirtualBaseClass)
+
+MEMBER_RECORD(LF_VFUNCTAB, 0x1409, VFPtr)
+MEMBER_RECORD(LF_STMEMBER, 0x150e, StaticDataMember)
+MEMBER_RECORD(LF_METHOD, 0x150f, OverloadedMethod)
+MEMBER_RECORD(LF_MEMBER, 0x150d, DataMember)
+MEMBER_RECORD(LF_NESTTYPE, 0x1510, NestedType)
+MEMBER_RECORD(LF_ONEMETHOD, 0x1511, OneMethod)
+MEMBER_RECORD(LF_ENUMERATE, 0x1502, Enumerator)
 
 // ID leaf records. Subsequent leaf types may be referenced from .debug$S.
-TYPE_RECORD(LF_FUNC_ID, 0x1601, FuncIdRecord, FuncId)
-TYPE_RECORD(LF_MFUNC_ID, 0x1602, MemberFunctionIdRecord, MemberFuncId)
-TYPE_RECORD(LF_BUILDINFO, 0x1603, BuildInfoRecord, BuildInfo)
-TYPE_RECORD_ALIAS(LF_SUBSTR_LIST, 0x1604, StringListRecord, ArgList)
-TYPE_RECORD(LF_STRING_ID, 0x1605, StringIdRecord, StringId)
-TYPE_RECORD(LF_UDT_SRC_LINE, 0x1606, UdtSourceLineRecord, UDTSrcLine)
+TYPE_RECORD(LF_FUNC_ID, 0x1601, FuncId)
+TYPE_RECORD(LF_MFUNC_ID, 0x1602, MemberFuncId)
+TYPE_RECORD(LF_BUILDINFO, 0x1603, BuildInfo)
+// FIXME: We reuse the structure of ArgListRecord for substring lists, but it
+// makes for confusing dumper output.
+TYPE_RECORD_ALIAS(LF_SUBSTR_LIST, 0x1604, StringList, ArgList)
+TYPE_RECORD(LF_STRING_ID, 0x1605, StringId)
+TYPE_RECORD(LF_UDT_SRC_LINE, 0x1606, UdtSourceLine)
 
-TYPE_RECORD(LF_METHODLIST, 0x1206, MethodOverloadListRecord, MethodListEntry)
+TYPE_RECORD(LF_METHODLIST, 0x1206, MethodOverloadList)
 
 
 // 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)

include/llvm/DebugInfo/CodeView/TypeTableBuilder.h

 
 public:
   virtual ~TypeTableBuilder();
 
 public:
   TypeIndex writeModifier(const ModifierRecord &Record);
   TypeIndex writeProcedure(const ProcedureRecord &Record);
   TypeIndex writeMemberFunction(const MemberFunctionRecord &Record);
-  TypeIndex writeArgumentList(const StringListRecord &Record);
+  TypeIndex writeArgList(const ArgListRecord &Record);
   TypeIndex writeRecord(TypeRecordBuilder &builder);
   TypeIndex writePointer(const PointerRecord &Record);
   TypeIndex writeArray(const ArrayRecord &Record);
   TypeIndex writeClass(const ClassRecord &Record);
   TypeIndex writeEnum(const EnumRecord &Record);
   TypeIndex writeBitField(const BitFieldRecord &Record);
-  TypeIndex writeVirtualTableShape(const VirtualTableShapeRecord &Record);
+  TypeIndex writeVFTableShape(const VFTableShapeRecord &Record);
 
   TypeIndex writeFieldList(FieldListRecordBuilder &FieldList);
   TypeIndex writeMethodList(MethodListRecordBuilder &MethodList);
 
 private:
   virtual TypeIndex writeRecord(llvm::StringRef record) = 0;
 };
 }
 }
 
 #endif

lib/DebugInfo/CodeView/FieldListRecordBuilder.cpp

void FieldListRecordBuilder::writeBaseClass(MemberAccess Access, TypeIndex Type,
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeEnumerate(MemberAccess Access, uint64_t Value,
                                             StringRef Name) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::Enumerate);
+  Builder.writeTypeRecordKind(TypeRecordKind::Enumerator);
   Builder.writeUInt16(static_cast<uint16_t>(Access));
   Builder.writeEncodedUnsignedInteger(Value);
   Builder.writeNullTerminatedString(Name);
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeMember(MemberAccess Access, TypeIndex Type,
                                          uint64_t Offset, StringRef Name) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::Member);
+  Builder.writeTypeRecordKind(TypeRecordKind::DataMember);
   Builder.writeUInt16(static_cast<uint16_t>(Access));
   Builder.writeTypeIndex(Type);
   Builder.writeEncodedUnsignedInteger(Offset);
   Builder.writeNullTerminatedString(Name);
 
   finishSubRecord();
 }
 
void FieldListRecordBuilder::writeNestedType(TypeIndex Type, StringRef Name) {
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeStaticMember(MemberAccess Access,
                                                TypeIndex Type, StringRef Name) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::StaticMember);
+  Builder.writeTypeRecordKind(TypeRecordKind::StaticDataMember);
   Builder.writeUInt16(static_cast<uint16_t>(Access));
   Builder.writeTypeIndex(Type);
   Builder.writeNullTerminatedString(Name);
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeIndirectVirtualBaseClass(
void FieldListRecordBuilder::writeVirtualBaseClass(
   Builder.writeEncodedUnsignedInteger(SlotIndex);
 
   finishSubRecord();
 }
 
 void FieldListRecordBuilder::writeVirtualFunctionTablePointer(TypeIndex Type) {
   TypeRecordBuilder &Builder = getBuilder();
 
-  Builder.writeTypeRecordKind(TypeRecordKind::VirtualFunctionTablePointer);
+  Builder.writeTypeRecordKind(TypeRecordKind::VFPtr);
   Builder.writeUInt16(0);
   Builder.writeTypeIndex(Type);
 
   finishSubRecord();
-}
+}
 

lib/DebugInfo/CodeView/MethodListRecordBuilder.cpp

 //===-- MethodListRecordBuilder.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/MethodListRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/FieldListRecordBuilder.h"
 
 using namespace llvm;
 using namespace codeview;
 
 MethodListRecordBuilder::MethodListRecordBuilder()
-    : ListRecordBuilder(TypeRecordKind::MethodList) {}
+    : ListRecordBuilder(TypeRecordKind::MethodOverloadList) {}
 
 void MethodListRecordBuilder::writeMethod(MemberAccess Access, MethodKind Kind,
                                           MethodOptions Options, TypeIndex Type,
                                           int32_t VTableSlotOffset) {
   TypeRecordBuilder &Builder = getBuilder();
 
   uint16_t Flags = static_cast<uint16_t>(Access);
   Flags |= static_cast<uint16_t>(Kind) << MethodKindShift;

lib/DebugInfo/CodeView/TypeDumper.cpp

 /// Use this private dumper implementation to keep implementation details about
 /// the visitor out of TypeDumper.h.
 class CVTypeDumperImpl : public CVTypeVisitor<CVTypeDumperImpl> {
 public:
   CVTypeDumperImpl(CVTypeDumper &CVTD, ScopedPrinter &W, bool PrintRecordBytes)
       : CVTD(CVTD), W(W), PrintRecordBytes(PrintRecordBytes) {}
 
   /// CVTypeVisitor overrides.
-#define TYPE_RECORD(EnumName, EnumVal, ClassName, PrintName)                   \
-  void visit##ClassName(TypeLeafKind LeafType, ClassName &Record);
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, ClassName, PrintName)
-#define MEMBER_RECORD(EnumName, EnumVal, ClassName, PrintName)                 \
-  void visit##ClassName(TypeLeafKind LeafType, ClassName &Record);
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, ClassName, PrintName)
+#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
+  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
+  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
   void visitUnknownMember(TypeLeafKind Leaf);
 
   void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
   void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
 
   void printMemberAttributes(MemberAttributes Attrs);
private:
   /// Name of the current type. Only valid before visitTypeEnd.
   StringRef Name;
 };
 
 } // end anonymous namespace
 
 static StringRef getLeafTypeName(TypeLeafKind LT) {
   switch (LT) {
-#define TYPE_RECORD(ename, value, class_name, print_name)                      \
+#define TYPE_RECORD(ename, value, name)                                        \
   case ename:                                                                  \
-    return #print_name;
+    return #name;
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   default:
     break;
   }
   return "UnknownLeaf";
 }
 
 void CVTypeDumperImpl::visitTypeBegin(TypeLeafKind Leaf,
void CVTypeDumperImpl::visitTypeEnd(TypeLeafKind Leaf,
 
   if (PrintRecordBytes)
     W.printBinaryBlock("LeafData", getBytesAsCharacters(LeafData));
 
   W.unindent();
   W.startLine() << "}\n";
 }
 
-void CVTypeDumperImpl::visitStringIdRecord(TypeLeafKind Leaf,
+void CVTypeDumperImpl::visitStringId(TypeLeafKind Leaf,
                                            StringIdRecord &String) {
   printTypeIndex("Id", String.getId());
   W.printString("StringData", String.getString());
   // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.
   Name = String.getString();
 }
-void CVTypeDumperImpl::visitStringListRecord(TypeLeafKind Leaf,
-                                             StringListRecord &Args) {
+void CVTypeDumperImpl::visitArgList(TypeLeafKind Leaf, ArgListRecord &Args) {
   auto Indices = Args.getIndices();
   uint32_t Size = Indices.size();
   W.printNumber("NumArgs", Size);
   ListScope Arguments(W, "Arguments");
   SmallString<256> TypeName("(");
   for (uint32_t I = 0; I < Size; ++I) {
     printTypeIndex("ArgType", Indices[I]);
     StringRef ArgTypeName = getTypeName(Indices[I]);
     TypeName.append(ArgTypeName);
     if (I + 1 != Size)
       TypeName.append(", ");
   }
   TypeName.push_back(')');
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitClassRecord(TypeLeafKind Leaf, ClassRecord &Class) {
+void CVTypeDumperImpl::visitClass(TypeLeafKind Leaf, 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());
   Name = Class.getName();
 }
 
-void CVTypeDumperImpl::visitUnionRecord(TypeLeafKind Leaf, UnionRecord &Union) {
+void CVTypeDumperImpl::visitUnion(TypeLeafKind Leaf, 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());
   Name = Union.getName();
 }
 
-void CVTypeDumperImpl::visitEnumRecord(TypeLeafKind Leaf, EnumRecord &Enum) {
+void CVTypeDumperImpl::visitEnum(TypeLeafKind Leaf, EnumRecord &Enum) {
   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());
   Name = Enum.getName();
 }
 
-void CVTypeDumperImpl::visitArrayRecord(TypeLeafKind Leaf, ArrayRecord &AT) {
+void CVTypeDumperImpl::visitArray(TypeLeafKind Leaf, ArrayRecord &AT) {
   printTypeIndex("ElementType", AT.getElementType());
   printTypeIndex("IndexType", AT.getIndexType());
   W.printNumber("SizeOf", AT.getSize());
   W.printString("Name", AT.getName());
   Name = AT.getName();
 }
 
-void CVTypeDumperImpl::visitVirtualTableRecord(TypeLeafKind Leaf,
-                                               VirtualTableRecord &VFT) {
+void CVTypeDumperImpl::visitVFTable(TypeLeafKind Leaf, 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);
   Name = VFT.getName();
 }
 
-void CVTypeDumperImpl::visitMemberFunctionIdRecord(TypeLeafKind Leaf,
-                                                   MemberFunctionIdRecord &Id) {
+void CVTypeDumperImpl::visitMemberFuncId(TypeLeafKind Leaf,
+                                               MemberFuncIdRecord &Id) {
   printTypeIndex("ClassType", Id.getClassType());
   printTypeIndex("FunctionType", Id.getFunctionType());
   W.printString("Name", Id.getName());
   Name = Id.getName();
 }
 
-void CVTypeDumperImpl::visitProcedureRecord(TypeLeafKind Leaf,
-                                            ProcedureRecord &Proc) {
+void CVTypeDumperImpl::visitProcedure(TypeLeafKind Leaf,
   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());
 
   StringRef ReturnTypeName = getTypeName(Proc.getReturnType());
   StringRef ArgListTypeName = getTypeName(Proc.getArgumentList());
   SmallString<256> TypeName(ReturnTypeName);
   TypeName.push_back(' ');
   TypeName.append(ArgListTypeName);
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitMemberFunctionRecord(TypeLeafKind Leaf,
-                                                 MemberFunctionRecord &MF) {
+void CVTypeDumperImpl::visitMemberFunction(TypeLeafKind Leaf,
   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());
 
   StringRef ReturnTypeName = getTypeName(MF.getReturnType());
   StringRef ClassTypeName = getTypeName(MF.getClassType());
   StringRef ArgListTypeName = getTypeName(MF.getArgumentList());
   SmallString<256> TypeName(ReturnTypeName);
   TypeName.push_back(' ');
   TypeName.append(ClassTypeName);
   TypeName.append("::");
   TypeName.append(ArgListTypeName);
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitMethodOverloadListRecord(TypeLeafKind Leaf,
-                                             MethodOverloadListRecord &MethodList) {
+void CVTypeDumperImpl::visitMethodOverloadList(
+    TypeLeafKind Leaf, MethodOverloadListRecord &MethodList) {
   for (auto &M : MethodList.getMethods()) {
     ListScope S(W, "Method");
     printMemberAttributes(M.getAccess(), M.getKind(), M.getOptions());
     printTypeIndex("Type", M.getType());
     if (M.isIntroducingVirtual())
       W.printHex("VFTableOffset", M.getVFTableOffset());
   }
 }
 
-void CVTypeDumperImpl::visitFuncIdRecord(TypeLeafKind Leaf,
-                                         FuncIdRecord &Func) {
+void CVTypeDumperImpl::visitFuncId(TypeLeafKind Leaf, FuncIdRecord &Func) {
   printTypeIndex("ParentScope", Func.getParentScope());
   printTypeIndex("FunctionType", Func.getFunctionType());
   W.printString("Name", Func.getName());
   Name = Func.getName();
 }
 
-void CVTypeDumperImpl::visitTypeServer2Record(TypeLeafKind Leaf,
-                                              TypeServer2Record &TS) {
+void CVTypeDumperImpl::visitTypeServer2(TypeLeafKind Leaf,
   W.printBinary("Signature", TS.getGuid());
   W.printNumber("Age", TS.getAge());
   W.printString("Name", TS.getName());
   Name = TS.getName();
 }
 
-void CVTypeDumperImpl::visitPointerRecord(TypeLeafKind Leaf,
-                                          PointerRecord &Ptr) {
+void CVTypeDumperImpl::visitPointer(TypeLeafKind Leaf, 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());
else if (Ptr.getMode() == PointerMode::RValueReference)
       TypeName.append("&&");
     else if (Ptr.getMode() == PointerMode::Pointer)
       TypeName.append("*");
 
     Name = CVTD.saveName(TypeName);
   }
 }
 
-void CVTypeDumperImpl::visitModifierRecord(TypeLeafKind Leaf,
-                                           ModifierRecord &Mod) {
+void CVTypeDumperImpl::visitModifier(TypeLeafKind Leaf, ModifierRecord &Mod) {
   uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
   printTypeIndex("ModifiedType", Mod.getModifiedType());
   W.printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));
 
   StringRef ModifiedName = getTypeName(Mod.getModifiedType());
   SmallString<256> TypeName;
   if (Mods & uint16_t(ModifierOptions::Const))
     TypeName.append("const ");
   if (Mods & uint16_t(ModifierOptions::Volatile))
     TypeName.append("volatile ");
   if (Mods & uint16_t(ModifierOptions::Unaligned))
     TypeName.append("__unaligned ");
   TypeName.append(ModifiedName);
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitVirtualTableShapeRecord(
-    TypeLeafKind Leaf, VirtualTableShapeRecord &Shape) {
+void CVTypeDumperImpl::visitVFTableShape(TypeLeafKind Leaf,
+                                         VFTableShapeRecord &Shape) {
   W.printNumber("VFEntryCount", Shape.getEntryCount());
 }
 
-void CVTypeDumperImpl::visitUdtSourceLineRecord(TypeLeafKind Leaf,
-                                                UdtSourceLineRecord &Line) {
+void CVTypeDumperImpl::visitUdtSourceLine(TypeLeafKind Leaf,
   printTypeIndex("UDT", Line.getUDT());
   printTypeIndex("SourceFile", Line.getSourceFile());
   W.printNumber("LineNumber", Line.getLineNumber());
 }
 
-void CVTypeDumperImpl::visitBuildInfoRecord(TypeLeafKind Leaf,
-                                            BuildInfoRecord &Args) {
+void CVTypeDumperImpl::visitBuildInfo(TypeLeafKind Leaf,
   W.printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
 
   ListScope Arguments(W, "Arguments");
   for (auto Arg : Args.getArgs()) {
     printTypeIndex("ArgType", Arg);
   }
 }
 
W.printFlags("MethodOptions", unsigned(Options),
                  makeArrayRef(MethodOptionNames));
   }
 }
 
 void CVTypeDumperImpl::visitUnknownMember(TypeLeafKind Leaf) {
   W.printHex("UnknownMember", unsigned(Leaf));
 }
 
-void CVTypeDumperImpl::visitNestedTypeRecord(TypeLeafKind Leaf,
-                                             NestedTypeRecord &Nested) {
+void CVTypeDumperImpl::visitNestedType(TypeLeafKind Leaf,
   DictScope S(W, "NestedType");
   printTypeIndex("Type", Nested.getNestedType());
   W.printString("Name", Nested.getName());
   Name = Nested.getName();
 }
 
-void CVTypeDumperImpl::visitOneMethodRecord(TypeLeafKind Leaf,
-                                            OneMethodRecord &Method) {
+void CVTypeDumperImpl::visitOneMethod(TypeLeafKind Leaf,
   DictScope S(W, "OneMethod");
   MethodKind K = Method.getKind();
   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());
   Name = Method.getName();
 }
 
-void CVTypeDumperImpl::visitOverloadedMethodRecord(
-    TypeLeafKind Leaf, OverloadedMethodRecord &Method) {
+void CVTypeDumperImpl::visitOverloadedMethod(TypeLeafKind Leaf,
+                                             OverloadedMethodRecord &Method) {
   DictScope S(W, "OverloadedMethod");
   W.printHex("MethodCount", Method.getNumOverloads());
   printTypeIndex("MethodListIndex", Method.getMethodList());
   W.printString("Name", Method.getName());
   Name = Method.getName();
 }
 
-void CVTypeDumperImpl::visitDataMemberRecord(TypeLeafKind Leaf,
-                                             DataMemberRecord &Field) {
+void CVTypeDumperImpl::visitDataMember(TypeLeafKind Leaf,
   DictScope S(W, "DataMember");
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W.printHex("FieldOffset", Field.getFieldOffset());
   W.printString("Name", Field.getName());
   Name = Field.getName();
 }
 
-void CVTypeDumperImpl::visitStaticDataMemberRecord(
-    TypeLeafKind Leaf, StaticDataMemberRecord &Field) {
+void CVTypeDumperImpl::visitStaticDataMember(TypeLeafKind Leaf,
+                                             StaticDataMemberRecord &Field) {
   DictScope S(W, "StaticDataMember");
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W.printString("Name", Field.getName());
   Name = Field.getName();
 }
 
-void CVTypeDumperImpl::visitVirtualFunctionPointerRecord(
-    TypeLeafKind Leaf, VirtualFunctionPointerRecord &VFTable) {
-  DictScope S(W, "VirtualFunctionPointer");
+void CVTypeDumperImpl::visitVFPtr(TypeLeafKind Leaf, VFPtrRecord &VFTable) {
+  DictScope S(W, "VFPtr");
   printTypeIndex("Type", VFTable.getType());
 }
 
-void CVTypeDumperImpl::visitEnumeratorRecord(TypeLeafKind Leaf,
-                                             EnumeratorRecord &Enum) {
+void CVTypeDumperImpl::visitEnumerator(TypeLeafKind Leaf,
   DictScope S(W, "Enumerator");
   printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   W.printNumber("EnumValue", Enum.getValue());
   W.printString("Name", Enum.getName());
   Name = Enum.getName();
 }
 
-void CVTypeDumperImpl::visitBaseClassRecord(TypeLeafKind Leaf,
-                                            BaseClassRecord &Base) {
+void CVTypeDumperImpl::visitBaseClass(TypeLeafKind Leaf,
   DictScope S(W, "BaseClass");
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   W.printHex("BaseOffset", Base.getBaseOffset());
 }
 
-void CVTypeDumperImpl::visitVirtualBaseClassRecord(
-    TypeLeafKind Leaf, VirtualBaseClassRecord &Base) {
+void CVTypeDumperImpl::visitVirtualBaseClass(TypeLeafKind Leaf,
+                                             VirtualBaseClassRecord &Base) {
   DictScope S(W, "VirtualBaseClass");
   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());
 }

lib/DebugInfo/CodeView/TypeRecordBuilder.cpp

void TypeRecordBuilder::writeEncodedInteger(int64_t Value) {
   } else {
     writeEncodedSignedInteger(Value);
   }
 }
 
 void TypeRecordBuilder::writeEncodedSignedInteger(int64_t Value) {
   if (Value >= std::numeric_limits<int8_t>::min() &&
       Value <= std::numeric_limits<int8_t>::max()) {
-    writeUInt16(static_cast<uint16_t>(TypeRecordKind::SByte));
+    writeUInt16(LF_CHAR);
     writeInt16(static_cast<int8_t>(Value));
   } else if (Value >= std::numeric_limits<int16_t>::min() &&
              Value <= std::numeric_limits<int16_t>::max()) {
-    writeUInt16(static_cast<uint16_t>(TypeRecordKind::Int16));
+    writeUInt16(LF_SHORT);
     writeInt16(static_cast<int16_t>(Value));
   } else if (Value >= std::numeric_limits<int32_t>::min() &&
              Value <= std::numeric_limits<int32_t>::max()) {
-    writeUInt16(static_cast<uint32_t>(TypeRecordKind::Int32));
+    writeUInt16(LF_LONG);
     writeInt32(static_cast<int32_t>(Value));
   } else {
-    writeUInt16(static_cast<uint16_t>(TypeRecordKind::Int64));
+    writeUInt16(LF_QUADWORD);
     writeInt64(Value);
   }
 }
 
 void TypeRecordBuilder::writeEncodedUnsignedInteger(uint64_t Value) {
-  if (Value < static_cast<uint16_t>(TypeRecordKind::SByte)) {
+  if (Value < LF_CHAR) {
     writeUInt16(static_cast<uint16_t>(Value));
   } else if (Value <= std::numeric_limits<uint16_t>::max()) {
-    writeUInt16(static_cast<uint16_t>(TypeRecordKind::UInt16));
+    writeUInt16(LF_USHORT);
     writeUInt16(static_cast<uint16_t>(Value));
   } else if (Value <= std::numeric_limits<uint32_t>::max()) {
-    writeUInt16(static_cast<uint16_t>(TypeRecordKind::UInt32));
+    writeUInt16(LF_ULONG);
     writeUInt32(static_cast<uint32_t>(Value));
   } else {
-    writeUInt16(static_cast<uint16_t>(TypeRecordKind::UInt64));
+    writeUInt16(LF_UQUADWORD);
     writeUInt64(Value);
   }
 }
 
 void TypeRecordBuilder::writeNullTerminatedString(const char *Value) {
   assert(Value != nullptr);
 
   size_t Length = strlen(Value);

lib/DebugInfo/CodeView/TypeTableBuilder.cpp

 using namespace llvm;
 using namespace codeview;
 
 TypeTableBuilder::TypeTableBuilder() {}
 
 TypeTableBuilder::~TypeTableBuilder() {}
 
 TypeIndex TypeTableBuilder::writeModifier(const ModifierRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::Modifier);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getModifiedType());
   Builder.writeUInt16(static_cast<uint16_t>(Record.getModifiers()));
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writeProcedure(const ProcedureRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::Procedure);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getReturnType());
   Builder.writeUInt8(static_cast<uint8_t>(Record.getCallConv()));
   Builder.writeUInt8(static_cast<uint8_t>(Record.getOptions()));
   Builder.writeUInt16(Record.getParameterCount());
   Builder.writeTypeIndex(Record.getArgumentList());
 
   return writeRecord(Builder);
 }
 
 TypeIndex
 TypeTableBuilder::writeMemberFunction(const MemberFunctionRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::MemberFunction);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getReturnType());
   Builder.writeTypeIndex(Record.getClassType());
   Builder.writeTypeIndex(Record.getThisType());
   Builder.writeUInt8(static_cast<uint8_t>(Record.getCallConv()));
   Builder.writeUInt8(static_cast<uint8_t>(Record.getOptions()));
   Builder.writeUInt16(Record.getParameterCount());
   Builder.writeTypeIndex(Record.getArgumentList());
   Builder.writeInt32(Record.getThisPointerAdjustment());
 
   return writeRecord(Builder);
 }
 
-TypeIndex TypeTableBuilder::writeArgumentList(const StringListRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::ArgumentList);
+TypeIndex TypeTableBuilder::writeArgList(const ArgListRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeUInt32(Record.getIndices().size());
   for (TypeIndex TI : Record.getIndices()) {
     Builder.writeTypeIndex(TI);
   }
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writePointer(const PointerRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::Pointer);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getReferentType());
   uint32_t flags = static_cast<uint32_t>(Record.getOptions()) |
                    (Record.getSize() << PointerRecord::PointerSizeShift) |
                    (static_cast<uint32_t>(Record.getMode())
                     << PointerRecord::PointerModeShift) |
                    (static_cast<uint32_t>(Record.getPointerKind())
                     << PointerRecord::PointerKindShift);
   Builder.writeUInt32(flags);
 
   if (Record.isPointerToMember()) {
     const MemberPointerInfo &M = Record.getMemberInfo();
     Builder.writeTypeIndex(M.getContainingType());
     Builder.writeUInt16(static_cast<uint16_t>(M.getRepresentation()));
   }
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writeArray(const ArrayRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::Array);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getElementType());
   Builder.writeTypeIndex(Record.getIndexType());
   Builder.writeEncodedUnsignedInteger(Record.getSize());
   Builder.writeNullTerminatedString(Record.getName());
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writeClass(const ClassRecord &Record) {
-  assert((Record.getKind() == TypeRecordKind::Structure) ||
+  assert((Record.getKind() == TypeRecordKind::Struct) ||
          (Record.getKind() == TypeRecordKind::Class) ||
          (Record.getKind() == TypeRecordKind::Union));
 
   TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeUInt16(Record.getMemberCount());
   uint16_t Flags =
       static_cast<uint16_t>(Record.getOptions()) |
if ((Record.getOptions() & ClassOptions::HasUniqueName) !=
       ClassOptions::None) {
     Builder.writeNullTerminatedString(Record.getUniqueName());
   }
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writeEnum(const EnumRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::Enum);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeUInt16(Record.getMemberCount());
   Builder.writeUInt16(static_cast<uint16_t>(Record.getOptions()));
   Builder.writeTypeIndex(Record.getUnderlyingType());
   Builder.writeTypeIndex(Record.getFieldList());
   Builder.writeNullTerminatedString(Record.getName());
   if ((Record.getOptions() & ClassOptions::HasUniqueName) !=
       ClassOptions::None) {
     Builder.writeNullTerminatedString(Record.getUniqueName());
   }
 
   return writeRecord(Builder);
 }
 
 TypeIndex TypeTableBuilder::writeBitField(const BitFieldRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::BitField);
+  TypeRecordBuilder Builder(Record.getKind());
 
   Builder.writeTypeIndex(Record.getType());
   Builder.writeUInt8(Record.getBitSize());
   Builder.writeUInt8(Record.getBitOffset());
 
   return writeRecord(Builder);
 }
 
-TypeIndex TypeTableBuilder::writeVirtualTableShape(
-    const VirtualTableShapeRecord &Record) {
-  TypeRecordBuilder Builder(TypeRecordKind::VirtualTableShape);
+TypeIndex
+TypeTableBuilder::writeVFTableShape(const VFTableShapeRecord &Record) {
+  TypeRecordBuilder Builder(Record.getKind());
 
-  ArrayRef<VirtualTableSlotKind> Slots = Record.getSlots();
+  ArrayRef<VFTableSlotKind> Slots = Record.getSlots();
 
   Builder.writeUInt16(Slots.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]);
     }
     Builder.writeUInt8(Byte);

test/DebugInfo/COFF/inlining.ll

 
 ; We should only the LF_FUNC_ID records that we needed to reference.
 ; OBJ: CodeViewTypes [
 ; OBJ:   Section: .debug$T (4)
 ; OBJ:   ArgList (0x1000) {
 ; OBJ:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; OBJ:     NumArgs: 0
 ; OBJ:   }
-; OBJ:   ProcedureType (0x1001) {
+; OBJ:   Procedure (0x1001) {
 ; OBJ:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; OBJ:     ReturnType: void (0x3)
 ; OBJ:     NumParameters: 0
 ; OBJ:     ArgListType: () (0x1000)
 ; OBJ:   }
 ; OBJ:   FuncId (0x1002) {
 ; OBJ:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; OBJ:     ParentScope: 0x0

test/tools/llvm-readobj/codeview-vftable.test

 ;     virtual void h();
 ;   };
 ;   A a;
 ;   B b;
 ;   C c;
 
 RUN: llvm-readobj -codeview %p/Inputs/codeview-vftable.obj.coff | FileCheck %s
 
-CHECK:       VFTableType (0x10F0) {
+CHECK:       VFTable (0x10F0) {
 CHECK-NEXT:    TypeLeafKind: LF_VFTABLE (0x151D)
 CHECK-NEXT:    CompleteClass: A
 CHECK-NEXT:    OverriddenVFTable: 0x0
 CHECK-NEXT:    VFPtrOffset: 0x0
 CHECK-NEXT:    VFTableName: ??_7A@@6B@
 CHECK-NEXT:    MethodName: ?f@A@@UEAAXXZ
 CHECK-NEXT:  }
-CHECK-NEXT:  VFTableType (0x10F1) {
+CHECK-NEXT:  VFTable (0x10F1) {
 CHECK-NEXT:    TypeLeafKind: LF_VFTABLE (0x151D)
 CHECK-NEXT:    CompleteClass: B
 CHECK-NEXT:    OverriddenVFTable: ??_7A@@6B@ (0x10F0)
 CHECK-NEXT:    VFPtrOffset: 0x0
 CHECK-NEXT:    VFTableName: ??_7B@@6B@
 CHECK-NEXT:    MethodName: ?f@B@@UEAAXXZ
 CHECK-NEXT:    MethodName: ?g@B@@UEAAXXZ
 CHECK-NEXT:  }
-CHECK-NEXT:  VFTableType (0x10F2) {
+CHECK-NEXT:  VFTable (0x10F2) {
 CHECK-NEXT:    TypeLeafKind: LF_VFTABLE (0x151D)
 CHECK-NEXT:    CompleteClass: C
 CHECK-NEXT:    OverriddenVFTable: ??_7B@@6B@ (0x10F1)
 CHECK-NEXT:    VFPtrOffset: 0x0
 CHECK-NEXT:    VFTableName: ??_7C@@6B@
 CHECK-NEXT:    MethodName: ?f@C@@UEAAXXZ
 CHECK-NEXT:    MethodName: ?g@C@@UEAAXXZ
 CHECK-NEXT:    MethodName: ?h@C@@UEAAXXZ
 CHECK-NEXT:  }