Improving CodeView debug info type record's inline comments

[nilanjana_basu]

Summary

Improved inline comments for the following:

1. Printing names of types (based on type index)
2. Printing all enum names (e.g. for Calling convention, access specifier, method kinds etc)
3. Printing all enabled flag names (e.g. enabled flags for Function options, modifier names, properties, attributes etc )

[nilanjana_basu]

Ran git clang-format

[nilanjana_basu]

1. Added an extra test case for MethodList.
2. Added a more human-readable version of record & member kinds, in addition to their enum names

[rnk]

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

30

Please move these tables to EnumTables.cpp, add getFooNames methods for them to EnumTables.h, and use them here. Otherwise these tables will be duplicated in the final binary.

210

I think most members are very simple, and it would be better to keep the comment on a single line if possible. Something like:
.long ... # Attrs: Public, Virtual, Sealed
.long ... # Attrs: Private, Vanilla
.long ... # Attrs: Public, Vanilla, CompilerGenerated

It's not as explicit as the old comment format, but I think it's better to be more compact.

437

Please avoid computing these expensive strings when type record mapping is not being used in streaming mode. Formatting strings can be quite expensive, but serializing the records should be as fast as possible. When we aren't streaming, the comment can be an empty string or just "Attributes" or "Attrs".

453

I'm also a bit concerned that the vast majority of pointers don't set any of these flags. It would be nice to only mention the flags that are set. You can also look at the code in llvm/tools/llvm-pdbutil/MinimalTypeDumper.cpp, which emits flags like that.

[nilanjana_basu]

Changes made according to review feedback:

1. Moved EnumTables to EnumTables.cpp
2. Made attributes & properties print on the same line, in a more compact form (print only the ones that are enabled, & on the same line. Flags are "|" separated, & enums are comma-separated)
3. Restricted string formatting related computation to Streamer mode

Question: Have been updating the test files manually, so that the difference is clearly visible in the diff. However, because of this it does not take into account a lot of other changes in output, that also should be verified. Do you recommend updating the test files by a direct copy of the ASM?

[nilanjana_basu]

Updated 2 test cases, to match the exact type record directive & comment output, as is emitted with the current code

[rnk]

lgtm, thanks! I think that's everything we need to remove the type dump comment block.

[nilanjana_basu]

Fixed address-sanitizer reported issue of using Stringref to return references to stack memory, which were used later when they were no longer valid.

[rnk]

The code feels very std::string-y now. :) I see two places where StringRef should work and would be more consistent with the rest of LLVM, but other than that I would leave it as you have it.

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

27

I don't think this needs to return std::string, it only return string literals, which live forever.

82

I don't think this needs to return std::string, since it only ever returns constant strings from tables or the empty string.

[rnk]

I see you marked the comments "done", but I don't see a new version of the patch. I'm happy to assume that you made those edits and to approve this to be committed. Ultimately, I have to trust that you commit the same code that is uploaded anyway. :)

[nilanjana_basu]

