Adding inline comments to code view type records

[nilanjana_basu]

Summary

Code view debug info type records are emitted as a set of directives. Comments describing these records were previously emitted all together for each record at the end of the record. With this change, every directive representing a sub-field of a type record is augmented with a comment describing the sub field.

[rnk]

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

63

Is it possible to change these all to accept const Twine &Comment = ""? I think string literals are meant to be implicitly convertible to Twine.

Generally in LLVM StringRef is preferred over const char *. We have some documentation for this here:
https://llvm.org/docs/ProgrammersManual.html#passing-strings-the-stringref-and-twine-classes

I think for this API where the string length is unlikely to be used at all, Twine makes sense, but across LLVM C strings are generally avoided if possible.

[nilanjana_basu]

String parameter passing is done using Twine instead of using C strings, as suggested in the review

[nilanjana_basu]

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

63

Got it. Have made the changes & updated the patch.

[nilanjana_basu]

Corrected comments for codeview type record from "NumAttributes" to "AccessSpecifier"

[nilanjana_basu]

Added record kind name in the comments for better readability

[rnk]

lgtm, sorry this fell out of my inbox.

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 ~CodeViewRecordStreamer() = default;
 };
 
 class CodeViewRecordIO {
   uint32_t getCurrentOffset() const {
     if (isWriting())
       return Writer->getOffset();
     else if (isReading())
public:
 
   // writes records to assembly file using MC library interface
   explicit CodeViewRecordIO(CodeViewRecordStreamer &Streamer)
       : Streamer(&Streamer) {}
 
   Error beginRecord(Optional<uint32_t> MaxLength);
   Error endRecord();
 
-  Error mapInteger(TypeIndex &TypeInd);
+  Error mapInteger(TypeIndex &TypeInd, const Twine &Comment = "");
 
   bool isStreaming() const {
     return (Streamer != nullptr) && (Reader == nullptr) && (Writer == nullptr);
   }
   bool isReading() const {
     return (Reader != nullptr) && (Streamer == nullptr) && (Writer == nullptr);
   }
   bool isWriting() const {
template <typename T> Error mapObject(T &Value) {
 
     const T *ValuePtr;
     if (auto EC = Reader->readObject(ValuePtr))
       return EC;
     Value = *ValuePtr;
     return Error::success();
   }
 
-  template <typename T> Error mapInteger(T &Value) {
+  template <typename T> Error mapInteger(T &Value, const Twine &Comment = "") {
     if (isStreaming()) {
+      emitComment(Comment);
       Streamer->EmitIntValue((int)Value, sizeof(T));
       incrStreamedLen(sizeof(T));
       return Error::success();
     }
 
     if (isWriting())
       return Writer->writeInteger(Value);
 
     return Reader->readInteger(Value);
   }
 
-  template <typename T> Error mapEnum(T &Value) {
+  template <typename T> Error mapEnum(T &Value, const Twine &Comment = "") {
     if (!isStreaming() && sizeof(Value) > maxFieldLength())
       return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 
     using U = typename std::underlying_type<T>::type;
     U X;
 
     if (isWriting() || isStreaming())
       X = static_cast<U>(Value);
 
-    if (auto EC = mapInteger(X))
+    if (auto EC = mapInteger(X, Comment))
       return EC;
 
     if (isReading())
       Value = static_cast<T>(X);
 
     return Error::success();
   }
 
-  Error mapEncodedInteger(int64_t &Value);
-  Error mapEncodedInteger(uint64_t &Value);
-  Error mapEncodedInteger(APSInt &Value);
-  Error mapStringZ(StringRef &Value);
-  Error mapGuid(GUID &Guid);
+  Error mapEncodedInteger(int64_t &Value, const Twine &Comment = "");
+  Error mapEncodedInteger(uint64_t &Value, const Twine &Comment = "");
+  Error mapEncodedInteger(APSInt &Value, const Twine &Comment = "");
+  Error mapStringZ(StringRef &Value, const Twine &Comment = "");
+  Error mapGuid(GUID &Guid, const Twine &Comment = "");
 
-  Error mapStringZVectorZ(std::vector<StringRef> &Value);
+  Error mapStringZVectorZ(std::vector<StringRef> &Value,
+                          const Twine &Comment = "");
 
   template <typename SizeType, typename T, typename ElementMapper>
-  Error mapVectorN(T &Items, const ElementMapper &Mapper) {
+  Error mapVectorN(T &Items, const ElementMapper &Mapper,
+                   const Twine &Comment = "") {
     SizeType Size;
     if (isStreaming()) {
       Size = static_cast<SizeType>(Items.size());
+      emitComment(Comment);
       Streamer->EmitIntValue(Size, sizeof(Size));
       incrStreamedLen(sizeof(Size)); // add 1 for the delimiter
 
       for (auto &X : Items) {
         if (auto EC = Mapper(*this, X))
           return EC;
       }
     } else if (isWriting()) {
if (isStreaming()) {
         Items.push_back(Item);
       }
     }
 
     return Error::success();
   }
 
   template <typename T, typename ElementMapper>
-  Error mapVectorTail(T &Items, const ElementMapper &Mapper) {
+  Error mapVectorTail(T &Items, const ElementMapper &Mapper,
+                      const Twine &Comment = "") {
+    emitComment(Comment);
     if (isStreaming() || isWriting()) {
       for (auto &Item : Items) {
         if (auto EC = Mapper(*this, Item))
           return EC;
       }
     } else {
       typename T::value_type Field;
       // Stop when we run out of bytes or we hit record padding bytes.
       while (!Reader->empty() && Reader->peek() < 0xf0 /* LF_PAD0 */) {
         if (auto EC = Mapper(*this, Field))
           return EC;
         Items.push_back(Field);
       }
     }
     return Error::success();
   }
 
-  Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes);
-  Error mapByteVectorTail(std::vector<uint8_t> &Bytes);
+  Error mapByteVectorTail(ArrayRef<uint8_t> &Bytes, const Twine &Comment = "");
+  Error mapByteVectorTail(std::vector<uint8_t> &Bytes,
+                          const Twine &Comment = "");
 
   Error padToAlignment(uint32_t Align);
   Error skipPadding();
 
   uint64_t getStreamedLen() {
     if (isStreaming())
       return StreamedLen;
     return 0;
   }
 
 private:
-  void emitEncodedSignedInteger(const int64_t &Value);
-  void emitEncodedUnsignedInteger(const uint64_t &Value);
+  void emitEncodedSignedInteger(const int64_t &Value,
+                                const Twine &Comment = "");
+  void emitEncodedUnsignedInteger(const uint64_t &Value,
+                                  const Twine &Comment = "");
   Error writeEncodedSignedInteger(const int64_t &Value);
   Error writeEncodedUnsignedInteger(const uint64_t &Value);
 
   void incrStreamedLen(const uint64_t &Len) {
     if (isStreaming())
       StreamedLen += Len;
   }
 
   void resetStreamedLen() {
     if (isStreaming())
       StreamedLen = 4; // The record prefix is 4 bytes long
   }
 
+  void emitComment(const Twine &Comment) {
+    if (isStreaming()) {
+      Twine TComment(Comment);
+      Streamer->AddComment(TComment);
+    }
+  }
+
   struct RecordLimit {
     uint32_t BeginOffset;
     Optional<uint32_t> MaxLength;
 
     Optional<uint32_t> bytesRemaining(uint32_t CurrentOffset) const {
       if (!MaxLength.hasValue())
         return None;
       assert(CurrentOffset >= BeginOffset);

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

public:
   void EmitBytes(StringRef Data) { OS->EmitBytes(Data); }
 
   void EmitIntValue(uint64_t Value, unsigned Size) {
     OS->EmitIntValue(Value, Size);
   }
 
   void EmitBinaryData(StringRef Data) { OS->EmitBinaryData(Data); }
 
+  void AddComment(const Twine &T) { OS->AddComment(T); }
+
 private:
   MCStreamer *OS = nullptr;
 };
 } // namespace
 
 static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
   switch (Type) {
   case Triple::ArchType::x86:
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();
 
void CodeViewDebug::emitTypeInformation() {
   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();
-    OS.EmitIntValue(RecordLen - 2, 2);
-    OS.EmitIntValue(RecordKind, sizeof(RecordKind));
+    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");
     }
 

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

Error CodeViewRecordIO::skipPadding() {
   if (Leaf < LF_PAD0)
     return Error::success();
   // Leaf is greater than 0xf0. We should advance by the number of bytes in
   // the low 4 bits.
   unsigned BytesToAdvance = Leaf & 0x0F;
   return Reader->skip(BytesToAdvance);
 }
 
-Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes) {
+Error CodeViewRecordIO::mapByteVectorTail(ArrayRef<uint8_t> &Bytes,
+                                          const Twine &Comment) {
   if (isStreaming()) {
+    emitComment(Comment);
     Streamer->EmitBinaryData(toStringRef(Bytes));
     incrStreamedLen(Bytes.size());
   } else if (isWriting()) {
     if (auto EC = Writer->writeBytes(Bytes))
       return EC;
   } else {
     if (auto EC = Reader->readBytes(Bytes, Reader->bytesRemaining()))
       return EC;
   }
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes) {
+Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes,
+                                          const Twine &Comment) {
   ArrayRef<uint8_t> BytesRef(Bytes);
-  if (auto EC = mapByteVectorTail(BytesRef))
+  if (auto EC = mapByteVectorTail(BytesRef, Comment))
     return EC;
   if (!isWriting())
     Bytes.assign(BytesRef.begin(), BytesRef.end());
 
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd) {
+Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd, const Twine &Comment) {
   if (isStreaming()) {
+    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))
       return EC;
     TypeInd.setIndex(I);
   }
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value) {
+Error CodeViewRecordIO::mapEncodedInteger(int64_t &Value,
+                                          const Twine &Comment) {
   if (isStreaming()) {
     if (Value >= 0)
-      emitEncodedUnsignedInteger(static_cast<uint64_t>(Value));
+      emitEncodedUnsignedInteger(static_cast<uint64_t>(Value), Comment);
     else
-      emitEncodedSignedInteger(Value);
+      emitEncodedSignedInteger(Value, Comment);
   } else if (isWriting()) {
     if (Value >= 0) {
       if (auto EC = writeEncodedUnsignedInteger(static_cast<uint64_t>(Value)))
         return EC;
     } else {
       if (auto EC = writeEncodedSignedInteger(Value))
         return EC;
     }
   } else {
     APSInt N;
     if (auto EC = consume(*Reader, N))
       return EC;
     Value = N.getExtValue();
   }
 
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value) {
+Error CodeViewRecordIO::mapEncodedInteger(uint64_t &Value,
+                                          const Twine &Comment) {
   if (isStreaming())
-    emitEncodedUnsignedInteger(Value);
+    emitEncodedUnsignedInteger(Value, Comment);
   else if (isWriting()) {
     if (auto EC = writeEncodedUnsignedInteger(Value))
       return EC;
   } else {
     APSInt N;
     if (auto EC = consume(*Reader, N))
       return EC;
     Value = N.getZExtValue();
   }
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value) {
+Error CodeViewRecordIO::mapEncodedInteger(APSInt &Value, const Twine &Comment) {
   if (isStreaming()) {
     if (Value.isSigned())
-      emitEncodedSignedInteger(Value.getSExtValue());
+      emitEncodedSignedInteger(Value.getSExtValue(), Comment);
     else
-      emitEncodedUnsignedInteger(Value.getZExtValue());
+      emitEncodedUnsignedInteger(Value.getZExtValue(), Comment);
   } else if (isWriting()) {
     if (Value.isSigned())
       return writeEncodedSignedInteger(Value.getSExtValue());
     return writeEncodedUnsignedInteger(Value.getZExtValue());
   } else
     return consume(*Reader, Value);
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapStringZ(StringRef &Value) {
+Error CodeViewRecordIO::mapStringZ(StringRef &Value, const Twine &Comment) {
   if (isStreaming()) {
     auto NullTerminatedString = StringRef(Value.data(), Value.size() + 1);
+    emitComment(Comment);
     Streamer->EmitBytes(NullTerminatedString);
     incrStreamedLen(NullTerminatedString.size());
   } else if (isWriting()) {
     // Truncate if we attempt to write too much.
     StringRef S = Value.take_front(maxFieldLength() - 1);
     if (auto EC = Writer->writeCString(S))
       return EC;
   } else {
     if (auto EC = Reader->readCString(Value))
       return EC;
   }
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapGuid(GUID &Guid) {
+Error CodeViewRecordIO::mapGuid(GUID &Guid, const Twine &Comment) {
   constexpr uint32_t GuidSize = 16;
 
   if (isStreaming()) {
     StringRef GuidSR =
         StringRef((reinterpret_cast<const char *>(&Guid)), GuidSize);
+    emitComment(Comment);
     Streamer->EmitBytes(GuidSR);
     incrStreamedLen(GuidSize);
     return Error::success();
   }
 
   if (maxFieldLength() < GuidSize)
     return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 
   if (isWriting()) {
     if (auto EC = Writer->writeBytes(Guid.Guid))
       return EC;
   } else {
     ArrayRef<uint8_t> GuidBytes;
     if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
       return EC;
     memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
   }
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) {
+Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value,
+                                          const Twine &Comment) {
 
   if (!isReading()) {
+    emitComment(Comment);
     for (auto V : Value) {
       if (auto EC = mapStringZ(V))
         return EC;
     }
     uint8_t FinalZero = 0;
     if (auto EC = mapInteger(FinalZero))
       return EC;
   } else {
     StringRef S;
     if (auto EC = mapStringZ(S))
       return EC;
     while (!S.empty()) {
       Value.push_back(S);
       if (auto EC = mapStringZ(S))
         return EC;
     };
   }
   return Error::success();
 }
 
-void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value) {
+void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value,
+                                                const Twine &Comment) {
   assert(Value < 0 && "Encoded integer is not signed!");
   if (Value >= std::numeric_limits<int8_t>::min()) {
     Streamer->EmitIntValue(LF_CHAR, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 1);
     incrStreamedLen(3);
   } else if (Value >= std::numeric_limits<int16_t>::min()) {
     Streamer->EmitIntValue(LF_SHORT, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 2);
     incrStreamedLen(4);
   } else if (Value >= std::numeric_limits<int32_t>::min()) {
     Streamer->EmitIntValue(LF_LONG, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 4);
     incrStreamedLen(6);
   } else {
     Streamer->EmitIntValue(LF_QUADWORD, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 4);
     incrStreamedLen(6);
   }
 }
 
-void CodeViewRecordIO::emitEncodedUnsignedInteger(const uint64_t &Value) {
+void CodeViewRecordIO::emitEncodedUnsignedInteger(const uint64_t &Value,
+                                                  const Twine &Comment) {
   if (Value < LF_NUMERIC) {
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 2);
     incrStreamedLen(2);
   } else if (Value <= std::numeric_limits<uint16_t>::max()) {
     Streamer->EmitIntValue(LF_USHORT, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 2);
     incrStreamedLen(4);
   } else if (Value <= std::numeric_limits<uint32_t>::max()) {
     Streamer->EmitIntValue(LF_ULONG, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 4);
     incrStreamedLen(6);
   } else {
     Streamer->EmitIntValue(LF_UQUADWORD, 2);
+    emitComment(Comment);
     Streamer->EmitIntValue(Value, 8);
     incrStreamedLen(6);
   }
 }
 
 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
   assert(Value < 0 && "Encoded integer is not signed!");
   if (Value >= std::numeric_limits<int8_t>::min()) {

llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp

if (auto EC = X)                                                             \
     return EC;
 
 namespace {
 struct MapOneMethodRecord {
   explicit MapOneMethodRecord(bool IsFromOverloadList)
       : IsFromOverloadList(IsFromOverloadList) {}
 
   Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {
-    error(IO.mapInteger(Method.Attrs.Attrs));
+    error(IO.mapInteger(Method.Attrs.Attrs, "AccessSpecifier"));
     if (IsFromOverloadList) {
       uint16_t Padding = 0;
-      error(IO.mapInteger(Padding));
+      error(IO.mapInteger(Padding, "Padding"));
     }
-    error(IO.mapInteger(Method.Type));
+    error(IO.mapInteger(Method.Type, "Type"));
     if (Method.isIntroducingVirtual()) {
-      error(IO.mapInteger(Method.VFTableOffset));
+      error(IO.mapInteger(Method.VFTableOffset, "VFTableOffset"));
     } else if (IO.isReading())
       Method.VFTableOffset = -1;
 
     if (!IsFromOverloadList)
-      error(IO.mapStringZ(Method.Name));
+      error(IO.mapStringZ(Method.Name, "Name"));
 
     return Error::success();
   }
 
 private:
   bool IsFromOverloadList;
 };
 }
if (HasUniqueName) {
       // plus one for the required null terminator.
       auto N = StringRef(Name).take_front(BytesLeft - 1);
       error(IO.mapStringZ(N));
     }
   } else {
     // Reading & Streaming mode come after writing mode is executed for each
     // record. Truncating large names are done during writing, so its not
     // necessary to do it while reading or streaming.
-    error(IO.mapStringZ(Name));
+    error(IO.mapStringZ(Name, "Name"));
     if (HasUniqueName)
-      error(IO.mapStringZ(UniqueName));
+      error(IO.mapStringZ(UniqueName, "LinkageName"));
   }
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {
   assert(!TypeKind.hasValue() && "Already in a type mapping!");
   assert(!MemberKind.hasValue() && "Already in a member mapping!");
Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {
   }
 
   MemberKind.reset();
   error(IO.endRecord());
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
-  error(IO.mapInteger(Record.ModifiedType));
-  error(IO.mapEnum(Record.Modifiers));
+  error(IO.mapInteger(Record.ModifiedType, "ModifiedType"));
+  error(IO.mapEnum(Record.Modifiers, "Modifiers"));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           ProcedureRecord &Record) {
-  error(IO.mapInteger(Record.ReturnType));
-  error(IO.mapEnum(Record.CallConv));
-  error(IO.mapEnum(Record.Options));
-  error(IO.mapInteger(Record.ParameterCount));
-  error(IO.mapInteger(Record.ArgumentList));
+  error(IO.mapInteger(Record.ReturnType, "ReturnType"));
+  error(IO.mapEnum(Record.CallConv, "CallingConvention"));
+  error(IO.mapEnum(Record.Options, "FunctionOptions"));
+  error(IO.mapInteger(Record.ParameterCount, "NumParameters"));
+  error(IO.mapInteger(Record.ArgumentList, "ArgListType"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           MemberFunctionRecord &Record) {
-  error(IO.mapInteger(Record.ReturnType));
-  error(IO.mapInteger(Record.ClassType));
-  error(IO.mapInteger(Record.ThisType));
-  error(IO.mapEnum(Record.CallConv));
-  error(IO.mapEnum(Record.Options));
-  error(IO.mapInteger(Record.ParameterCount));
-  error(IO.mapInteger(Record.ArgumentList));
-  error(IO.mapInteger(Record.ThisPointerAdjustment));
+  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.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>(
       Record.ArgIndices,
-      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
+      [](CodeViewRecordIO &IO, TypeIndex &N) {
+        return IO.mapInteger(N, "Argument");
+      },
+      "NumArgs"));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           StringListRecord &Record) {
   error(IO.mapVectorN<uint32_t>(
       Record.StringIndices,
-      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
+      [](CodeViewRecordIO &IO, TypeIndex &N) {
+        return IO.mapInteger(N, "Strings");
+      },
+      "NumStrings"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {
-  error(IO.mapInteger(Record.ReferentType));
-  error(IO.mapInteger(Record.Attrs));
+  error(IO.mapInteger(Record.ReferentType, "PointeeType"));
+  error(IO.mapInteger(Record.Attrs, "Attributes"));
 
   if (Record.isPointerToMember()) {
     if (IO.isReading())
       Record.MemberInfo.emplace();
 
     MemberPointerInfo &M = *Record.MemberInfo;
-    error(IO.mapInteger(M.ContainingType));
-    error(IO.mapEnum(M.Representation));
+    error(IO.mapInteger(M.ContainingType, "ClassType"));
+    error(IO.mapEnum(M.Representation, "Representation"));
   }
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {
-  error(IO.mapInteger(Record.ElementType));
-  error(IO.mapInteger(Record.IndexType));
-  error(IO.mapEncodedInteger(Record.Size));
-  error(IO.mapStringZ(Record.Name));
+  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));
 
-  error(IO.mapInteger(Record.MemberCount));
-  error(IO.mapEnum(Record.Options));
-  error(IO.mapInteger(Record.FieldList));
-  error(IO.mapInteger(Record.DerivationList));
-  error(IO.mapInteger(Record.VTableShape));
-  error(IO.mapEncodedInteger(Record.Size));
+  error(IO.mapInteger(Record.MemberCount, "MemberCount"));
+  error(IO.mapEnum(Record.Options, "Properties"));
+  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) {
-  error(IO.mapInteger(Record.MemberCount));
-  error(IO.mapEnum(Record.Options));
-  error(IO.mapInteger(Record.FieldList));
-  error(IO.mapEncodedInteger(Record.Size));
+  error(IO.mapInteger(Record.MemberCount, "MemberCount"));
+  error(IO.mapEnum(Record.Options, "Properties"));
+  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) {
-  error(IO.mapInteger(Record.MemberCount));
-  error(IO.mapEnum(Record.Options));
-  error(IO.mapInteger(Record.UnderlyingType));
-  error(IO.mapInteger(Record.FieldList));
+  error(IO.mapInteger(Record.MemberCount, "NumEnumerators"));
+  error(IO.mapEnum(Record.Options, "Properties"));
+  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, BitFieldRecord &Record) {
-  error(IO.mapInteger(Record.Type));
-  error(IO.mapInteger(Record.BitSize));
-  error(IO.mapInteger(Record.BitOffset));
+  error(IO.mapInteger(Record.Type, "Type"));
+  error(IO.mapInteger(Record.BitSize, "BitSize"));
+  error(IO.mapInteger(Record.BitOffset, "BitOffset"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           VFTableShapeRecord &Record) {
   uint16_t Size;
   if (!IO.isReading()) {
     ArrayRef<VFTableSlotKind> Slots = Record.getSlots();
     Size = Slots.size();
-    error(IO.mapInteger(Size));
+    error(IO.mapInteger(Size, "VFEntryCount"));
 
     for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {
       uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;
       if ((SlotIndex + 1) < Slots.size()) {
         Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);
       }
       error(IO.mapInteger(Byte));
     }
   } else {
     error(IO.mapInteger(Size));
     for (uint16_t I = 0; I < Size; I += 2) {
       uint8_t Byte;
       error(IO.mapInteger(Byte));
       Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));
       if ((I + 1) < Size)
         Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));
     }
   }
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {
-  error(IO.mapInteger(Record.CompleteClass));
-  error(IO.mapInteger(Record.OverriddenVFTable));
-  error(IO.mapInteger(Record.VFPtrOffset));
+  error(IO.mapInteger(Record.CompleteClass, "CompleteClass"));
+  error(IO.mapInteger(Record.OverriddenVFTable, "OverriddenVFTable"));
+  error(IO.mapInteger(Record.VFPtrOffset, "VFPtrOffset"));
   uint32_t NamesLen = 0;
   if (!IO.isReading()) {
     for (auto Name : Record.MethodNames)
       NamesLen += Name.size() + 1;
   }
-  error(IO.mapInteger(NamesLen));
+  error(IO.mapInteger(NamesLen, ""));
   error(IO.mapVectorTail(
       Record.MethodNames,
-      [](CodeViewRecordIO &IO, StringRef &S) { return IO.mapStringZ(S); }));
+      [](CodeViewRecordIO &IO, StringRef &S) {
+        return IO.mapStringZ(S, "MethodName");
+      },
+      "VFTableName"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {
-  error(IO.mapInteger(Record.Id));
-  error(IO.mapStringZ(Record.String));
+  error(IO.mapInteger(Record.Id, "Id"));
+  error(IO.mapStringZ(Record.String, "StringData"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           UdtSourceLineRecord &Record) {
-  error(IO.mapInteger(Record.UDT));
-  error(IO.mapInteger(Record.SourceFile));
-  error(IO.mapInteger(Record.LineNumber));
+  error(IO.mapInteger(Record.UDT, "UDT"));
+  error(IO.mapInteger(Record.SourceFile, "SourceFile"));
+  error(IO.mapInteger(Record.LineNumber, "LineNumber"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           UdtModSourceLineRecord &Record) {
-  error(IO.mapInteger(Record.UDT));
-  error(IO.mapInteger(Record.SourceFile));
-  error(IO.mapInteger(Record.LineNumber));
-  error(IO.mapInteger(Record.Module));
+  error(IO.mapInteger(Record.UDT, "UDT"));
+  error(IO.mapInteger(Record.SourceFile, "SourceFile"));
+  error(IO.mapInteger(Record.LineNumber, "LineNumber"));
+  error(IO.mapInteger(Record.Module, "Module"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR, FuncIdRecord &Record) {
-  error(IO.mapInteger(Record.ParentScope));
-  error(IO.mapInteger(Record.FunctionType));
-  error(IO.mapStringZ(Record.Name));
+  error(IO.mapInteger(Record.ParentScope, "ParentScope"));
+  error(IO.mapInteger(Record.FunctionType, "FunctionType"));
+  error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           MemberFuncIdRecord &Record) {
-  error(IO.mapInteger(Record.ClassType));
-  error(IO.mapInteger(Record.FunctionType));
-  error(IO.mapStringZ(Record.Name));
+  error(IO.mapInteger(Record.ClassType, "ClassType"));
+  error(IO.mapInteger(Record.FunctionType, "FunctionType"));
+  error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           BuildInfoRecord &Record) {
   error(IO.mapVectorN<uint16_t>(
       Record.ArgIndices,
-      [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
+      [](CodeViewRecordIO &IO, TypeIndex &N) {
+        return IO.mapInteger(N, "Argument");
+      },
+      "NumArgs"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           MethodOverloadListRecord &Record) {
   // TODO: Split the list into multiple records if it's longer than 64KB, using
   // a subrecord of TypeRecordKind::Index to chain the records together.
-  error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true)));
+  error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true), "Method"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           FieldListRecord &Record) {
   error(IO.mapByteVectorTail(Record.Data));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           TypeServer2Record &Record) {
-  error(IO.mapGuid(Record.Guid));
-  error(IO.mapInteger(Record.Age));
-  error(IO.mapStringZ(Record.Name));
+  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));
+  error(IO.mapEnum(Record.Mode, "Mode"));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           BaseClassRecord &Record) {
-  error(IO.mapInteger(Record.Attrs.Attrs));
-  error(IO.mapInteger(Record.Type));
-  error(IO.mapEncodedInteger(Record.Offset));
+  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  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));
 
   // FIXME: Handle full APInt such as __int128.
-  error(IO.mapEncodedInteger(Record.Value));
-  error(IO.mapStringZ(Record.Name));
+  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));
-  error(IO.mapInteger(Record.Type));
-  error(IO.mapEncodedInteger(Record.FieldOffset));
-  error(IO.mapStringZ(Record.Name));
+  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  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,
                                           OverloadedMethodRecord &Record) {
-  error(IO.mapInteger(Record.NumOverloads));
-  error(IO.mapInteger(Record.MethodList));
-  error(IO.mapStringZ(Record.Name));
+  error(IO.mapInteger(Record.NumOverloads, "MethodCount"));
+  error(IO.mapInteger(Record.MethodList, "MethodListIndex"));
+  error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           OneMethodRecord &Record) {
   const bool IsFromOverloadList = (TypeKind == LF_METHODLIST);
   MapOneMethodRecord Mapper(IsFromOverloadList);
   return Mapper(IO, Record);
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           NestedTypeRecord &Record) {
   uint16_t Padding = 0;
-  error(IO.mapInteger(Padding));
-  error(IO.mapInteger(Record.Type));
-  error(IO.mapStringZ(Record.Name));
+  error(IO.mapInteger(Padding, "Padding"));
+  error(IO.mapInteger(Record.Type, "Type"));
+  error(IO.mapStringZ(Record.Name, "Name"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           StaticDataMemberRecord &Record) {
 
-  error(IO.mapInteger(Record.Attrs.Attrs));
-  error(IO.mapInteger(Record.Type));
-  error(IO.mapStringZ(Record.Name));
+  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  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));
-  error(IO.mapInteger(Record.BaseType));
-  error(IO.mapInteger(Record.VBPtrType));
-  error(IO.mapEncodedInteger(Record.VBPtrOffset));
-  error(IO.mapEncodedInteger(Record.VTableIndex));
+  error(IO.mapInteger(Record.Attrs.Attrs, "AccessSpecifier"));
+  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();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           VFPtrRecord &Record) {
   uint16_t Padding = 0;
-  error(IO.mapInteger(Padding));
-  error(IO.mapInteger(Record.Type));
+  error(IO.mapInteger(Padding, "Padding"));
+  error(IO.mapInteger(Record.Type, "Type"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
                                           ListContinuationRecord &Record) {
   uint16_t Padding = 0;
-  error(IO.mapInteger(Padding));
-  error(IO.mapInteger(Record.ContinuationIndex));
+  error(IO.mapInteger(Padding, "Padding"));
+  error(IO.mapInteger(Record.ContinuationIndex, "ContinuationIndex"));
 
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           PrecompRecord &Precomp) {
-  error(IO.mapInteger(Precomp.StartTypeIndex));
-  error(IO.mapInteger(Precomp.TypesCount));
-  error(IO.mapInteger(Precomp.Signature));
-  error(IO.mapStringZ(Precomp.PrecompFilePath));
+  error(IO.mapInteger(Precomp.StartTypeIndex, "StartIndex"));
+  error(IO.mapInteger(Precomp.TypesCount, "Count"));
+  error(IO.mapInteger(Precomp.Signature, "Signature"));
+  error(IO.mapStringZ(Precomp.PrecompFilePath, "PrecompFile"));
   return Error::success();
 }
 
 Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
                                           EndPrecompRecord &EndPrecomp) {
-  error(IO.mapInteger(EndPrecomp.Signature));
+  error(IO.mapInteger(EndPrecomp.Signature, "Signature"));
   return Error::success();
 }

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

 ; CHECK:       ]
 ; CHECK:       VarName: c32
 ; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK: ]
 
-
-
 ; ASM: .section .debug$T,"dr"
 ; ASM: .p2align 2
 ; ASM: .long  4                       # Debug section magic
-; ASM: .short 18
-; ASM: .short 4609
-; ASM: .long  3
-; ASM: .long  64
-; ASM: .long  65
-; ASM: .long  19
+; ASM: .short 18                      # Record length
+; ASM: .short 4609                    # Record kind: LF_ARGLIST
+; ASM: .long  3                       # NumArgs
+; ASM: .long  64                      # Argument
+; ASM: .long  65                      # Argument
+; ASM: .long  19                      # Argument
 ; 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 14
-; ASM: .short 4104
-; ASM: .long  3
-; ASM: .byte  0
-; ASM: .byte  0
-; ASM: .short 3
-; ASM: .long  4096
+; ASM: .short 14                      # Record length
+; ASM: .short 4104                    # Record kind: LF_PROCEDURE
+; ASM: .long  3                       # ReturnType
+; ASM: .byte  0                       # CallingConvention
+; ASM: .byte  0                       # FunctionOptions
+; ASM: .short 3                       # NumParameters
+; ASM: .long  4096                    # ArgListType
 ; 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 14
-; ASM: .short 5633
-; ASM: .long  0
-; ASM: .long  4097
-; ASM: .asciz "f"
+; ASM: .short 14                      # Record length
+; ASM: .short 5633                    # Record kind: LF_FUNC_ID
+; ASM: .long  0                       # ParentScope
+; ASM: .long  4097                    # FunctionType
+; 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 10
-; ASM: .short 4097
-; ASM: .long  116
-; ASM: .short 1
+; ASM: .short 10                      # Record length
+; ASM: .short 4097                    # Record kind: LF_MODIFIER
+; ASM: .long  116                     # ModifiedType
+; ASM: .short 1                       # Modifiers
 ; 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 10
-; ASM: .short 4098
-; ASM: .long  4099
-; ASM: .long  65548
+; ASM: .short 10                      # Record length
+; ASM: .short 4098                    # Record kind: LF_POINTER
+; ASM: .long  4099                    # PointeeType
+; ASM: .long  65548                   # Attributes
 ; 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 22
-; ASM: .short 5381
-; ASM: .short 0
-; ASM: .short 128
-; ASM: .long  0
-; ASM: .long  0
-; ASM: .long  0
-; ASM: .short 0
-; ASM: .asciz "A"
+; ASM: .short 22                      # Record length
+; ASM: .short 5381                    # Record kind: LF_STRUCTURE
+; ASM: .short 0                       # MemberCount
+; ASM: .short 128                     # Properties
+; ASM: .long  0                       # FieldList
+; ASM: .long  0                       # DerivedFrom
+; ASM: .long  0                       # VShape
+; ASM: .short 0                       # 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 18
-; ASM: .short 4098
-; ASM: .long  116
-; ASM: .long  32844
-; ASM: .long  4101
-; ASM: .short 4
+; ASM: .short 18                      # Record length
+; ASM: .short 4098                    # Record kind: LF_POINTER
+; ASM: .long  116                     # PointeeType
+; ASM: .long  32844                   # Attributes
+; ASM: .long  4101                    # ClassType
+; ASM: .short 4                       # Representation
 ; 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 10
-; ASM: .short 4098
-; ASM: .long  4101
-; ASM: .long  66572
+; ASM: .short 10                      # Record length
+; ASM: .short 4098                    # Record kind: LF_POINTER
+; ASM: .long  4101                    # PointeeType
+; ASM: .long  66572                   # Attributes
 ; 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: #   IsUnaligned: 0
 ; ASM: #   IsRestrict: 0
 ; ASM: #   IsThisPtr&: 0
 ; ASM: #   IsThisPtr&&: 0
 ; ASM: #   SizeOf: 8
 ; ASM: # }
-; ASM: .short 6
-; ASM: .short 4609
-; ASM: .long  0
+; ASM: .short 6                       # Record length
+; ASM: .short 4609                    # Record kind: LF_ARGLIST
+; ASM: .long  0                       # NumArgs
 ; ASM: # ArgList (0x1008) {
 ; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
 ; ASM: #   NumArgs: 0
 ; ASM: #   Arguments [
 ; ASM: #   ]
 ; ASM: # }
-; ASM: .short 26
-; ASM: .short 4105
-; ASM: .long  3
-; ASM: .long  4101
-; ASM: .long  4103
-; ASM: .byte  0
-; ASM: .byte  0
-; ASM: .short 0
-; ASM: .long  4104
-; ASM: .long  0
+; ASM: .short 26                      # Record length
+; ASM: .short 4105                    # Record kind: LF_MFUNCTION
+; ASM: .long  3                       # ReturnType
+; ASM: .long  4101                    # ClassType
+; ASM: .long  4103                    # ThisType
+; ASM: .byte  0                       # CallingConvention
+; ASM: .byte  0                       # FunctionOptions
+; ASM: .short 0                       # NumParameters
+; ASM: .long  4104                    # ArgListType
+; ASM: .long  0                       # 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 30
-; ASM: .short 4611
+; ASM: .short 30                      # Record length
+; ASM: .short 4611                    # Record kind: LF_FIELDLIST
 ; ASM: .byte  0x0d, 0x15, 0x03, 0x00
 ; ASM: .byte  0x74, 0x00, 0x00, 0x00
 ; ASM: .byte  0x00, 0x00, 0x61, 0x00
 ; ASM: .byte  0x11, 0x15, 0x03, 0x00
 ; ASM: .byte  0x09, 0x10, 0x00, 0x00
 ; ASM: .byte  0x41, 0x3a, 0x3a, 0x66
 ; ASM: .byte  0x00, 0xf3, 0xf2, 0xf1
 ; 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 22
-; ASM: .short 5381
-; ASM: .short 2
-; ASM: .short 0
-; ASM: .long  4106
-; ASM: .long  0
-; ASM: .long  0
-; ASM: .short 4
-; ASM: .asciz "A"
+; ASM: .short 22                      # Record length
+; ASM: .short 5381                    # Record kind: LF_STRUCTURE
+; ASM: .short 2                       # MemberCount
+; ASM: .short 0                       # Properties
+; ASM: .long  4106                    # FieldList
+; ASM: .long  0                       # DerivedFrom
+; ASM: .long  0                       # VShape
+; ASM: .short 4                       # SizeOf
+; ASM: .asciz "A"                     # Name
 ; ASM: # Struct (0x100B) {
 ; ASM: #   TypeLeafKind: LF_STRUCTURE (0x1505)
 ; ASM: #   MemberCount: 2
 ; ASM: #   Properties [ (0x0)
 ; ASM: #   ]
 ; ASM: #   FieldList: <field list> (0x100A)
 ; ASM: #   DerivedFrom: 0x0
 ; ASM: #   VShape: 0x0
 ; ASM: #   SizeOf: 4
 ; ASM: #   Name: A
 ; ASM: # }
-; ASM: .short 30
-; ASM: .short 5637
-; ASM: .long  0
-; ASM: .asciz "D:\\src\\llvm\\build\\t.cpp"
+; ASM: .short 30                      # Record length
+; ASM: .short 5637                    # Record kind: LF_STRING_ID
+; ASM: .long  0                       # Id
+; 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 14
-; ASM: .short 5638
-; ASM: .long  4107
-; ASM: .long  4108
-; ASM: .long  1
+; ASM: .short 14                      # Record length
+; ASM: .short 5638                    # Record kind: LF_UDT_SRC_LINE
+; ASM: .long  4107                    # UDT
+; ASM: .long  4108                    # SourceFile
+; ASM: .long  1                       # 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 18
-; ASM: .short 4098
-; ASM: .long  4105
-; ASM: .long  65644
-; ASM: .long  4101
-; ASM: .short 8
+; ASM: .short 18                      # Record length
+; ASM: .short 4098                    # Record kind: LF_POINTER
+; ASM: .long  4105                    # PointeeType
+; ASM: .long  65644                   # Attributes
+; ASM: .long  4101                    # ClassType
+; ASM: .short 8                       # Representation
 ; 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 10
-; ASM: .short 4097
-; ASM: .long  3
-; ASM: .short 1
+; ASM: .short 10                      # Record length
+; ASM: .short 4097                    # Record kind: LF_MODIFIER
+; ASM: .long  3                       # ModifiedType
+; ASM: .short 1                       # Modifiers
 ; 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 10
-; ASM: .short 4098
-; ASM: .long  4111
-; ASM: .long  65548
+; ASM: .short 10                      # Record length
+; ASM: .short 4098                    # Record kind: LF_POINTER
+; ASM: .long  4111                    # PointeeType
+; ASM: .long  65548                   # Attributes
 ; 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 14
-; ASM: .short 4104
-; ASM: .long  3
-; ASM: .byte  0
-; ASM: .byte  0
-; ASM: .short 0
-; ASM: .long  4104
+; ASM: .short 14                      # Record length
+; ASM: .short 4104                    # Record kind: LF_PROCEDURE
+; ASM: .long  3                       # ReturnType
+; ASM: .byte  0                       # CallingConvention
+; ASM: .byte  0                       # FunctionOptions
+; ASM: .short 0                       # NumParameters
+; ASM: .long  4104                    # 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 22
-; ASM: .short 5633
-; ASM: .long  0
-; ASM: .long  4113
-; ASM: .asciz "CharTypes"
+; ASM: .short 22                      # Record length
+; ASM: .short 5633                    # Record kind: LF_FUNC_ID
+; ASM: .long  0                       # ParentScope
+; ASM: .long  4113                    # FunctionType
+; 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: # }
-; ASM: .short 26
-; ASM: .short 5637
-; ASM: .long  0
-; ASM: .asciz "D:\\src\\llvm\\build"
+; ASM: .short 26                      # Record length
+; ASM: .short 5637                    # Record kind: LF_STRING_ID
+; ASM: .long  0                       # Id
+; ASM: .asciz "D:\\src\\llvm\\build"  # StringData
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # StringId (0x1013) {
 ; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
 ; ASM: #   Id: 0x0
 ; ASM: #   StringData: D:\src\llvm\build
 ; ASM: # }
-; ASM: .short 14
-; ASM: .short 5637
-; ASM: .long  0
-; ASM: .asciz "t.cpp"
+; ASM: .short 14                      # Record length
+; ASM: .short 5637                    # Record kind: LF_STRING_ID
+; ASM: .long  0                       # Id
+; ASM: .asciz "t.cpp"                 # StringData
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # StringId (0x1014) {
 ; ASM: #   TypeLeafKind: LF_STRING_ID (0x1605)
 ; ASM: #   Id: 0x0
 ; ASM: #   StringData: t.cpp
 ; ASM: # }
-; ASM: .short 26
-; ASM: .short 5635
-; ASM: .short 5
-; ASM: .long  4115
-; ASM: .long  0
-; ASM: .long  4116
-; ASM: .long  0
-; ASM: .long  0
+; ASM: .short 26                      # Record length
+; ASM: .short 5635                    # Record kind: LF_BUILDINFO
+; ASM: .short 5                       # NumArgs
+; ASM: .long  4115                    # Argument
+; ASM: .long  0                       # Argument
+; ASM: .long  4116                    # Argument
+; ASM: .long  0                       # Argument
+; ASM: .long  0                       # Argument
 ; ASM: .byte  242
 ; ASM: .byte  241
 ; ASM: # BuildInfo (0x1015) {
 ; ASM: #   TypeLeafKind: LF_BUILDINFO (0x1603)
 ; ASM: #   NumArgs: 5
 ; ASM: #   Arguments [
 ; ASM: #     ArgType: D:\src\llvm\build (0x1013)
 ; ASM: #     ArgType: 0x0