Get rid of Data and RawData in CVRecord

[zturner]

Summary

To make this work, we had to make restrict the usage of CVRecord to mean "record with length-specified prefix". This means CVRecord can no longer be used for field list members since they don't describe their own length and don't contain a prefix. So a new type is introduced called CVMemberTypeRecord, and then all the associated fallout is dealt with. Mostly this means changing all visitors to use separate methods for visiting CVRecords vs CVMemberTypeRecords, there's just a lot of it.

[zturner]

ping

[rnk]

include/llvm/DebugInfo/CodeView/TypeRecord.h

33 ↗

(On Diff #70917)

How about CVMemberRecord? It's consistent with MEMBER_RECORD vs TYPE_RECORD and visitKnownMember and visitKnownType.

[rnk]

lgtm

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

 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #include "llvm/DebugInfo/MSF/StreamReader.h"
 #include "llvm/DebugInfo/MSF/StreamRef.h"
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace codeview {
 
-template <typename Kind> struct CVRecord {
-  uint32_t Length;
+template <typename Kind> class CVRecord {
+public:
+  CVRecord() {}
+  CVRecord(Kind K, ArrayRef<uint8_t> Data) : Type(K), RecordData(Data) {}
+
+  uint32_t length() const { return RecordData.size(); }
+  Kind kind() const { return Type; }
+  ArrayRef<uint8_t> data() const { return RecordData; }
+  ArrayRef<uint8_t> content() const {
+    return RecordData.drop_front(sizeof(RecordPrefix));
+  }
+  Optional<uint32_t> hash() const { return Hash; }
+
+  void setHash(uint32_t Value) { Hash = Value; }
+
   Kind Type;
-  ArrayRef<uint8_t> Data;
-  ArrayRef<uint8_t> RawData;
+  ArrayRef<uint8_t> RecordData;
   Optional<uint32_t> Hash;
 };
 }
+
 namespace msf {
 
 template <typename Kind>
 struct VarStreamArrayExtractor<codeview::CVRecord<Kind>> {
   Error operator()(ReadableStreamRef Stream, uint32_t &Len,
                    codeview::CVRecord<Kind> &Item) const {
     using namespace codeview;
     const RecordPrefix *Prefix = nullptr;
     StreamReader Reader(Stream);
     uint32_t Offset = Reader.getOffset();
 
     if (auto EC = Reader.readObject(Prefix))
       return EC;
-    Item.Length = Prefix->RecordLen;
-    if (Item.Length < 2)
+    if (Prefix->RecordLen < 2)
       return make_error<CodeViewError>(cv_error_code::corrupt_record);
-    Item.Type = static_cast<Kind>(uint16_t(Prefix->RecordKind));
+    Kind K = static_cast<Kind>(uint16_t(Prefix->RecordKind));
 
     Reader.setOffset(Offset);
+    ArrayRef<uint8_t> RawData;
     if (auto EC =
-            Reader.readBytes(Item.RawData, Item.Length + sizeof(uint16_t)))
+            Reader.readBytes(RawData, Prefix->RecordLen + sizeof(uint16_t)))
       return EC;
-    Item.Data = Item.RawData.slice(sizeof(RecordPrefix));
-    Len = Prefix->RecordLen + 2;
+    Item = codeview::CVRecord<Kind>(K, RawData);
+    Len = Item.length();
     return Error::success();
   }
 };
 }
 }
 
 #endif

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

 /// FIXME: Make the visitor interpret the trailing bytes so that clients don't
 /// need to.
 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
   void visit##Name(SymbolRecordKind Kind, Name &Record) {}
 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "CVSymbolTypes.def"
 
   void visitSymbolRecord(const CVRecord<SymbolKind> &Record) {
-    ArrayRef<uint8_t> Data = Record.Data;
+    ArrayRef<uint8_t> Data = Record.content();
     auto *DerivedThis = static_cast<Derived *>(this);
     DerivedThis->visitSymbolBegin(Record.Type, Data);
     uint32_t RecordOffset = Delegate ? Delegate->getRecordOffset(Data) : 0;
     switch (Record.Type) {
     default:
       DerivedThis->visitUnknownSymbol(Record.Type, Data);
       break;
 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
   case EnumName: {                                                             \
     SymbolRecordKind RK = static_cast<SymbolRecordKind>(EnumName);             \
     auto ExpectedResult = Name::deserialize(RK, RecordOffset, Data);           \
     if (!ExpectedResult) {                                                     \
       consumeError(ExpectedResult.takeError());                                \
       return parseError();                                                     \
     }                                                                          \
     DerivedThis->visit##Name(Record.Type, *ExpectedResult);                    \
     break;                                                                     \
   }
 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
   SYMBOL_RECORD(EnumVal, EnumVal, AliasName)
 #include "CVSymbolTypes.def"
     }
-    DerivedThis->visitSymbolEnd(Record.Type, Record.Data);
+    DerivedThis->visitSymbolEnd(Record.Type, Record.content());
   }
 
   /// Visits the symbol records in Data. Sets the error flag on parse failures.
   void visitSymbolStream(const CVSymbolArray &Symbols) {
     for (const auto &I : Symbols) {
       visitSymbolRecord(I);
       if (hadError())
         break;

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

 
 namespace llvm {
 namespace codeview {
 
 class CVTypeVisitor {
 public:
   explicit CVTypeVisitor(TypeVisitorCallbacks &Callbacks);
 
-  Error visitTypeRecord(CVRecord<TypeLeafKind> &Record);
+  Error visitTypeRecord(CVType &Record);
+  Error visitMemberRecord(CVMemberRecord &Record);
 
   /// Visits the type records in Data. Sets the error flag on parse failures.
   Error visitTypeStream(const CVTypeArray &Types);
 
   Error visitFieldListMemberStream(ArrayRef<uint8_t> FieldList);
 
 private:
   /// The interface to the class that gets notified of each visitation.
   TypeVisitorCallbacks &Callbacks;
 };
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_CVTYPEVISITOR_H

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

 
 namespace llvm {
 namespace codeview {
 class TypeDeserializer : public TypeVisitorCallbacks {
 public:
   TypeDeserializer() {}
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
-      override {                                                               \
+  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override {         \
     return defaultVisitKnownRecord(CVR, Record);                               \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
+    return defaultVisitKnownMember(CVR, Record);                               \
+  }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
 protected:
 
   template <typename T>
   Error deserializeRecord(ArrayRef<uint8_t> &Data, TypeLeafKind Kind,
                           T &Record) const {
     TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
     auto ExpectedRecord = T::deserialize(RK, Data);
     if (!ExpectedRecord)
       return ExpectedRecord.takeError();
     Record = std::move(*ExpectedRecord);
     return Error::success();
   }
 
 private:
-  template <typename T>
-  Error defaultVisitKnownRecord(CVRecord<TypeLeafKind> &CVR, T &Record) {
-    ArrayRef<uint8_t> RD = CVR.Data;
+  template <typename T> Error defaultVisitKnownRecord(CVType &CVR, T &Record) {
+    ArrayRef<uint8_t> RD = CVR.content();
     if (auto EC = deserializeRecord(RD, CVR.Type, Record))
       return EC;
     return Error::success();
   }
+  template <typename T>
+  Error defaultVisitKnownMember(CVMemberRecord &CVMR, T &Record) {
+    ArrayRef<uint8_t> RD = CVMR.Data;
+    if (auto EC = deserializeRecord(RD, CVMR.Kind, Record))
+      return EC;
+    return Error::success();
+  }
 };
 }
 }
 
 #endif

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

public:
   StringRef saveName(StringRef TypeName) {
     return TypeNames.insert(TypeName).first->getKey();
   }
 
   void setPrinter(ScopedPrinter *P);
   ScopedPrinter *getPrinter() { return W; }
 
   /// Action to take on unknown types. By default, they are ignored.
-  Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override;
-  Error visitUnknownMember(CVRecord<TypeLeafKind> &Record) override;
+  Error visitUnknownType(CVType &Record) override;
+  Error visitUnknownMember(CVMemberRecord &Record) override;
 
   /// Paired begin/end actions for all types. Receives all record data,
   /// including the fixed-length record prefix.
-  Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override;
-  Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) override;
+  Error visitTypeBegin(CVType &Record) override;
+  Error visitTypeEnd(CVType &Record) override;
+  Error visitMemberBegin(CVMemberRecord &Record) override;
+  Error visitMemberEnd(CVMemberRecord &Record) override;
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
-      override;
+  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override;
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
 private:
   void printMemberAttributes(MemberAttributes Attrs);
   void printMemberAttributes(MemberAccess Access, MethodKind Kind,
                              MethodOptions Options);

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

 namespace llvm {
 namespace codeview {
 
 using llvm::support::little32_t;
 using llvm::support::ulittle16_t;
 using llvm::support::ulittle32_t;
 
 typedef CVRecord<TypeLeafKind> CVType;
+
+struct CVMemberRecord {
+  TypeLeafKind Kind;
+  ArrayRef<uint8_t> Data;
+};
 typedef msf::VarStreamArray<CVType> CVTypeArray;
 
 /// Equvalent to CV_fldattr_t in cvinfo.h.
 struct MemberAttributes {
   ulittle16_t Attrs;
   enum {
     MethodKindShift = 2,
   };

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

 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   virtual Error visitKnownRecord(CVType &CVR, Name##Record &Record) override { \
     visitKnownRecordImpl(CVR, Record);                                         \
     return Error::success();                                                   \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  virtual Error visitKnownRecord(CVType &CVR, Name##Record &Record) override { \
+  virtual Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record)    \
+      override {                                                               \
     visitMemberRecordImpl(Record);                                             \
     return Error::success();                                                   \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
 private:
   void updateCVRecord(CVType &Record) {
     StringRef S = TypeTableBuilder.getRecords().back();
-    ArrayRef<uint8_t> Data(S.bytes_begin(), S.bytes_end());
-    Record.RawData = Data;
-    Record.Data = Record.RawData.drop_front(sizeof(RecordPrefix));
-    Record.Length = Data.size() - sizeof(ulittle16_t);
+    Record.RecordData = ArrayRef<uint8_t>(S.bytes_begin(), S.bytes_end());
   }
   template <typename RecordKind>
   void visitKnownRecordImpl(CVType &CVR, RecordKind &Record) {
     TypeTableBuilder.writeKnownType(Record);
     updateCVRecord(CVR);
   }
   template <typename RecordKind>
   void visitMemberRecordImpl(RecordKind &Record) {

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

public:
   virtual Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitUnknownType(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Error visitUnknownMember(CVRecord<TypeLeafKind> &Record) override {
+  virtual Error visitUnknownMember(CVMemberRecord &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitUnknownMember(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override {
+  virtual Error visitTypeBegin(CVType &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitTypeBegin(Record))
         return EC;
     }
     return Error::success();
   }
-  virtual Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) override {
+  virtual Error visitTypeEnd(CVType &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitTypeEnd(Record))
         return EC;
     }
     return Error::success();
   }
 
+  virtual Error visitMemberBegin(CVMemberRecord &Record) override {
+    for (auto Visitor : Pipeline) {
+      if (auto EC = Visitor->visitMemberBegin(Record))
+        return EC;
+    }
+    return Error::success();
+  }
+  virtual Error visitMemberEnd(CVMemberRecord &Record) override {
+    for (auto Visitor : Pipeline) {
+      if (auto EC = Visitor->visitMemberEnd(Record))
+        return EC;
+    }
+    return Error::success();
+  }
+
   void addCallbackToPipeline(TypeVisitorCallbacks &Callbacks) {
     Pipeline.push_back(&Callbacks);
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
-      override {                                                               \
+  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override {         \
     for (auto Visitor : Pipeline) {                                            \
       if (auto EC = Visitor->visitKnownRecord(CVR, Record))                    \
         return EC;                                                             \
     }                                                                          \
     return Error::success();                                                   \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  Error visitKnownMember(CVMemberRecord &CVMR, Name##Record &Record)           \
+      override {                                                               \
+    for (auto Visitor : Pipeline) {                                            \
+      if (auto EC = Visitor->visitKnownMember(CVMR, Record))                   \
+        return EC;                                                             \
+    }                                                                          \
+    return Error::success();                                                   \
+  }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
 private:
   std::vector<TypeVisitorCallbacks *> Pipeline;
 };
 }
 }
 
 #endif

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

 namespace codeview {
 class TypeVisitorCallbacks {
   friend class CVTypeVisitor;
 
 public:
   virtual ~TypeVisitorCallbacks() {}
 
   /// Action to take on unknown types. By default, they are ignored.
-  virtual Error visitUnknownType(CVRecord<TypeLeafKind> &Record) {
-    return Error::success();
-  }
-  virtual Error visitUnknownMember(CVRecord<TypeLeafKind> &Record) {
-    return Error::success();
-  }
-
+  virtual Error visitUnknownType(CVType &Record) { return Error::success(); }
   /// Paired begin/end actions for all types. Receives all record data,
   /// including the fixed-length record prefix.  visitTypeBegin() should return
   /// the type of the Record, or an error if it cannot be determined.
-  virtual Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) {
+  virtual Error visitTypeBegin(CVType &Record) { return Error::success(); }
+  virtual Error visitTypeEnd(CVType &Record) { return Error::success(); }
+
+  virtual Error visitUnknownMember(CVMemberRecord &Record) {
     return Error::success();
   }
-  virtual Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) {
+  virtual Error visitMemberBegin(CVMemberRecord &Record) {
+    return Error::success();
+  }
+  virtual Error visitMemberEnd(CVMemberRecord &Record) {
     return Error::success();
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  virtual Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,                  \
-                                 Name##Record &Record) {                       \
+  virtual Error visitKnownRecord(CVType &CVR, Name##Record &Record) {          \
     return Error::success();                                                   \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  virtual Error visitKnownMember(CVMemberRecord &CVM, Name##Record &Record) {  \
+    return Error::success();                                                   \
+  }
+
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 };
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/TpiStreamBuilder.h

 namespace msf {
 class ByteStream;
 class MSFBuilder;
 struct MSFLayout;
 class ReadableStreamRef;
 class WritableStream;
 
 template <> struct SequencedItemTraits<llvm::codeview::CVType> {
-  static size_t length(const codeview::CVType &Item) {
-    return Item.RawData.size();
-  }
+  static size_t length(const codeview::CVType &Item) { return Item.length(); }
   static ArrayRef<uint8_t> bytes(const codeview::CVType &Item) {
-    return Item.RawData;
+    return Item.data();
   }
 };
 }
 namespace pdb {
 class PDBFile;
 class TpiStream;
 struct TpiStreamHeader;
 

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

if (Data.size() < BytesToAdvance) {
     return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record,
                                            "Invalid padding bytes!");
   }
   Data = Data.drop_front(BytesToAdvance);
   return Error::success();
 }
 
 template <typename T>
-static Expected<CVType> deserializeMemberRecord(ArrayRef<uint8_t> &Data,
+static Expected<CVMemberRecord> deserializeMemberRecord(ArrayRef<uint8_t> &Data,
                                                         TypeLeafKind Kind) {
   ArrayRef<uint8_t> OldData = Data;
   TypeRecordKind RK = static_cast<TypeRecordKind>(Kind);
   auto ExpectedRecord = T::deserialize(RK, Data);
   if (!ExpectedRecord)
     return ExpectedRecord.takeError();
   assert(Data.size() < OldData.size());
   if (auto EC = skipPadding(Data))
     return std::move(EC);
 
-  CVType CVR;
-  CVR.Type = Kind;
-  CVR.Length = OldData.size() - Data.size();
-  CVR.Data = OldData.slice(0, CVR.Length);
-  CVR.RawData = CVR.Data;
-  return CVR;
+  CVMemberRecord CVMR;
+  CVMR.Kind = Kind;
+  CVMR.Data = OldData.drop_back(Data.size());
+  return CVMR;
 }
 
 CVTypeVisitor::CVTypeVisitor(TypeVisitorCallbacks &Callbacks)
     : Callbacks(Callbacks) {}
 
 template <typename T>
-static Error visitKnownRecord(CVRecord<TypeLeafKind> &Record,
-                              TypeVisitorCallbacks &Callbacks) {
+static Error visitKnownRecord(CVType &Record, TypeVisitorCallbacks &Callbacks) {
   TypeRecordKind RK = static_cast<TypeRecordKind>(Record.Type);
   T KnownRecord(RK);
   if (auto EC = Callbacks.visitKnownRecord(Record, KnownRecord))
     return EC;
   return Error::success();
 }
 
-Error CVTypeVisitor::visitTypeRecord(CVRecord<TypeLeafKind> &Record) {
+template <typename T>
+static Error visitKnownMember(CVMemberRecord &Record,
+                              TypeVisitorCallbacks &Callbacks) {
+  TypeRecordKind RK = static_cast<TypeRecordKind>(Record.Kind);
+  T KnownRecord(RK);
+  if (auto EC = Callbacks.visitKnownMember(Record, KnownRecord))
+    return EC;
+  return Error::success();
+}
+
+Error CVTypeVisitor::visitTypeRecord(CVType &Record) {
   if (auto EC = Callbacks.visitTypeBegin(Record))
     return EC;
 
   switch (Record.Type) {
   default:
     if (auto EC = Callbacks.visitUnknownType(Record))
       return EC;
     break;
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   case EnumName: {                                                             \
     if (auto EC = visitKnownRecord<Name##Record>(Record, Callbacks))           \
       return EC;                                                               \
     break;                                                                     \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                  \
   TYPE_RECORD(EnumVal, EnumVal, AliasName)
+#define MEMBER_RECORD(EnumName, EnumVal, Name)
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
+#include "llvm/DebugInfo/CodeView/TypeRecords.def"
+  }
+
+  if (auto EC = Callbacks.visitTypeEnd(Record))
+    return EC;
+
+  return Error::success();
+}
+
+Error CVTypeVisitor::visitMemberRecord(CVMemberRecord &Record) {
+  if (auto EC = Callbacks.visitMemberBegin(Record))
+    return EC;
+
+  switch (Record.Kind) {
+  default:
+    if (auto EC = Callbacks.visitUnknownMember(Record))
+      return EC;
+    break;
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  case EnumName: {                                                             \
+    if (auto EC = visitKnownMember<Name##Record>(Record, Callbacks))           \
+      return EC;                                                               \
+    break;                                                                     \
+  }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
-  MEMBER_RECORD(EnumName, EnumVal, AliasName)
+  MEMBER_RECORD(EnumVal, EnumVal, AliasName)
+#define TYPE_RECORD(EnumName, EnumVal, Name)
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   }
 
-  if (auto EC = Callbacks.visitTypeEnd(Record))
+  if (auto EC = Callbacks.visitMemberEnd(Record))
     return EC;
 
   return Error::success();
 }
 
 /// Visits the type records in Data. Sets the error flag on parse failures.
 Error CVTypeVisitor::visitTypeStream(const CVTypeArray &Types) {
   for (auto I : Types) {
     if (auto EC = visitTypeRecord(I))
       return EC;
   }
   return Error::success();
 }
 
 template <typename MR>
 static Error visitKnownMember(ArrayRef<uint8_t> &Data, TypeLeafKind Leaf,
                               TypeVisitorCallbacks &Callbacks) {
   auto ExpectedRecord = deserializeMemberRecord<MR>(Data, Leaf);
   if (!ExpectedRecord)
     return ExpectedRecord.takeError();
-  CVType &Record = *ExpectedRecord;
-  if (auto EC = Callbacks.visitTypeBegin(Record))
+  CVMemberRecord &Record = *ExpectedRecord;
+  if (auto EC = Callbacks.visitMemberBegin(Record))
     return EC;
-  if (auto EC = visitKnownRecord<MR>(Record, Callbacks))
+  if (auto EC = visitKnownMember<MR>(Record, Callbacks))
     return EC;
-  if (auto EC = Callbacks.visitTypeEnd(Record))
+  if (auto EC = Callbacks.visitMemberEnd(Record))
     return EC;
   return Error::success();
 }
 
 Error CVTypeVisitor::visitFieldListMemberStream(ArrayRef<uint8_t> Data) {
   while (!Data.empty()) {
     const support::ulittle16_t *LeafValue;
     if (auto EC = takeObject(Data, LeafValue))

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

 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   default:
     break;
   }
   return "UnknownLeaf";
 }
 
 Error CVTypeDumper::visitTypeBegin(CVRecord<TypeLeafKind> &Record) {
+  assert(!IsInFieldList);
   // Reset Name to the empty string. If the visitor sets it, we know it.
   Name = "";
 
   W->startLine() << getLeafTypeName(Record.Type);
-  if (!IsInFieldList) {
-    // If this is a field list member, don't record its type index because it
-    // doesn't have one.  Only the outer field list has a type index.
-    W->getOStream() << " (" << HexNumber(getNextTypeIndex()) << ")";
-  }
   W->getOStream() << " {\n";
   W->indent();
   W->printEnum("TypeLeafKind", unsigned(Record.Type),
                makeArrayRef(LeafTypeNames));
   if (Record.Type == LF_FIELDLIST) {
     // Record that we're in a field list so that members do not get assigned
     // type indices.
-    assert(!IsInFieldList);
     IsInFieldList = true;
   }
   return Error::success();
 }
 
 Error CVTypeDumper::visitTypeEnd(CVRecord<TypeLeafKind> &Record) {
   if (Record.Type == LF_FIELDLIST) {
     assert(IsInFieldList);
     IsInFieldList = false;
   }
+  assert(!IsInFieldList);
 
-  if (!IsInFieldList) {
-    // Record every type that is not a field list member, even if Name is empty.
-    // CVUDTNames is indexed by type index, and must have one entry for every
-    // type.  Field list members are not recorded, and are only referenced by
-    // their containing field list record.
-    recordType(Name);
-  }
+
+  if (PrintRecordBytes)
+    W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));
+
+  W->unindent();
+  W->startLine() << "}\n";
+  return Error::success();
 
+Error CVTypeDumper::visitMemberBegin(CVMemberRecord &Record) {
+  assert(IsInFieldList);
+  // Reset Name to the empty string. If the visitor sets it, we know it.
+  Name = "";
+
+  W->startLine() << getLeafTypeName(Record.Kind);
+  W->getOStream() << " {\n";
+  W->indent();
+  W->printEnum("TypeLeafKind", unsigned(Record.Kind),
+               makeArrayRef(LeafTypeNames));
+  return Error::success();
+}
+
+Error CVTypeDumper::visitMemberEnd(CVMemberRecord &Record) {
+  assert(IsInFieldList);
   if (PrintRecordBytes)
     W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
 
   W->unindent();
   W->startLine() << "}\n";
   return Error::success();
 }
 
void CVTypeDumper::printMemberAttributes(MemberAccess Access, MethodKind Kind,
   if (Kind != MethodKind::Vanilla)
     W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));
   if (Options != MethodOptions::None) {
     W->printFlags("MethodOptions", unsigned(Options),
                   makeArrayRef(MethodOptionNames));
   }
 }
 
-Error CVTypeDumper::visitUnknownMember(CVRecord<TypeLeafKind> &Record) {
-  W->printHex("UnknownMember", unsigned(Record.Type));
+Error CVTypeDumper::visitUnknownMember(CVMemberRecord &Record) {
+  W->printHex("UnknownMember", unsigned(Record.Kind));
   return Error::success();
 }
 
 Error CVTypeDumper::visitUnknownType(CVRecord<TypeLeafKind> &Record) {
-  W->printEnum("Kind", uint16_t(Record.Type), makeArrayRef(LeafTypeNames));
-  W->printNumber("Length", uint32_t(Record.Data.size()));
+  W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames));
+  W->printNumber("Length", uint32_t(Record.content().size()));
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      NestedTypeRecord &Nested) {
   printTypeIndex("Type", Nested.getNestedType());
   W->printString("Name", Nested.getName());
   Name = Nested.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      OneMethodRecord &Method) {
   MethodKind K = Method.getKind();
   printMemberAttributes(Method.getAccess(), K, Method.getOptions());
   printTypeIndex("Type", Method.getType());
   // If virtual, then read the vftable offset.
   if (Method.isIntroducingVirtual())
     W->printHex("VFTableOffset", Method.getVFTableOffset());
   W->printString("Name", Method.getName());
   Name = Method.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      OverloadedMethodRecord &Method) {
   W->printHex("MethodCount", Method.getNumOverloads());
   printTypeIndex("MethodListIndex", Method.getMethodList());
   W->printString("Name", Method.getName());
   Name = Method.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      DataMemberRecord &Field) {
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W->printHex("FieldOffset", Field.getFieldOffset());
   W->printString("Name", Field.getName());
   Name = Field.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      StaticDataMemberRecord &Field) {
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W->printString("Name", Field.getName());
   Name = Field.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      VFPtrRecord &VFTable) {
   printTypeIndex("Type", VFTable.getType());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      EnumeratorRecord &Enum) {
   printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   W->printNumber("EnumValue", Enum.getValue());
   W->printString("Name", Enum.getName());
   Name = Enum.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      BaseClassRecord &Base) {
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   W->printHex("BaseOffset", Base.getBaseOffset());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      VirtualBaseClassRecord &Base) {
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   printTypeIndex("VBPtrType", Base.getVBPtrType());
   W->printHex("VBPtrOffset", Base.getVBPtrOffset());
   W->printHex("VBTableIndex", Base.getVTableIndex());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownMember(CVMemberRecord &CVR,
                                      ListContinuationRecord &Cont) {
   printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
   return Error::success();
 }
 
 StringRef CVTypeDumper::getTypeName(TypeIndex TI) {
   if (TI.isNoneType())
     return "<no type>";

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

 class TypeStreamMerger : public TypeVisitorCallbacks {
 public:
   TypeStreamMerger(TypeTableBuilder &DestStream) : DestStream(DestStream) {
     assert(!hadError());
   }
 
 /// TypeVisitorCallbacks overrides.
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
-      override;
+  Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override;
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
-  Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override;
+  Error visitUnknownType(CVType &Record) override;
 
-  Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override;
-  Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) override;
+  Error visitTypeBegin(CVType &Record) override;
+  Error visitTypeEnd(CVType &Record) override;
+  Error visitMemberEnd(CVMemberRecord &Record) override;
 
   bool mergeStream(const CVTypeArray &Types);
 
 private:
   template <typename RecordType>
   Error visitKnownRecordImpl(RecordType &Record) {
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);
     IndexMap.push_back(DestStream.writeKnownType(Record));
Error TypeStreamMerger::visitTypeBegin(CVRecord<TypeLeafKind> &Rec) {
   return Error::success();
 }
 
 Error TypeStreamMerger::visitTypeEnd(CVRecord<TypeLeafKind> &Rec) {
   if (Rec.Type == TypeLeafKind::LF_FIELDLIST) {
     IndexMap.push_back(DestStream.writeFieldList(FieldBuilder));
     FieldBuilder.reset();
     IsInFieldList = false;
-  } else if (!IsInFieldList) {
-    assert(IndexMap.size() == BeginIndexMapSize + 1);
   }
   return Error::success();
 }
 
+Error TypeStreamMerger::visitMemberEnd(CVMemberRecord &Rec) {
+  assert(IndexMap.size() == BeginIndexMapSize + 1);
+  return Error::success();
+}
+
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error TypeStreamMerger::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,        \
+  Error TypeStreamMerger::visitKnownRecord(CVType &CVR,                        \
                                            Name##Record &Record) {             \
     return visitKnownRecordImpl(Record);                                       \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  Error TypeStreamMerger::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,        \
+  Error TypeStreamMerger::visitKnownMember(CVMemberRecord &CVR,                \
                                            Name##Record &Record) {             \
     return visitKnownMemberRecordImpl(Record);                                 \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
-Error TypeStreamMerger::visitUnknownType(CVRecord<TypeLeafKind> &Rec) {
+Error TypeStreamMerger::visitUnknownType(CVType &Rec) {
   // We failed to translate a type. Translate this index as "not translated".
   IndexMap.push_back(
       TypeIndex(SimpleTypeKind::NotTranslated, SimpleTypeMode::Direct));
   return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record);
 }
 
 bool TypeStreamMerger::mergeStream(const CVTypeArray &Types) {
   assert(IndexMap.empty());

llvm/trunk/lib/DebugInfo/PDB/Raw/TpiHashing.cpp

 }
 
 void TpiHashUpdater::visitKnownRecordImpl(CVType &CVR,
                                           UdtModSourceLineRecord &Rec) {
   CVR.Hash = getSourceLineHash(Rec);
 }
 
 void TpiHashUpdater::visitKnownRecordImpl(CVType &CVR, ClassRecord &Rec) {
-  CVR.Hash = getTpiHash(Rec, CVR.RawData);
+  CVR.Hash = getTpiHash(Rec, CVR.data());
 }
 
 void TpiHashUpdater::visitKnownRecordImpl(CVType &CVR, EnumRecord &Rec) {
-  CVR.Hash = getTpiHash(Rec, CVR.RawData);
+  CVR.Hash = getTpiHash(Rec, CVR.data());
 }
 
 void TpiHashUpdater::visitKnownRecordImpl(CVType &CVR, UnionRecord &Rec) {
-  CVR.Hash = getTpiHash(Rec, CVR.RawData);
+  CVR.Hash = getTpiHash(Rec, CVR.data());
 }
 
 Error TpiHashVerifier::visitKnownRecord(CVType &CVR, UdtSourceLineRecord &Rec) {
   return verifySourceLine(Rec.getUDT());
 }
 
 Error TpiHashVerifier::visitKnownRecord(CVType &CVR,
                                         UdtModSourceLineRecord &Rec) {
   return verifySourceLine(Rec.getUDT());
 }
 
 Error TpiHashVerifier::visitKnownRecord(CVType &CVR, ClassRecord &Rec) {
-  if (getTpiHash(Rec, CVR.RawData) % NumHashBuckets != HashValues[Index])
+  if (getTpiHash(Rec, CVR.data()) % NumHashBuckets != HashValues[Index])
     return errorInvalidHash();
   return Error::success();
 }
 Error TpiHashVerifier::visitKnownRecord(CVType &CVR, EnumRecord &Rec) {
-  if (getTpiHash(Rec, CVR.RawData) % NumHashBuckets != HashValues[Index])
+  if (getTpiHash(Rec, CVR.data()) % NumHashBuckets != HashValues[Index])
     return errorInvalidHash();
   return Error::success();
 }
 Error TpiHashVerifier::visitKnownRecord(CVType &CVR, UnionRecord &Rec) {
-  if (getTpiHash(Rec, CVR.RawData) % NumHashBuckets != HashValues[Index])
+  if (getTpiHash(Rec, CVR.data()) % NumHashBuckets != HashValues[Index])
     return errorInvalidHash();
   return Error::success();
 }
 
 Error TpiHashVerifier::verifySourceLine(codeview::TypeIndex TI) {
   char Buf[4];
   support::endian::write32le(Buf, TI.getIndex());
   uint32_t Hash = hashStringV1(StringRef(Buf, 4));

llvm/trunk/tools/llvm-pdbdump/CodeViewYaml.h

 namespace codeview {
 namespace yaml {
 class YamlTypeDumperCallbacks : public TypeVisitorCallbacks {
 public:
   YamlTypeDumperCallbacks(llvm::yaml::IO &IO,
                           llvm::pdb::yaml::SerializationContext &Context)
       : YamlIO(IO), Context(Context) {}
 
-  virtual Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override;
+  virtual Error visitTypeBegin(CVType &Record) override;
+  virtual Error visitMemberBegin(CVMemberRecord &Record) override;
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
       override {                                                               \
     visitKnownRecordImpl(#Name, CVR, Record);                                  \
     return Error::success();                                                   \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  TYPE_RECORD(EnumName, EnumVal, Name)
+  Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
+    visitKnownMemberImpl(#Name, Record);                                       \
+    return Error::success();                                                   \
+  }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
 private:
+  template <typename T> void visitKnownMemberImpl(const char *Name, T &Record) {
+    YamlIO.mapRequired(Name, Record);
+  }
+
   template <typename T>
   void visitKnownRecordImpl(const char *Name, CVType &Type, T &Record) {
     YamlIO.mapRequired(Name, Record);
   }
 
   void visitKnownRecordImpl(const char *Name, CVType &CVR,
                             FieldListRecord &FieldList);
 

llvm/trunk/tools/llvm-pdbdump/CodeViewYaml.cpp

 #include "CodeViewYaml.h"
 #include "PdbYaml.h"
 #include "YamlSerializationContext.h"
 
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeSerializationVisitor.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
+#include "llvm/DebugInfo/PDB/Raw/TpiHashing.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::codeview::yaml;
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
 LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
 LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
 LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
 LLVM_YAML_IS_SEQUENCE_VECTOR(CVType)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbTpiRecord)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbTpiFieldListRecord)
 
 namespace {
 struct FieldListRecordSplitter : public TypeVisitorCallbacks {
 public:
   explicit FieldListRecordSplitter(
-      std::vector<llvm::pdb::yaml::PdbTpiRecord> &Records)
+      std::vector<llvm::pdb::yaml::PdbTpiFieldListRecord> &Records)
       : Records(Records) {}
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  Error visitKnownRecord(CVType &CVT, Name##Record &Record) override {         \
-    visitKnownRecordImpl(CVT);                                                 \
+  Error visitKnownMember(CVMemberRecord &CVT, Name##Record &Record) override { \
+    visitKnownMemberImpl(CVT);                                                 \
     return Error::success();                                                   \
   }
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
 private:
-  void visitKnownRecordImpl(CVType &CVT) {
-    llvm::pdb::yaml::PdbTpiRecord R;
+  void visitKnownMemberImpl(CVMemberRecord &CVT) {
+    llvm::pdb::yaml::PdbTpiFieldListRecord R;
     R.Record = CVT;
     Records.push_back(std::move(R));
   }
 
-  std::vector<llvm::pdb::yaml::PdbTpiRecord> &Records;
+  std::vector<llvm::pdb::yaml::PdbTpiFieldListRecord> &Records;
 };
 }
 
 namespace llvm {
 namespace yaml {
 template <> struct ScalarEnumerationTraits<PointerToMemberRepresentation> {
   static void enumeration(IO &IO, PointerToMemberRepresentation &Value) {
     IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
   auto TypeLeafNames = getTypeLeafNames();
   for (const auto &E : TypeLeafNames)
     io.enumCase(Value, E.Name.str().c_str(), E.Value);
 }
 }
 }
 
 Error llvm::codeview::yaml::YamlTypeDumperCallbacks::visitTypeBegin(
-    CVRecord<TypeLeafKind> &CVR) {
+    CVType &CVR) {
   YamlIO.mapRequired("Kind", CVR.Type);
   return Error::success();
 }
 
+Error llvm::codeview::yaml::YamlTypeDumperCallbacks::visitMemberBegin(
+    CVMemberRecord &Record) {
+  YamlIO.mapRequired("Kind", Record.Kind);
+  return Error::success();
+}
+
 void llvm::codeview::yaml::YamlTypeDumperCallbacks::visitKnownRecordImpl(
     const char *Name, CVType &CVR, FieldListRecord &FieldList) {
-  std::vector<llvm::pdb::yaml::PdbTpiRecord> FieldListRecords;
+  std::vector<llvm::pdb::yaml::PdbTpiFieldListRecord> FieldListRecords;
   if (YamlIO.outputting()) {
     // If we are outputting, then `FieldList.Data` contains a huge chunk of data
     // representing the serialized list of members.  We need to split it up into
     // individual CVType records where each record represents an individual
     // member.  This way, we can simply map the entire thing as a Yaml sequence,
     // which will recurse back to the standard handler for top-level fields
     // (top-level and member fields all have the exact same Yaml syntax so use
     // the same parser).
     //
     // If we are not outputting, then the array contains no data starting out,
     // and is instead populated from the sequence represented by the yaml --
     // again, using the same logic that we use for top-level records.
     FieldListRecordSplitter Splitter(FieldListRecords);
     CVTypeVisitor V(Splitter);
     consumeError(V.visitFieldListMemberStream(FieldList.Data));
   }
   YamlIO.mapRequired("FieldList", FieldListRecords, Context);
 }
+
+namespace llvm {
+namespace yaml {
+template <>
+struct MappingContextTraits<pdb::yaml::PdbTpiFieldListRecord,
+                            pdb::yaml::SerializationContext> {
+  static void mapping(IO &IO, pdb::yaml::PdbTpiFieldListRecord &Obj,
+                      pdb::yaml::SerializationContext &Context) {
+    codeview::TypeVisitorCallbackPipeline Pipeline;
+    codeview::TypeDeserializer Deserializer;
+    codeview::TypeSerializationVisitor Serializer(Context.FieldListBuilder,
+                                                  Context.TypeTableBuilder);
+    pdb::TpiHashUpdater Hasher;
+
+    if (IO.outputting()) {
+      // For PDB to Yaml, deserialize into a high level record type, then dump
+      // it.
+      Pipeline.addCallbackToPipeline(Deserializer);
+      Pipeline.addCallbackToPipeline(Context.Dumper);
+    } else {
+      // For Yaml to PDB, extract from the high level record type, then write it
+      // to bytes.
+      Pipeline.addCallbackToPipeline(Context.Dumper);
+      Pipeline.addCallbackToPipeline(Serializer);
+      Pipeline.addCallbackToPipeline(Hasher);
+    }
+
+    codeview::CVTypeVisitor Visitor(Pipeline);
+    consumeError(Visitor.visitMemberRecord(Obj.Record));
+  }
+};
+}
+}

llvm/trunk/tools/llvm-pdbdump/LLVMOutputStyle.cpp

for (auto &Type : Tpi->types(&HadError)) {
       DictScope DD(P, "");
 
       if (DumpRecords) {
         if (auto EC = Dumper.dump(Type))
           return EC;
       }
 
       if (DumpRecordBytes)
-        P.printBinaryBlock("Bytes", Type.Data);
+        P.printBinaryBlock("Bytes", Type.content());
     }
     dumpTpiHash(P, *Tpi);
     if (HadError)
       return make_error<RawError>(raw_error_code::corrupt_file,
                                   "TPI stream contained corrupt record");
   } else if (opts::raw::DumpModuleSyms) {
     // Even if the user doesn't want to dump type records, we still need to
     // iterate them in order to build the list of types so that we can print
for (auto &Modi : DS->modules()) {
           codeview::CVSymbolDumper SD(P, Dumper, nullptr, false);
           bool HadError = false;
           for (const auto &S : ModS.symbols(&HadError)) {
             DictScope DD(P, "");
 
             if (opts::raw::DumpModuleSyms)
               SD.dump(S);
             if (opts::raw::DumpSymRecordBytes)
-              P.printBinaryBlock("Bytes", S.Data);
+              P.printBinaryBlock("Bytes", S.content());
           }
           if (HadError)
             return make_error<RawError>(
                 raw_error_code::corrupt_file,
                 "DBI stream contained corrupt symbol record");
         }
         if (opts::raw::DumpLineInfo) {
           ListScope SS(P, "LineInfo");
Error LLVMOutputStyle::dumpPublicsStream() {
   ListScope L(P, "Symbols");
   codeview::CVSymbolDumper SD(P, Dumper, nullptr, false);
   bool HadError = false;
   for (auto S : Publics->getSymbols(&HadError)) {
     DictScope DD(P, "");
 
     SD.dump(S);
     if (opts::raw::DumpSymRecordBytes)
-      P.printBinaryBlock("Bytes", S.Data);
+      P.printBinaryBlock("Bytes", S.content());
   }
   if (HadError)
     return make_error<RawError>(
         raw_error_code::corrupt_file,
         "Public symbol stream contained corrupt record");
 
   return Error::success();
 }

llvm/trunk/tools/llvm-pdbdump/PdbYaml.h

struct PdbDbiStream {
 
   std::vector<PdbDbiModuleInfo> ModInfos;
 };
 
 struct PdbTpiRecord {
   codeview::CVType Record;
 };
 
+struct PdbTpiFieldListRecord {
+  codeview::CVMemberRecord Record;
+};
+
 struct PdbTpiStream {
   PdbRaw_TpiVer Version;
   std::vector<PdbTpiRecord> Records;
 };
 
 struct PdbObject {
   explicit PdbObject(BumpPtrAllocator &Allocator) : Allocator(Allocator) {}