Changed getLeafTypeName() & getEnumName() return types to StringRef, as per the reviewer comments.

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

 namespace codeview {
 
 class CodeViewRecordStreamer {
 public:
   virtual void EmitBytes(StringRef Data) = 0;
   virtual void EmitIntValue(uint64_t Value, unsigned Size) = 0;
   virtual void EmitBinaryData(StringRef Data) = 0;
   virtual void AddComment(const Twine &T) = 0;
+  virtual bool isVerboseAsm() = 0;
+  virtual StringRef getTypeName(TypeIndex TI) = 0;
   virtual ~CodeViewRecordStreamer() = default;
 };
 
 class CodeViewRecordIO {
   uint32_t getCurrentOffset() const {
     if (isWriting())
       return Writer->getOffset();
     else if (isReading())
private:
   }
 
   void resetStreamedLen() {
     if (isStreaming())
       StreamedLen = 4; // The record prefix is 4 bytes long
   }
 
   void emitComment(const Twine &Comment) {
-    if (isStreaming()) {
+    if (isStreaming() && Streamer->isVerboseAsm()) {
       Twine TComment(Comment);
       if (!TComment.isTriviallyEmpty())
         Streamer->AddComment(TComment);
     }
   }
 
   struct RecordLimit {
     uint32_t BeginOffset;

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 #include <vector>
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 namespace {
 class CVMCAdapter : public CodeViewRecordStreamer {
 public:
-  CVMCAdapter(MCStreamer &OS) : OS(&OS) {}
+  CVMCAdapter(MCStreamer &OS, TypeCollection &TypeTable)
+      : OS(&OS), TypeTable(TypeTable) {}
 
   void EmitBytes(StringRef Data) { OS->EmitBytes(Data); }
 
   void EmitIntValue(uint64_t Value, unsigned Size) {
     OS->EmitIntValueInHex(Value, Size);
   }
 
   void EmitBinaryData(StringRef Data) { OS->EmitBinaryData(Data); }
 
   void AddComment(const Twine &T) { OS->AddComment(T); }
 
+  bool isVerboseAsm() { return OS->isVerboseAsm(); }
+
+  StringRef getTypeName(TypeIndex TI) {
+    StringRef TypeName;
+    if (!TI.isNoneType()) {
+      if (TI.isSimple())
+        TypeName = TypeIndex::simpleTypeName(TI);
+      else
+        TypeName = TypeTable.getTypeName(TI);
+    }
+    return TypeName;
+  }
+
 private:
   MCStreamer *OS = nullptr;
+  TypeCollection &TypeTable;
 };
 } // namespace
 
 static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
   switch (Type) {
   case Triple::ArchType::x86:
     return CPUType::Pentium3;
   case Triple::ArchType::x86_64:
emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S,
   // always be less than 0xF00 (3840) bytes, so truncate the string so that the
   // overall record size is less than the maximum allowed.
   SmallString<32> NullTerminatedString(
       S.take_front(MaxRecordLength - MaxFixedRecordLength - 1));
   NullTerminatedString.push_back('\0');
   OS.EmitBytes(NullTerminatedString);
 }
 
-static StringRef getTypeLeafName(TypeLeafKind TypeKind) {
-  for (const EnumEntry<TypeLeafKind> &EE : getTypeLeafNames())
-    if (EE.Value == TypeKind)
-      return EE.Name;
-  return "";
-}
-
 void CodeViewDebug::emitTypeInformation() {
   if (TypeTable.empty())
     return;
 
   // 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 += ' ';
   }
 
   TypeTableCollection Table(TypeTable.records());
+  TypeVisitorCallbackPipeline Pipeline;
   SmallString<512> CommentBlock;
   raw_svector_ostream CommentOS(CommentBlock);
   std::unique_ptr<ScopedPrinter> SP;
   std::unique_ptr<TypeDumpVisitor> TDV;
-  TypeVisitorCallbackPipeline Pipeline;
 
   if (OS.isVerboseAsm()) {
     // To construct block comment describing the type record for readability.
     SP = llvm::make_unique<ScopedPrinter>(CommentOS);
     SP->setPrefix(CommentPrefix);
     TDV = llvm::make_unique<TypeDumpVisitor>(Table, SP.get(), false);
     Pipeline.addCallbackToPipeline(*TDV);
   }
 
   // To emit type record using Codeview MCStreamer adapter
-  CVMCAdapter CVMCOS(OS);
+  CVMCAdapter CVMCOS(OS, Table);
   TypeRecordMapping typeMapping(CVMCOS);
   Pipeline.addCallbackToPipeline(typeMapping);
 
   Optional<TypeIndex> B = Table.getFirst();
   while (B) {
     // This will fail if the record data is invalid.
     CVType Record = Table.getType(*B);
 
     CommentBlock.clear();
-
-    auto RecordLen = Record.length();
-    auto RecordKind = Record.kind();
-    if (OS.isVerboseAsm())
-      CVMCOS.AddComment("Record length");
-    CVMCOS.EmitIntValue(RecordLen - 2, 2);
-    if (OS.isVerboseAsm())
-      CVMCOS.AddComment("Record kind: " + getTypeLeafName(RecordKind));
-    CVMCOS.EmitIntValue(RecordKind, sizeof(RecordKind));
-
     Error E = codeview::visitTypeRecord(Record, *B, Pipeline);
 
     if (E) {
       logAllUnhandledErrors(std::move(E), errs(), "error: ");
       llvm_unreachable("produced malformed type record");
     }
 
     if (OS.isVerboseAsm()) {

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes,
   if (!isWriting())
     Bytes.assign(BytesRef.begin(), BytesRef.end());
 
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd, const Twine &Comment) {
   if (isStreaming()) {
+    StringRef TypeNameStr = Streamer->getTypeName(TypeInd);
+    if (!TypeNameStr.empty())
+      emitComment(Comment + ": " + TypeNameStr);
+    else
       emitComment(Comment);
     Streamer->EmitIntValue(TypeInd.getIndex(), sizeof(TypeInd.getIndex()));
     incrStreamedLen(sizeof(TypeInd.getIndex()));
   } else if (isWriting()) {
     if (auto EC = Writer->writeInteger(TypeInd.getIndex()))
       return EC;
   } else {
     uint32_t I;
     if (auto EC = Reader->readInteger(I))

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

 //===- TypeRecordMapping.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/DebugInfo/CodeView/EnumTables.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
+namespace {
+
 #define error(X)                                                               \
   if (auto EC = X)                                                             \
     return EC;
 
-namespace {
+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 #ename;
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+  default:
+    break;
+  }
+  return "UnknownLeaf";
+}
+
+template <typename T>
+static bool compEnumNames(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) {
+  return lhs.Name < rhs.Name;
+}
+
+template <typename T, typename TFlag>
+static StringRef getFlagNames(T Value, ArrayRef<EnumEntry<TFlag>> Flags) {
+  typedef EnumEntry<TFlag> FlagEntry;
+  typedef SmallVector<FlagEntry, 10> FlagVector;
+  FlagVector SetFlags;
+  for (const auto &Flag : Flags) {
+    if (Flag.Value == 0)
+      continue;
+    if ((Value & Flag.Value) == Flag.Value) {
+      SetFlags.push_back(Flag);
+    }
+  }
+
+  llvm::sort(SetFlags, &compEnumNames<TFlag>);
+
+  SmallString<128> FlagLabel;
+  for (const auto &Flag : SetFlags)
+    FlagLabel +=
+        ("\t" + Flag.Name + " (0x" + utohexstr(Flag.Value) + ") " + "\n").str();
+
+  if (!FlagLabel.empty()) {
+    SmallString<128> LabelWithBraces("\n[\n");
+    LabelWithBraces += (FlagLabel + "]").str();
+    return LabelWithBraces.str();
+  } else
+    return FlagLabel.str();
+}
+
+template <typename T, typename TEnum>
+static StringRef getEnumName(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
+  StringRef Name;
+  for (const auto &EnumItem : EnumValues) {
+    if (EnumItem.Value == Value) {
+      Name = EnumItem.Name;
+      break;
+    }
+  }
+
+  return Name;
+}
+
+static StringRef getMemberAttributes(MemberAccess Access, MethodKind Kind,
+                                     MethodOptions Options) {
+  SmallString<256> AccessSpecifier =
+      getEnumName(uint8_t(Access), makeArrayRef(MemberAccessNames));
+  SmallString<256> MemberAttrs(
+      ("\n[\n\tAccessSpecifier: " + AccessSpecifier + "\n").str());
+  if (Kind != MethodKind::Vanilla) {
+    SmallString<256> MethodKind =
+        getEnumName(unsigned(Kind), makeArrayRef(MemberKindNames));
+    MemberAttrs += ("\tMethodKind: " + MethodKind + "\n").str();
+  }
+  if (Options != MethodOptions::None) {
+    SmallString<256> MethodOptions =
+        getFlagNames(unsigned(Options), makeArrayRef(MethodOptionNames));
+    MemberAttrs += ("\tMethodOptions" + MethodOptions + "\n").str();
+  }
+  MemberAttrs += "]";
+  return MemberAttrs.str();
+}
+
 struct MapOneMethodRecord {
   explicit MapOneMethodRecord(bool IsFromOverloadList)
       : IsFromOverloadList(IsFromOverloadList) {}
 
   Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {
-    error(IO.mapInteger(Method.Attrs.Attrs, "AccessSpecifier"));
+    StringRef Attrs = getMemberAttributes(
+        Method.getAccess(), Method.getMethodKind(), Method.getOptions());
+    error(IO.mapInteger(Method.Attrs.Attrs, "Attributes" + Attrs));
     if (IsFromOverloadList) {
       uint16_t Padding = 0;
       error(IO.mapInteger(Padding, "Padding"));
     }
     error(IO.mapInteger(Method.Type, "Type"));
     if (Method.isIntroducingVirtual()) {
       error(IO.mapInteger(Method.VFTableOffset, "VFTableOffset"));
     } else if (IO.isReading())
       Method.VFTableOffset = -1;
 
     if (!IsFromOverloadList)
       error(IO.mapStringZ(Method.Name, "Name"));
 
     return Error::success();
   }
 
 private:
   bool IsFromOverloadList;
 };
-}
+} // namespace
 
 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 (IO.isWriting()) {
     error(IO.mapStringZ(Name, "Name"));
     if (HasUniqueName)
       error(IO.mapStringZ(UniqueName, "LinkageName"));
   }
 
   return Error::success();
 }
 
-static StringRef getLeafTypeName(TypeLeafKind LT) {
-  switch (LT) {
-#define TYPE_RECORD(ename, value, name)                                        \
-  case ename:                                                                  \
-    return #ename;
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
-  default:
-    break;
-  }
-  return "UnknownLeaf";
-}
-
 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.kind() != TypeLeafKind::LF_FIELDLIST &&
       CVR.kind() != TypeLeafKind::LF_METHODLIST)
     MaxLen = MaxRecordLength - sizeof(RecordPrefix);
   error(IO.beginRecord(MaxLen));
   TypeKind = CVR.kind();
+
+  if (IO.isStreaming()) {
+    auto RecordKind = CVR.kind();
+    uint16_t RecordLen = CVR.length() - 2;
+    error(IO.mapInteger(RecordLen, "Record length"));
+    error(
+        IO.mapEnum(RecordKind, "Record kind: " + getLeafTypeName(RecordKind)));
+  }
   return Error::success();
 }
 
 Error TypeRecordMapping::visitTypeBegin(CVType &CVR, TypeIndex Index) {
   return visitTypeBegin(CVR);
 }
 
 Error TypeRecordMapping::visitTypeEnd(CVType &Record) {
Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {
   }
 
   MemberKind.reset();
   error(IO.endRecord());
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
+  SmallString<256> ModifierNames = getFlagNames(
+      static_cast<uint16_t>(Record.Modifiers), makeArrayRef(TypeModifierNames));
   error(IO.mapInteger(Record.ModifiedType, "ModifiedType"));
-  error(IO.mapEnum(Record.Modifiers, "Modifiers"));
+  error(IO.mapEnum(Record.Modifiers, "Modifiers" + ModifierNames));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           ProcedureRecord &Record) {
+  SmallString<256> CallinConvName =
+      getEnumName(uint8_t(Record.CallConv), makeArrayRef(CallingConventions));
+  SmallString<256> FuncOptionNames = getFlagNames(
+      static_cast<uint16_t>(Record.Options), makeArrayRef(FunctionOptionEnum));
   error(IO.mapInteger(Record.ReturnType, "ReturnType"));
-  error(IO.mapEnum(Record.CallConv, "CallingConvention"));
-  error(IO.mapEnum(Record.Options, "FunctionOptions"));
+  error(IO.mapEnum(Record.CallConv, "CallingConvention: " + CallinConvName));
+  error(IO.mapEnum(Record.Options, "FunctionOptions" + FuncOptionNames));
   error(IO.mapInteger(Record.ParameterCount, "NumParameters"));
   error(IO.mapInteger(Record.ArgumentList, "ArgListType"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           MemberFunctionRecord &Record) {
+  SmallString<256> CallinConvName =
+      getEnumName(uint8_t(Record.CallConv), makeArrayRef(CallingConventions));
+  SmallString<256> FuncOptionNames = getFlagNames(
+      static_cast<uint16_t>(Record.Options), makeArrayRef(FunctionOptionEnum));
   error(IO.mapInteger(Record.ReturnType, "ReturnType"));
   error(IO.mapInteger(Record.ClassType, "ClassType"));
   error(IO.mapInteger(Record.ThisType, "ThisType"));
-  error(IO.mapEnum(Record.CallConv, "CallingConvention"));
-  error(IO.mapEnum(Record.Options, "FunctionOptions"));
+  error(IO.mapEnum(Record.CallConv, "CallingConvention: " + CallinConvName));
+  error(IO.mapEnum(Record.Options, "FunctionOptions" + FuncOptionNames));
   error(IO.mapInteger(Record.ParameterCount, "NumParameters"));
   error(IO.mapInteger(Record.ArgumentList, "ArgListType"));
   error(IO.mapInteger(Record.ThisPointerAdjustment, "ThisAdjustment"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {
error(IO.mapVectorN<uint32_t>(
         return IO.mapInteger(N, "Strings");
       },
       "NumStrings"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {
+
+  SmallString<512> Attr("Attributes\n");
+  SmallString<256> PtrType = getEnumName(unsigned(Record.getPointerKind()),
+                                         makeArrayRef(PtrKindNames));
+  SmallString<256> PtrMode =
+      getEnumName(unsigned(Record.getMode()), makeArrayRef(PtrModeNames));
+  auto PtrIsFlat = Record.isFlat();
+  auto PtrIsConst = Record.isConst();
+  auto PtrIsVolatile = Record.isVolatile();
+  auto PtrIsUnaligned = Record.isUnaligned();
+  auto PtrIsRestrict = Record.isRestrict();
+  auto PtrIsLValueReferenceThisPtr = Record.isLValueReferenceThisPtr();
+  auto PtrIsRValueReferenceThisPtr = Record.isRValueReferenceThisPtr();
+  auto PtrSizeOf = Record.getSize();
+
   error(IO.mapInteger(Record.ReferentType, "PointeeType"));
-  error(IO.mapInteger(Record.Attrs, "Attributes"));
+
+  Attr += ("[\nPtrType: " + PtrType + "\nPtrMode: " + PtrMode + "\nIsFlat: " +
+           itostr(PtrIsFlat) + "\nIsConst: " + itostr(PtrIsConst) +
+           "\nIsVolatile: " + itostr(PtrIsVolatile) + "\nIsUnaligned: " +
+           itostr(PtrIsUnaligned) + "\nIsRestrict: " + itostr(PtrIsRestrict) +
+           "\nIsThisPtr&: " + itostr(PtrIsLValueReferenceThisPtr) +
+           "\nIsThisPtr&&: " + itostr(PtrIsRValueReferenceThisPtr) +
+           "\nSizeOf: " + itostr(PtrSizeOf) + "\n]")
+              .str();
+  error(IO.mapInteger(Record.Attrs, Attr));
 
   if (Record.isPointerToMember()) {
     if (IO.isReading())
       Record.MemberInfo.emplace();
 
     MemberPointerInfo &M = *Record.MemberInfo;
     error(IO.mapInteger(M.ContainingType, "ClassType"));
-    error(IO.mapEnum(M.Representation, "Representation"));
+    SmallString<256> PtrMemberGetRepresentation = getEnumName(
+        uint16_t(M.Representation), makeArrayRef(PtrMemberRepNames));
+    error(IO.mapEnum(M.Representation,
+                     "Representation: " + PtrMemberGetRepresentation));
   }
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {
   error(IO.mapInteger(Record.ElementType, "ElementType"));
   error(IO.mapInteger(Record.IndexType, "IndexType"));
   error(IO.mapEncodedInteger(Record.Size, "SizeOf"));
   error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ClassRecord &Record) {
   assert((CVR.kind() == TypeLeafKind::LF_STRUCTURE) ||
          (CVR.kind() == TypeLeafKind::LF_CLASS) ||
          (CVR.kind() == TypeLeafKind::LF_INTERFACE));
 
+  SmallString<256> PropertiesNames = getFlagNames(
+      static_cast<uint16_t>(Record.Options), makeArrayRef(ClassOptionNames));
   error(IO.mapInteger(Record.MemberCount, "MemberCount"));
-  error(IO.mapEnum(Record.Options, "Properties"));
+  error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames));
   error(IO.mapInteger(Record.FieldList, "FieldList"));
   error(IO.mapInteger(Record.DerivationList, "DerivedFrom"));
   error(IO.mapInteger(Record.VTableShape, "VShape"));
   error(IO.mapEncodedInteger(Record.Size, "SizeOf"));
   error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
                              Record.hasUniqueName()));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {
+  SmallString<256> PropertiesNames = getFlagNames(
+      static_cast<uint16_t>(Record.Options), makeArrayRef(ClassOptionNames));
   error(IO.mapInteger(Record.MemberCount, "MemberCount"));
-  error(IO.mapEnum(Record.Options, "Properties"));
+  error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames));
   error(IO.mapInteger(Record.FieldList, "FieldList"));
   error(IO.mapEncodedInteger(Record.Size, "SizeOf"));
   error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
                              Record.hasUniqueName()));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {
+  SmallString<256> PropertiesNames = getFlagNames(
+      static_cast<uint16_t>(Record.Options), makeArrayRef(ClassOptionNames));
   error(IO.mapInteger(Record.MemberCount, "NumEnumerators"));
-  error(IO.mapEnum(Record.Options, "Properties"));
+  error(IO.mapEnum(Record.Options, "Properties" + PropertiesNames));
   error(IO.mapInteger(Record.UnderlyingType, "UnderlyingType"));
   error(IO.mapInteger(Record.FieldList, "FieldListType"));
   error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
                              Record.hasUniqueName()));
 
   return Error::success();
 }
 
Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           TypeServer2Record &Record) {
   error(IO.mapGuid(Record.Guid, "Guid"));
   error(IO.mapInteger(Record.Age, "Age"));
   error(IO.mapStringZ(Record.Name, "Name"));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {
-  error(IO.mapEnum(Record.Mode, "Mode"));
+  SmallString<256> ModeName =
+      getEnumName(uint16_t(), makeArrayRef(LabelTypeEnum));
+  error(IO.mapEnum(Record.Mode, "Mode: " + ModeName));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           BaseClassRecord &Record) {
-  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  StringRef Attrs = getMemberAttributes(Record.getAccess(), MethodKind::Vanilla,
+                                        MethodOptions::None);
+  error(IO.mapInteger(Record.Attrs.Attrs, "Attributes" + Attrs));
   error(IO.mapInteger(Record.Type, "BaseType"));
   error(IO.mapEncodedInteger(Record.Offset, "BaseOffset"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           EnumeratorRecord &Record) {
-  error(IO.mapInteger(Record.Attrs.Attrs));
+  StringRef Attrs = getMemberAttributes(Record.getAccess(), MethodKind::Vanilla,
+                                        MethodOptions::None);
+  error(IO.mapInteger(Record.Attrs.Attrs, "Attributes" + Attrs));
 
   // FIXME: Handle full APInt such as __int128.
   error(IO.mapEncodedInteger(Record.Value, "EnumValue"));
   error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           DataMemberRecord &Record) {
-  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  StringRef Attrs = getMemberAttributes(Record.getAccess(), MethodKind::Vanilla,
+                                        MethodOptions::None);
+  error(IO.mapInteger(Record.Attrs.Attrs, "Attributes" + Attrs));
   error(IO.mapInteger(Record.Type, "Type"));
   error(IO.mapEncodedInteger(Record.FieldOffset, "FieldOffset"));
   error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
   error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           StaticDataMemberRecord &Record) {
 
-  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  StringRef Attrs = getMemberAttributes(Record.getAccess(), MethodKind::Vanilla,
+                                        MethodOptions::None);
+  error(IO.mapInteger(Record.Attrs.Attrs, "Attributes" + Attrs));
   error(IO.mapInteger(Record.Type, "Type"));
   error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           VirtualBaseClassRecord &Record) {
 
-  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  StringRef Attrs = getMemberAttributes(Record.getAccess(), MethodKind::Vanilla,
+                                        MethodOptions::None);
+  error(IO.mapInteger(Record.Attrs.Attrs, "Attributes" + Attrs));
   error(IO.mapInteger(Record.BaseType, "BaseType"));
   error(IO.mapInteger(Record.VBPtrType, "VBPtrType"));
   error(IO.mapEncodedInteger(Record.VBPtrOffset, "VBPtrOffset"));
   error(IO.mapEncodedInteger(Record.VTableIndex, "VBTableIndex"));
 
   return Error::success();
 }
 

llvm/test/DebugInfo/COFF/types-basic.ll

 ; CHECK: ]
 
 ; ASM: .section .debug$T,"dr"
 ; ASM: .p2align 2
 ; ASM: .long  4                       # Debug section magic
 ; ASM: .short 0x12                    # Record length
 ; ASM: .short 0x1201                  # Record kind: LF_ARGLIST
 ; ASM: .long  0x3                     # NumArgs
-; ASM: .long  0x40                    # Argument
-; ASM: .long  0x41                    # Argument
-; ASM: .long  0x13                    # Argument
+; ASM: .long  0x40                    # Argument: float
+; ASM: .long  0x41                    # Argument: double
+; ASM: .long  0x13                    # Argument: __int64
 ; ASM: # ArgList (0x1000) {
 ; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
 ; ASM: #   NumArgs: 3
 ; ASM: #   Arguments [
 ; ASM: #     ArgType: float (0x40)
 ; ASM: #     ArgType: double (0x41)
 ; ASM: #     ArgType: __int64 (0x13)
 ; ASM: #   ]
 ; ASM: # }
 ; ASM: .short 0xe                     # Record length
 ; ASM: .short 0x1008                  # Record kind: LF_PROCEDURE
-; ASM: .long  0x3                     # ReturnType
-; ASM: .byte  0x0                     # CallingConvention
+; ASM: .long  0x3                     # ReturnType: void
+; ASM: .byte  0x0                     # CallingConvention: NearC
 ; ASM: .byte  0x0                     # FunctionOptions
 ; ASM: .short 0x3                     # NumParameters
-; ASM: .long  0x1000                  # ArgListType
+; ASM: .long  0x1000                  # ArgListType: (float, double, __int64)
 ; ASM: # Procedure (0x1001) {
 ; ASM: #   TypeLeafKind: LF_PROCEDURE (0x1008)
 ; ASM: #   ReturnType: void (0x3)
 ; ASM: #   CallingConvention: NearC (0x0)
 ; ASM: #   FunctionOptions [ (0x0)
 ; ASM: #   ]
 ; ASM: #   NumParameters: 3
 ; ASM: #   ArgListType: (float, double, __int64) (0x1000)
 ; ASM: # }
 ; ASM: .short 0xe                     # Record length
 ; ASM: .short 0x1601                  # Record kind: LF_FUNC_ID
 ; ASM: .long  0x0                     # ParentScope
-; ASM: .long  0x1001                  # FunctionType
+; ASM: .long  0x1001                  # FunctionType: void (float, double, __int64)
 ; ASM: .asciz "f"                     # Name
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # FuncId (0x1002) {
 ; ASM: #   TypeLeafKind: LF_FUNC_ID (0x1601)
 ; ASM: #   ParentScope: 0x0
 ; ASM: #   FunctionType: void (float, double, __int64) (0x1001)
 ; ASM: #   Name: f
 ; ASM: # }
 ; ASM: .short 0xa                     # Record length
 ; ASM: .short 0x1001                  # Record kind: LF_MODIFIER
-; ASM: .long  0x74                    # ModifiedType
+; ASM: .long  0x74                    # ModifiedType: int
 ; ASM: .short 0x1                     # Modifiers
+; ASM:                                         # [
+; ASM:                                         #  Const (0x1) 
+; ASM:                                         # ]
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # Modifier (0x1003) {
 ; ASM: #   TypeLeafKind: LF_MODIFIER (0x1001)
 ; ASM: #   ModifiedType: int (0x74)
 ; ASM: #   Modifiers [ (0x1)
 ; ASM: #     Const (0x1)
 ; ASM: #   ]
 ; ASM: # }
 ; ASM: .short 0xa                     # Record length
 ; ASM: .short 0x1002                  # Record kind: LF_POINTER
-; ASM: .long  0x1003                  # PointeeType
+; ASM: .long  0x1003                  # PointeeType: const int
 ; ASM: .long  0x1000c                 # Attributes
+; ASM:                                         # [
+; ASM:                                         # PtrType: Near64
+; ASM:                                         # PtrMode: Pointer
+; ASM:                                         # IsFlat: 0
+; ASM:                                         # IsConst: 0
+; ASM:                                         # IsVolatile: 0
+; ASM:                                         # IsUnaligned: 0
+; ASM:                                         # IsRestrict: 0
+; ASM:                                         # IsThisPtr&: 0
+; ASM:                                         # IsThisPtr&&: 0
+; ASM:                                         # SizeOf: 8
+; ASM:                                         # ]
 ; ASM: # Pointer (0x1004) {
 ; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
 ; ASM: #   PointeeType: const int (0x1003)
 ; ASM: #   PtrType: Near64 (0xC)
 ; ASM: #   PtrMode: Pointer (0x0)
 ; ASM: #   IsFlat: 0
 ; ASM: #   IsConst: 0
 ; ASM: #   IsVolatile: 0
 ; ASM: #   IsUnaligned: 0
 ; ASM: #   IsRestrict: 0
 ; ASM: #   IsThisPtr&: 0
 ; ASM: #   IsThisPtr&&: 0
 ; ASM: #   SizeOf: 8
 ; ASM: # }
 ; ASM: .short 0x16                    # Record length
 ; ASM: .short 0x1505                  # Record kind: LF_STRUCTURE
 ; ASM: .short 0x0                     # MemberCount
 ; ASM: .short 0x80                    # Properties
+; ASM:                                         # [
+; ASM:                                         #  ForwardReference (0x80) 
+; ASM:                                         # ]
 ; ASM: .long  0x0                     # FieldList
 ; ASM: .long  0x0                     # DerivedFrom
 ; ASM: .long  0x0                     # VShape
 ; ASM: .short 0x0                     # SizeOf
 ; ASM: .asciz "A"                     # Name
 ; ASM: # Struct (0x1005) {
 ; ASM: #   TypeLeafKind: LF_STRUCTURE (0x1505)
 ; ASM: #   MemberCount: 0
 ; ASM: #   Properties [ (0x80)
 ; ASM: #     ForwardReference (0x80)
 ; ASM: #   ]
 ; ASM: #   FieldList: 0x0
 ; ASM: #   DerivedFrom: 0x0
 ; ASM: #   VShape: 0x0
 ; ASM: #   SizeOf: 0
 ; ASM: #   Name: A
 ; ASM: # }
 ; ASM: .short 0x12                    # Record length
 ; ASM: .short 0x1002                  # Record kind: LF_POINTER
 ; ASM: .long  0x74                    # PointeeType
 ; ASM: .long  0x804c                  # Attributes
-; ASM: .long  0x1005                  # ClassType
-; ASM: .short 0x4                     # Representation
+; ASM:                                         # [
+; ASM:                                         # PtrType: Near64
+; ASM:                                         # PtrMode: PointerToDataMember
+; ASM:                                         # IsFlat: 0
+; ASM:                                         # IsConst: 0
+; ASM:                                         # IsVolatile: 0
+; ASM:                                         # IsUnaligned: 0
+; ASM:                                         # IsRestrict: 0
+; ASM:                                         # IsThisPtr&: 0
+; ASM:                                         # IsThisPtr&&: 0
+; ASM:                                         # SizeOf: 4
+; ASM:                                         # ]
+; ASM: .long  0x1005                  # ClassType: A
+; ASM: .short 0x4                     # Representation: GeneralData
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # Pointer (0x1006) {
 ; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
 ; ASM: #   PointeeType: int (0x74)
 ; ASM: #   PtrType: Near64 (0xC)
 ; ASM: #   PtrMode: PointerToDataMember (0x2)
 ; ASM: #   IsFlat: 0
 ; ASM: #   IsConst: 0
 ; ASM: #   IsVolatile: 0
 ; ASM: #   IsUnaligned: 0
 ; ASM: #   IsRestrict: 0
 ; ASM: #   IsThisPtr&: 0
 ; ASM: #   IsThisPtr&&: 0
 ; ASM: #   SizeOf: 4
 ; ASM: #   ClassType: A (0x1005)
 ; ASM: #   Representation: GeneralData (0x4)
 ; ASM: # }
 ; ASM: .short 0xa                     # Record length
 ; ASM: .short 0x1002                  # Record kind: LF_POINTER
-; ASM: .long  0x1005                  # PointeeType
+; ASM: .long  0x1005                  # PointeeType: A
 ; ASM: .long  0x1040c                 # Attributes
+; ASM:                                         # [
+; ASM:                                         # PtrType: Near64
+; ASM:                                         # PtrMode: Pointer
+; ASM:                                         # IsFlat: 0
+; ASM:                                         # IsConst: 1
+; ASM:                                         # IsVolatile: 0
+; ASM:                                         # IsUnaligned: 0
+; ASM:                                         # IsRestrict: 0
+; ASM:                                         # IsThisPtr&: 0
+; ASM:                                         # IsThisPtr&&: 0
+; ASM:                                         # SizeOf: 8
+; ASM:                                         # ]
 ; ASM: # Pointer (0x1007) {
 ; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
 ; ASM: #   PointeeType: A (0x1005)
 ; ASM: #   PtrType: Near64 (0xC)
 ; ASM: #   PtrMode: Pointer (0x0)
 ; ASM: #   IsFlat: 0
 ; ASM: #   IsConst: 1
 ; ASM: #   IsVolatile: 0

 ; ASM: # ArgList (0x1008) {
 ; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
 ; ASM: #   NumArgs: 0
 ; ASM: #   Arguments [
 ; ASM: #   ]
 ; ASM: # }
 ; ASM: .short 0x1a                    # Record length
 ; ASM: .short 0x1009                  # Record kind: LF_MFUNCTION
-; ASM: .long  0x3                     # ReturnType
-; ASM: .long  0x1005                  # ClassType
-; ASM: .long  0x1007                  # ThisType
-; ASM: .byte  0x0                     # CallingConvention
+; ASM: .long  0x3                     # ReturnType: void
+; ASM: .long  0x1005                  # ClassType: A
+; ASM: .long  0x1007                  # ThisType: A* const
+; ASM: .byte  0x0                     # CallingConvention: NearC
 ; ASM: .byte  0x0                     # FunctionOptions
 ; ASM: .short 0x0                     # NumParameters
-; ASM: .long  0x1008                  # ArgListType
+; ASM: .long  0x1008                  # ArgListType: ()
 ; ASM: .long  0x0                     # ThisAdjustment
 ; ASM: # MemberFunction (0x1009) {
 ; ASM: #   TypeLeafKind: LF_MFUNCTION (0x1009)
 ; ASM: #   ReturnType: void (0x3)
 ; ASM: #   ClassType: A (0x1005)
 ; ASM: #   ThisType: A* const (0x1007)
 ; ASM: #   CallingConvention: NearC (0x0)
 ; ASM: #   FunctionOptions [ (0x0)
 ; ASM: #   ]
 ; ASM: #   NumParameters: 0
 ; ASM: #   ArgListType: () (0x1008)
 ; ASM: #   ThisAdjustment: 0
 ; ASM: # }
 ; ASM: .short 0x1e                    # Record length
 ; ASM: .short 0x1203                  # Record kind: LF_FIELDLIST
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                         # [
+; ASM:                                         #  AccessSpecifier: Public
+; ASM:                                         # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x0                     # FieldOffset
 ; ASM: .asciz "a"                     # Name
 ; ASM: .short 0x1511                  # Member kind: LF_ONEMETHOD
-; ASM: .short 0x3                     # AccessSpecifier
-; ASM: .long  0x1009                  # Type
+; ASM: .short 0x3                     # Attributes
+; ASM:                                         # [
+; ASM:                                         #  AccessSpecifier: Public
+; ASM:                                         # ]
+; ASM: .long  0x1009                  # Type: void A::()
 ; ASM: .asciz "A::f"                  # Name
 ; ASM: .byte  243
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # FieldList (0x100A) {
 ; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
 ; ASM: #   DataMember {
 ; ASM: #     TypeLeafKind: LF_MEMBER (0x150D)
 ; ASM: #     AccessSpecifier: Public (0x3)
 ; ASM: #     Type: int (0x74)
 ; ASM: #     FieldOffset: 0x0
 ; ASM: #     Name: a
 ; ASM: #   }
 ; ASM: #   OneMethod {
 ; ASM: #     TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; ASM: #     AccessSpecifier: Public (0x3)
 ; ASM: #     Type: void A::() (0x1009)
 ; ASM: #     Name: A::f
 ; ASM: #   }
 ; ASM: # }
 ; ASM: .short 0x16                    # Record length
 ; ASM: .short 0x1505                  # Record kind: LF_STRUCTURE
 ; ASM: .short 0x2                     # MemberCount
 ; ASM: .short 0x0                     # Properties
-; ASM: .long  0x100a                  # FieldList
+; ASM: .long  0x100a                  # FieldList: <field list>
 ; ASM: .long  0x0                     # DerivedFrom
 ; ASM: .long  0x0                     # VShape
 ; ASM: .short 0x4                     # SizeOf
 ; ASM: .asciz "A"                     # Name
 ; ASM: # Struct (0x100B) {
 ; ASM: #   TypeLeafKind: LF_STRUCTURE (0x1505)
 ; ASM: #   MemberCount: 2
 ; ASM: #   Properties [ (0x0)

 ; ASM: .asciz "D:\\src\\llvm\\build\\t.cpp" # StringData
 ; ASM: # StringId (0x100C) {
 ; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
 ; ASM: #   Id: 0x0
 ; ASM: #   StringData: D:\src\llvm\build\t.cpp
 ; ASM: # }
 ; ASM: .short 0xe                     # Record length
 ; ASM: .short 0x1606                  # Record kind: LF_UDT_SRC_LINE
-; ASM: .long  0x100b                  # UDT
-; ASM: .long  0x100c                  # SourceFile
+; ASM: .long  0x100b                  # UDT: A
+; ASM: .long  0x100c                  # SourceFile: D:\src\llvm\build\t.cpp
 ; ASM: .long  0x1                     # LineNumber
 ; ASM: # UdtSourceLine (0x100D) {
 ; ASM: #   TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
 ; ASM: #   UDT: A (0x100B)
 ; ASM: #   SourceFile: D:\src\llvm\build\t.cpp (0x100C)
 ; ASM: #   LineNumber: 1
 ; ASM: # }
 ; ASM: .short 0x12                    # Record length
 ; ASM: .short 0x1002                  # Record kind: LF_POINTER
-; ASM: .long  0x1009                  # PointeeType
+; ASM: .long  0x1009                  # PointeeType: void A::()
 ; ASM: .long  0x1006c                 # Attributes
-; ASM: .long  0x1005                  # ClassType
-; ASM: .short 0x8                     # Representation
+; ASM:                                         # [
+; ASM:                                         # PtrType: Near64
+; ASM:                                         # PtrMode: PointerToMemberFunction
+; ASM:                                         # IsFlat: 0
+; ASM:                                         # IsConst: 0
+; ASM:                                         # IsVolatile: 0
+; ASM:                                         # IsUnaligned: 0
+; ASM:                                         # IsRestrict: 0
+; ASM:                                         # IsThisPtr&: 0
+; ASM:                                         # IsThisPtr&&: 0
+; ASM:                                         # SizeOf: 8
+; ASM:                                         # ]
+; ASM: .long  0x1005                  # ClassType: A
+; ASM: .short 0x8                     # Representation: GeneralFunction
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # Pointer (0x100E) {
 ; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
 ; ASM: #   PointeeType: void A::() (0x1009)
 ; ASM: #   PtrType: Near64 (0xC)
 ; ASM: #   PtrMode: PointerToMemberFunction (0x3)
 ; ASM: #   IsFlat: 0
 ; ASM: #   IsConst: 0
 ; ASM: #   IsVolatile: 0
 ; ASM: #   IsUnaligned: 0
 ; ASM: #   IsRestrict: 0
 ; ASM: #   IsThisPtr&: 0
 ; ASM: #   IsThisPtr&&: 0
 ; ASM: #   SizeOf: 8
 ; ASM: #   ClassType: A (0x1005)
 ; ASM: #   Representation: GeneralFunction (0x8)
 ; ASM: # }
 ; ASM: .short 0xa                     # Record length
 ; ASM: .short 0x1001                  # Record kind: LF_MODIFIER
-; ASM: .long  0x3                     # ModifiedType
+; ASM: .long  0x3                     # ModifiedType: void
 ; ASM: .short 0x1                     # Modifiers
+; ASM:                                        # [
+; ASM:                                        #   Const (0x1) 
+; ASM:                                        # ]
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # Modifier (0x100F) {
 ; ASM: #   TypeLeafKind: LF_MODIFIER (0x1001)
 ; ASM: #   ModifiedType: void (0x3)
 ; ASM: #   Modifiers [ (0x1)
 ; ASM: #     Const (0x1)
 ; ASM: #   ]
 ; ASM: # }
 ; ASM: .short 0xa                     # Record length
 ; ASM: .short 0x1002                  # Record kind: LF_POINTER
-; ASM: .long  0x100f                  # PointeeType
+; ASM: .long  0x100f                  # PointeeType: const void
 ; ASM: .long  0x1000c                 # Attributes
+; ASM:                                         # [
+; ASM:                                         # PtrType: Near64
+; ASM:                                         # PtrMode: Pointer
+; ASM:                                         # IsFlat: 0
+; ASM:                                         # IsConst: 0
+; ASM:                                         # IsVolatile: 0
+; ASM:                                         # IsUnaligned: 0
+; ASM:                                         # IsRestrict: 0
+; ASM:                                         # IsThisPtr&: 0
+; ASM:                                         # IsThisPtr&&: 0
+; ASM:                                         # SizeOf: 8
+; ASM:                                         # ]
 ; ASM: # Pointer (0x1010) {
 ; ASM: #   TypeLeafKind: LF_POINTER (0x1002)
 ; ASM: #   PointeeType: const void (0x100F)
 ; ASM: #   PtrType: Near64 (0xC)
 ; ASM: #   PtrMode: Pointer (0x0)
 ; ASM: #   IsFlat: 0
 ; ASM: #   IsConst: 0
 ; ASM: #   IsVolatile: 0
 ; ASM: #   IsUnaligned: 0
 ; ASM: #   IsRestrict: 0
 ; ASM: #   IsThisPtr&: 0
 ; ASM: #   IsThisPtr&&: 0
 ; ASM: #   SizeOf: 8
 ; ASM: # }
 ; ASM: .short 0xe                     # Record length
 ; ASM: .short 0x1008                  # Record kind: LF_PROCEDURE
-; ASM: .long  0x3                     # ReturnType
-; ASM: .byte  0x0                     # CallingConvention
+; ASM: .long  0x3                     # ReturnType: void
+; ASM: .byte  0x0                     # CallingConvention: NearC
 ; ASM: .byte  0x0                     # FunctionOptions
 ; ASM: .short 0x0                     # NumParameters
-; ASM: .long  0x1008                  # ArgListType
+; ASM: .long  0x1008                  # ArgListType: ()
 ; ASM: # Procedure (0x1011) {
 ; ASM: #   TypeLeafKind: LF_PROCEDURE (0x1008)
 ; ASM: #   ReturnType: void (0x3)
 ; ASM: #   CallingConvention: NearC (0x0)
 ; ASM: #   FunctionOptions [ (0x0)
 ; ASM: #   ]
 ; ASM: #   NumParameters: 0
 ; ASM: #   ArgListType: () (0x1008)
 ; ASM: # }
 ; ASM: .short 0x16                    # Record length
 ; ASM: .short 0x1601                  # Record kind: LF_FUNC_ID
 ; ASM: .long  0x0                     # ParentScope
-; ASM: .long  0x1011                  # FunctionType
+; ASM: .long  0x1011                  # FunctionType: void ()
 ; ASM: .asciz "CharTypes"             # Name
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # FuncId (0x1012) {
 ; ASM: #   TypeLeafKind: LF_FUNC_ID (0x1601)
 ; ASM: #   ParentScope: 0x0
 ; ASM: #   FunctionType: void () (0x1011)
 ; ASM: #   Name: CharTypes

 ; ASM: # StringId (0x1014) {
 ; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
 ; ASM: #   Id: 0x0
 ; ASM: #   StringData: t.cpp
 ; ASM: # }
 ; ASM: .short 0x1a                    # Record length
 ; ASM: .short 0x1603                  # Record kind: LF_BUILDINFO
 ; ASM: .short 0x5                     # NumArgs
-; ASM: .long  0x1013                  # Argument
+; ASM: .long  0x1013                  # Argument: D:\src\llvm\build
 ; ASM: .long  0x0                     # Argument
-; ASM: .long  0x1014                  # Argument
+; ASM: .long  0x1014                  # Argument: t.cpp
 ; ASM: .long  0x0                     # Argument
 ; ASM: .long  0x0                     # Argument
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # BuildInfo (0x1015) {
 ; ASM: #   TypeLeafKind: LF_BUILDINFO (0x1603)
 ; ASM: #   NumArgs: 5
 ; ASM: #   Arguments [

llvm/test/DebugInfo/COFF/types-data-members.ll

 ; ASM: #   ModifiedType: int (0x74)
 ; ASM: #   Modifiers [ (0x1)
 ; ASM: #     Const (0x1)
 ; ASM: #   ]
 ; ASM: # }
 ; ASM: .short 0x3e                    # Record length
 ; ASM: .short 0x1203                  # Record kind: LF_FIELDLIST
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x0                     # FieldOffset
 ; ASM: .asciz "s1"                    # Name
 ; ASM: .byte  243
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x4                     # FieldOffset
 ; ASM: .asciz "s2"                    # Name
 ; ASM: .byte  243
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x8                     # FieldOffset
 ; ASM: .asciz "s3"                    # Name
 ; ASM: .byte  243
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: .short 0x150e                  # Member kind: LF_STMEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x1004                  # Type
 ; ASM: .asciz "sdm"                   # Name
 ; ASM: # FieldList (0x1005) {
 ; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
 ; ASM: #   DataMember {
 ; ASM: #     TypeLeafKind: LF_MEMBER (0x150D)
 ; ASM: #     AccessSpecifier: Public (0x3)
 ; ASM: #     Type: int (0x74)

 ; ASM: #   FieldList: 0x0
 ; ASM: #   SizeOf: 0
 ; ASM: #   Name: Union
 ; ASM: #   LinkageName: .?ATUnion@@
 ; ASM: # }
 ; ASM: .short 0x1a                    # Record length
 ; ASM: .short 0x1203                  # Record kind: LF_FIELDLIST
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x0                     # FieldOffset
 ; ASM: .asciz "a"                     # Name
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x40                    # Type
 ; ASM: .short 0x0                     # FieldOffset
 ; ASM: .asciz "b"                     # Name
 ; ASM: # FieldList (0x100A) {
 ; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
 ; ASM: #   DataMember {
 ; ASM: #     TypeLeafKind: LF_MEMBER (0x150D)
 ; ASM: #     AccessSpecifier: Public (0x3)

 ; ASM: #   VShape: 0x0
 ; ASM: #   SizeOf: 0
 ; ASM: #   Name: Class
 ; ASM: #   LinkageName: .?AVClass@@
 ; ASM: # }
 ; ASM: .short 0x32                    # Record length
 ; ASM: .short 0x1203                  # Record kind: LF_FIELDLIST
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x0                     # FieldOffset
 ; ASM: .asciz "pub"                   # Name
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x1                     # AccessSpecifier
+; ASM: .short 0x1                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Private
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x4                     # FieldOffset
 ; ASM: .asciz "priv"                  # Name
 ; ASM: .byte  241
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x2                     # AccessSpecifier
+; ASM: .short 0x2                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Protected
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x8                     # FieldOffset
 ; ASM: .asciz "prot"                  # Name
 ; ASM: .byte  241
 ; ASM: # FieldList (0x100E) {
 ; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
 ; ASM: #   DataMember {
 ; ASM: #     TypeLeafKind: LF_MEMBER (0x150D)

 ; ASM: #   IsRestrict: 0
 ; ASM: #   IsThisPtr&: 0
 ; ASM: #   IsThisPtr&&: 0
 ; ASM: #   SizeOf: 8
 ; ASM: # }
 ; ASM: .short 0x32                    # Record length
 ; ASM: .short 0x1203                  # Record kind: LF_FIELDLIST
 ; ASM: .short 0x1400                  # Member kind: LF_BCLASS
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x1003                  # BaseType
 ; ASM: .short 0x0                     # BaseOffset
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: .short 0x1401                  # Member kind: LF_VBCLASS
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x100d                  # BaseType
 ; ASM: .long  0x1012                  # VBPtrType
 ; ASM: .short 0x0                     # VBPtrOffset
 ; ASM: .short 0x1                     # VBTableIndex
 ; ASM: .short 0x1409                  # Member kind: LF_VFUNCTAB
 ; ASM: .short 0x0                     # Padding
 ; ASM: .long  0x1014                  # Type
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x18                    # FieldOffset
 ; ASM: .asciz "d"                     # Name
 ; ASM: # FieldList (0x1015) {
 ; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
 ; ASM: #   BaseClass {
 ; ASM: #     TypeLeafKind: LF_BCLASS (0x1400)
 ; ASM: #     AccessSpecifier: Public (0x3)

 ; ASM: #   VShape: 0x0
 ; ASM: #   SizeOf: 0
 ; ASM: #   Name: Class::Nested
 ; ASM: #   LinkageName: .?AUNested@Class@@
 ; ASM: # }
 ; ASM: .short 0xe                     # Record length
 ; ASM: .short 0x1203                  # Record kind: LF_FIELDLIST
 ; ASM: .short 0x150d                  # Member kind: LF_MEMBER
-; ASM: .short 0x3                     # AccessSpecifier
+; ASM: .short 0x3                     # Attributes
+; ASM:                                        # [
+; ASM:                                        #   AccessSpecifier: Public
+; ASM:                                        # ]
 ; ASM: .long  0x74                    # Type
 ; ASM: .short 0x0                     # FieldOffset
 ; ASM: .asciz "n"                     # Name
 ; ASM: # FieldList (0x1019) {
 ; ASM: #   TypeLeafKind: LF_FIELDLIST (0x1203)
 ; ASM: #   DataMember {
 ; ASM: #     TypeLeafKind: LF_MEMBER (0x150D)
 ; ASM: #     AccessSpecifier: Public (0x3)
 ; ASM: #     Type: int (0x74)
 ; ASM: #     FieldOffset: 0x0
 ; ASM: #     Name: n
 ; ASM: #   }
 ; ASM: # }
 ; ASM: .short 0x36                    # Record length
 ; ASM: .short 0x1505                  # Record kind: LF_STRUCTURE
 ; ASM: .short 0x1                     # MemberCount
 ; ASM: .short 0x208                   # Properties
+; ASM:                                         # [
+; ASM:                                         #  HasUniqueName (0x200) 
+; ASM:                                         #  Nested (0x8) 
+; ASM:                                         # ]
 ; ASM: .long  0x1019                  # FieldList
 ; ASM: .long  0x0                     # DerivedFrom
 ; ASM: .long  0x0                     # VShape
 ; ASM: .short 0x4                     # SizeOf
 ; ASM: .asciz "Class::Nested"         # Name
 ; ASM: .asciz ".?AUNested@Class@@"    # LinkageName
 ; ASM: .byte  241
 ; ASM: # Struct (0x101A) {