Pass CVRecords through visitors as non-const references

[zturner]

Summary

This simplifies a lot of code, and will actually be necessary for an upcoming patch to add a hash calcluation visitor.

The idea before was that visitors should be examining records, not modifying them. But this is no longer true with a visitor which constructs a CVRecord from a yaml description. To handle this until now, we were doing some fixup on the CVRecord objects at a higher level, but it makes a lot more sense to just have the visitor fill out the fields of the CVRecord directly. In doing so I uncovered a few bugs related to Data and RawData and fixed those.

[rnk]

lgtm While you're at it, it would be good if we could kill off Data and RawData, they're pretty redundant. Probably worth a separate change.

[zturner]

In D24362#537664, @rnk wrote:

lgtm While you're at it, it would be good if we could kill off Data and RawData, they're pretty redundant. Probably worth a separate change.

I tried, but it's not that easy. I still want to think about how to do that some more. The problem is that for top level records, Data = RawData.drop_front(sizeof(RecordPrefix)), but for field list member records, they're equal.

[zturner]

Also, I can't submit this until after D24316 which unfortunately is pretty big. So if someone gets a chance to look at it, would be nice.

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

 
 namespace llvm {
 namespace codeview {
 
 class CVTypeVisitor {
 public:
   explicit CVTypeVisitor(TypeVisitorCallbacks &Callbacks);
 
-  Error visitTypeRecord(const CVRecord<TypeLeafKind> &Record);
+  Error visitTypeRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,                    \
-                         Name##Record &Record) override {                      \
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
+      override {                                                               \
     return defaultVisitKnownRecord(CVR, Record);                               \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   TYPE_RECORD(EnumName, EnumVal, Name)
 #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(const CVRecord<TypeLeafKind> &CVR, T &Record) {
+  Error defaultVisitKnownRecord(CVRecord<TypeLeafKind> &CVR, T &Record) {
     ArrayRef<uint8_t> RD = CVR.Data;
     if (auto EC = deserializeRecord(RD, CVR.Type, 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(const CVRecord<TypeLeafKind> &Record) override;
-  Error visitUnknownMember(const CVRecord<TypeLeafKind> &Record) override;
+  Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override;
+  Error visitUnknownMember(CVRecord<TypeLeafKind> &Record) override;
 
   /// Paired begin/end actions for all types. Receives all record data,
   /// including the fixed-length record prefix.
-  Expected<TypeLeafKind>
-  visitTypeBegin(const CVRecord<TypeLeafKind> &Record) override;
-  Error visitTypeEnd(const CVRecord<TypeLeafKind> &Record) override;
+  Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override;
+  Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) override;
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,                    \
-                         Name##Record &Record) override;
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
+      override;
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   TYPE_RECORD(EnumName, EnumVal, Name)
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
 private:
   void printMemberAttributes(MemberAttributes Attrs);

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

 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPESERIALIZATIONVISITOR_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPESERIALIZATIONVISITOR_H
 
 #include "llvm/DebugInfo/CodeView/FieldListRecordBuilder.h"
 #include "llvm/DebugInfo/CodeView/MemoryTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 
 class TypeSerializationVisitor : public TypeVisitorCallbacks {
 public:
   TypeSerializationVisitor(FieldListRecordBuilder &FieldListBuilder,
                            MemoryTypeTableBuilder &TypeTableBuilder)
       : FieldListBuilder(FieldListBuilder), TypeTableBuilder(TypeTableBuilder) {
   }
 
-  virtual Expected<TypeLeafKind> visitTypeBegin(const CVType &Record) override {
+  virtual Error visitTypeBegin(CVType &Record) override {
     if (Record.Type == TypeLeafKind::LF_FIELDLIST)
       FieldListBuilder.reset();
-    return Record.Type;
+    return Error::success();
   }
 
-  virtual Error visitTypeEnd(const CVRecord<TypeLeafKind> &Record) override {
+  virtual Error visitTypeEnd(CVType &Record) override {
+    // Since this visitor's purpose is to serialize the record, fill out the
+    // fields of `Record` with the bytes of the record.
     if (Record.Type == TypeLeafKind::LF_FIELDLIST)
       TypeTableBuilder.writeFieldList(FieldListBuilder);
+
+    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);
     return Error::success();
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  virtual Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,            \
+  virtual Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,                  \
                                  Name##Record &Record) override {              \
     visitKnownRecordImpl(Record);                                              \
     return Error::success();                                                   \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  virtual Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,            \
+  virtual Error visitKnownRecord(CVRecord<TypeLeafKind> &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:

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

 #include <vector>
 
 namespace llvm {
 namespace codeview {
 class TypeVisitorCallbackPipeline : public TypeVisitorCallbacks {
 public:
   TypeVisitorCallbackPipeline() {}
 
-  virtual Error
-  visitUnknownType(const CVRecord<TypeLeafKind> &Record) override {
+  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(const CVRecord<TypeLeafKind> &Record) override {
+  virtual Error visitUnknownMember(CVRecord<TypeLeafKind> &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitUnknownMember(Record))
         return EC;
     }
     return Error::success();
   }
 
-  virtual Expected<TypeLeafKind>
-  visitTypeBegin(const CVRecord<TypeLeafKind> &Record) override {
-    // An implementation can calculate of visitTypeBegin() can calculate the
-    // kind based on an arbitrary factor, including the Type that is already
-    // specified in the Record.  So, as we go through the pipeline invoking
-    // each visitor, update the state in a copy of the record so that each
-    // visitor in the pipeline sees the most recently value of the type.
-    CVRecord<TypeLeafKind> RecordCopy = Record;
+  virtual Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override {
     for (auto Visitor : Pipeline) {
-      if (auto ExpectedKind = Visitor->visitTypeBegin(RecordCopy)) {
-        RecordCopy.Type = *ExpectedKind;
-      } else
-        return ExpectedKind.takeError();
+      if (auto EC = Visitor->visitTypeBegin(Record))
+        return EC;
     }
-    return RecordCopy.Type;
+    return Error::success();
   }
-  virtual Error visitTypeEnd(const CVRecord<TypeLeafKind> &Record) override {
+  virtual Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) override {
     for (auto Visitor : Pipeline) {
       if (auto EC = Visitor->visitTypeEnd(Record))
         return EC;
     }
     return Error::success();
   }
 
   void addCallbackToPipeline(TypeVisitorCallbacks &Callbacks) {
     Pipeline.push_back(&Callbacks);
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,                    \
-                         Name##Record &Record) override {                      \
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &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)

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(const CVRecord<TypeLeafKind> &Record) {
+  virtual Error visitUnknownType(CVRecord<TypeLeafKind> &Record) {
     return Error::success();
   }
-  virtual Error visitUnknownMember(const CVRecord<TypeLeafKind> &Record) {
+  virtual Error visitUnknownMember(CVRecord<TypeLeafKind> &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 Expected<TypeLeafKind>
-  visitTypeBegin(const CVRecord<TypeLeafKind> &Record) {
-    return Record.Type;
+  virtual Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) {
+    return Error::success();
   }
-  virtual Error visitTypeEnd(const CVRecord<TypeLeafKind> &Record) {
+  virtual Error visitTypeEnd(CVRecord<TypeLeafKind> &Record) {
     return Error::success();
   }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  virtual Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,            \
+  virtual Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,                  \
                                  Name##Record &Record) {                       \
     return Error::success();                                                   \
   }
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   TYPE_RECORD(EnumName, EnumVal, Name)
 #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

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

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

static Expected<CVType> deserializeMemberRecord(ArrayRef<uint8_t> &Data,
   CVR.RawData = CVR.Data;
   return CVR;
 }
 
 CVTypeVisitor::CVTypeVisitor(TypeVisitorCallbacks &Callbacks)
     : Callbacks(Callbacks) {}
 
 template <typename T>
-static Error visitKnownRecord(const CVRecord<TypeLeafKind> &Record,
+static Error visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &Record) {
-  TypeLeafKind Kind;
-  if (auto ExpectedKind = Callbacks.visitTypeBegin(Record))
-    Kind = *ExpectedKind;
-  else
-    return ExpectedKind.takeError();
-
-  CVType RecordCopy = Record;
-  RecordCopy.Type = Kind;
+Error CVTypeVisitor::visitTypeRecord(CVRecord<TypeLeafKind> &Record) {
+  if (auto EC = Callbacks.visitTypeBegin(Record))
+    return EC;
 
-  switch (Kind) {
+  switch (Record.Type) {
   default:
-    if (auto EC = Callbacks.visitUnknownType(RecordCopy))
+    if (auto EC = Callbacks.visitUnknownType(Record))
       return EC;
     break;
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   case EnumName: {                                                             \
-    if (auto EC = visitKnownRecord<Name##Record>(RecordCopy, Callbacks))       \
+    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)                                 \
   TYPE_RECORD(EnumName, EnumVal, Name)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
   MEMBER_RECORD(EnumName, EnumVal, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   }
 
-  if (auto EC = Callbacks.visitTypeEnd(RecordCopy))
+  if (auto EC = Callbacks.visitTypeEnd(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 (const auto &I : 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))
+    return EC;
+  if (auto EC = visitKnownRecord<MR>(Record, Callbacks))
+    return EC;
+  if (auto EC = Callbacks.visitTypeEnd(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))
       return EC;
 
     TypeLeafKind Leaf = static_cast<TypeLeafKind>(uint16_t(*LeafValue));
     CVType Record;
     switch (Leaf) {
     default:
       // Field list records do not describe their own length, so we cannot
       // continue parsing past a type that we don't know how to deserialize.
       return llvm::make_error<CodeViewError>(
           cv_error_code::unknown_member_record);
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   case EnumName: {                                                             \
-    auto ExpectedRecord = deserializeMemberRecord<Name##Record>(Data, Leaf);   \
-    if (!ExpectedRecord)                                                       \
-      return ExpectedRecord.takeError();                                       \
-    auto &Record = *ExpectedRecord;                                            \
-    auto ExpectedKind = Callbacks.visitTypeBegin(Record);                      \
-    if (!ExpectedKind || *ExpectedKind != Leaf)                                \
-      return ExpectedKind.takeError();                                         \
-    if (auto EC = visitKnownRecord<Name##Record>(Record, Callbacks))           \
-      return EC;                                                               \
-    if (auto EC = Callbacks.visitTypeEnd(Record))                              \
+    if (auto EC = visitKnownMember<Name##Record>(Data, Leaf, Callbacks))       \
       return EC;                                                               \
     break;                                                                     \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
   MEMBER_RECORD(EnumVal, EnumVal, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
     }
   }
   return Error::success();
 }

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

case ename:                                                                  \
     return #name;
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   default:
     break;
   }
   return "UnknownLeaf";
 }
 
-Expected<TypeLeafKind>
-CVTypeDumper::visitTypeBegin(const CVRecord<TypeLeafKind> &Record) {
+Error CVTypeDumper::visitTypeBegin(CVRecord<TypeLeafKind> &Record) {
   // 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 Record.Type;
+  return Error::success();
 }
 
-Error CVTypeDumper::visitTypeEnd(const CVRecord<TypeLeafKind> &Record) {
+Error CVTypeDumper::visitTypeEnd(CVRecord<TypeLeafKind> &Record) {
   if (Record.Type == LF_FIELDLIST) {
     assert(IsInFieldList);
     IsInFieldList = false;
   }
 
   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.Data));
 
   W->unindent();
   W->startLine() << "}\n";
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      FieldListRecord &FieldList) {
   TypeDeserializer Deserializer;
   TypeVisitorCallbackPipeline Pipeline;
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(*this);
 
   CVTypeVisitor Visitor(Pipeline);
   if (auto EC = Visitor.visitFieldListMemberStream(FieldList.Data))
     return EC;
 
   Name = "<field list>";
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      StringIdRecord &String) {
   printTypeIndex("Id", String.getId());
   W->printString("StringData", String.getString());
   // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.
   Name = String.getString();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      ArgListRecord &Args) {
   auto Indices = Args.getIndices();
   uint32_t Size = Indices.size();
   W->printNumber("NumArgs", Size);
   ListScope Arguments(*W, "Arguments");
   SmallString<256> TypeName("(");
   for (uint32_t I = 0; I < Size; ++I) {
     printTypeIndex("ArgType", Indices[I]);
     StringRef ArgTypeName = getTypeName(Indices[I]);
     TypeName.append(ArgTypeName);
     if (I + 1 != Size)
       TypeName.append(", ");
   }
   TypeName.push_back(')');
   Name = saveName(TypeName);
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      ClassRecord &Class) {
   uint16_t Props = static_cast<uint16_t>(Class.getOptions());
   W->printNumber("MemberCount", Class.getMemberCount());
   W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
   printTypeIndex("FieldList", Class.getFieldList());
   printTypeIndex("DerivedFrom", Class.getDerivationList());
   printTypeIndex("VShape", Class.getVTableShape());
   W->printNumber("SizeOf", Class.getSize());
   W->printString("Name", Class.getName());
   if (Props & uint16_t(ClassOptions::HasUniqueName))
     W->printString("LinkageName", Class.getUniqueName());
   Name = Class.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      UnionRecord &Union) {
   uint16_t Props = static_cast<uint16_t>(Union.getOptions());
   W->printNumber("MemberCount", Union.getMemberCount());
   W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
   printTypeIndex("FieldList", Union.getFieldList());
   W->printNumber("SizeOf", Union.getSize());
   W->printString("Name", Union.getName());
   if (Props & uint16_t(ClassOptions::HasUniqueName))
     W->printString("LinkageName", Union.getUniqueName());
   Name = Union.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      EnumRecord &Enum) {
   uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
   W->printNumber("NumEnumerators", Enum.getMemberCount());
   W->printFlags("Properties", uint16_t(Enum.getOptions()),
                 makeArrayRef(ClassOptionNames));
   printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
   printTypeIndex("FieldListType", Enum.getFieldList());
   W->printString("Name", Enum.getName());
   if (Props & uint16_t(ClassOptions::HasUniqueName))
     W->printString("LinkageName", Enum.getUniqueName());
   Name = Enum.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      ArrayRecord &AT) {
   printTypeIndex("ElementType", AT.getElementType());
   printTypeIndex("IndexType", AT.getIndexType());
   W->printNumber("SizeOf", AT.getSize());
   W->printString("Name", AT.getName());
   Name = AT.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      VFTableRecord &VFT) {
   printTypeIndex("CompleteClass", VFT.getCompleteClass());
   printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
   W->printHex("VFPtrOffset", VFT.getVFPtrOffset());
   W->printString("VFTableName", VFT.getName());
   for (auto N : VFT.getMethodNames())
     W->printString("MethodName", N);
   Name = VFT.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      MemberFuncIdRecord &Id) {
   printTypeIndex("ClassType", Id.getClassType());
   printTypeIndex("FunctionType", Id.getFunctionType());
   W->printString("Name", Id.getName());
   Name = Id.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      ProcedureRecord &Proc) {
   printTypeIndex("ReturnType", Proc.getReturnType());
   W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
                makeArrayRef(CallingConventions));
   W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
                 makeArrayRef(FunctionOptionEnum));
   W->printNumber("NumParameters", Proc.getParameterCount());
   printTypeIndex("ArgListType", Proc.getArgumentList());
 
   StringRef ReturnTypeName = getTypeName(Proc.getReturnType());
   StringRef ArgListTypeName = getTypeName(Proc.getArgumentList());
   SmallString<256> TypeName(ReturnTypeName);
   TypeName.push_back(' ');
   TypeName.append(ArgListTypeName);
   Name = saveName(TypeName);
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      MemberFunctionRecord &MF) {
   printTypeIndex("ReturnType", MF.getReturnType());
   printTypeIndex("ClassType", MF.getClassType());
   printTypeIndex("ThisType", MF.getThisType());
   W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
                makeArrayRef(CallingConventions));
   W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
                 makeArrayRef(FunctionOptionEnum));
   W->printNumber("NumParameters", MF.getParameterCount());
   printTypeIndex("ArgListType", MF.getArgumentList());
   W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
 
   StringRef ReturnTypeName = getTypeName(MF.getReturnType());
   StringRef ClassTypeName = getTypeName(MF.getClassType());
   StringRef ArgListTypeName = getTypeName(MF.getArgumentList());
   SmallString<256> TypeName(ReturnTypeName);
   TypeName.push_back(' ');
   TypeName.append(ClassTypeName);
   TypeName.append("::");
   TypeName.append(ArgListTypeName);
   Name = saveName(TypeName);
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      MethodOverloadListRecord &MethodList) {
   for (auto &M : MethodList.getMethods()) {
     ListScope S(*W, "Method");
     printMemberAttributes(M.getAccess(), M.getKind(), M.getOptions());
     printTypeIndex("Type", M.getType());
     if (M.isIntroducingVirtual())
       W->printHex("VFTableOffset", M.getVFTableOffset());
   }
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      FuncIdRecord &Func) {
   printTypeIndex("ParentScope", Func.getParentScope());
   printTypeIndex("FunctionType", Func.getFunctionType());
   W->printString("Name", Func.getName());
   Name = Func.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      TypeServer2Record &TS) {
   W->printBinary("Signature", TS.getGuid());
   W->printNumber("Age", TS.getAge());
   W->printString("Name", TS.getName());
   Name = TS.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      PointerRecord &Ptr) {
   printTypeIndex("PointeeType", Ptr.getReferentType());
   W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
   W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
                makeArrayRef(PtrKindNames));
   W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
 
   W->printNumber("IsFlat", Ptr.isFlat());
else if (Ptr.getMode() == PointerMode::Pointer)
       TypeName.append("*");
 
     if (!TypeName.empty())
       Name = saveName(TypeName);
   }
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      ModifierRecord &Mod) {
   uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
   printTypeIndex("ModifiedType", Mod.getModifiedType());
   W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));
 
   StringRef ModifiedName = getTypeName(Mod.getModifiedType());
   SmallString<256> TypeName;
   if (Mods & uint16_t(ModifierOptions::Const))
     TypeName.append("const ");
   if (Mods & uint16_t(ModifierOptions::Volatile))
     TypeName.append("volatile ");
   if (Mods & uint16_t(ModifierOptions::Unaligned))
     TypeName.append("__unaligned ");
   TypeName.append(ModifiedName);
   Name = saveName(TypeName);
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      BitFieldRecord &BitField) {
   printTypeIndex("Type", BitField.getType());
   W->printNumber("BitSize", BitField.getBitSize());
   W->printNumber("BitOffset", BitField.getBitOffset());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      VFTableShapeRecord &Shape) {
   W->printNumber("VFEntryCount", Shape.getEntryCount());
   Name = saveName("<vftable " + utostr(Shape.getEntryCount()) + " methods>");
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      UdtSourceLineRecord &Line) {
   printTypeIndex("UDT", Line.getUDT());
   printTypeIndex("SourceFile", Line.getSourceFile());
   W->printNumber("LineNumber", Line.getLineNumber());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      UdtModSourceLineRecord &Line) {
   printTypeIndex("UDT", Line.getUDT());
   printTypeIndex("SourceFile", Line.getSourceFile());
   W->printNumber("LineNumber", Line.getLineNumber());
   W->printNumber("Module", Line.getModule());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      BuildInfoRecord &Args) {
   W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
 
   ListScope Arguments(*W, "Arguments");
   for (auto Arg : Args.getArgs()) {
     printTypeIndex("ArgType", Arg);
   }
   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(const CVRecord<TypeLeafKind> &Record) {
+Error CVTypeDumper::visitUnknownMember(CVRecord<TypeLeafKind> &Record) {
   W->printHex("UnknownMember", unsigned(Record.Type));
   return Error::success();
 }
 
-Error CVTypeDumper::visitUnknownType(const CVRecord<TypeLeafKind> &Record) {
+Error CVTypeDumper::visitUnknownType(CVRecord<TypeLeafKind> &Record) {
   W->printEnum("Kind", uint16_t(Record.Type), makeArrayRef(LeafTypeNames));
   W->printNumber("Length", uint32_t(Record.Data.size()));
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      NestedTypeRecord &Nested) {
   printTypeIndex("Type", Nested.getNestedType());
   W->printString("Name", Nested.getName());
   Name = Nested.getName();
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      VFPtrRecord &VFTable) {
   printTypeIndex("Type", VFTable.getType());
   return Error::success();
 }
 
-Error CVTypeDumper::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &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(const CVRecord<TypeLeafKind> &CVR,
+Error CVTypeDumper::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                                      ListContinuationRecord &Cont) {
   printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
   return Error::success();
 }
 
 StringRef CVTypeDumper::getTypeName(TypeIndex TI) {
   if (TI.isNoneType())
     return "<no type>";
Error CVTypeDumper::dump(const CVRecord<TypeLeafKind> &Record) {
   assert(W && "printer should not be null");
   TypeDeserializer Deserializer;
   TypeVisitorCallbackPipeline Pipeline;
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(*this);
 
   CVTypeVisitor Visitor(Pipeline);
 
-  if (auto EC = Visitor.visitTypeRecord(Record))
+  CVRecord<TypeLeafKind> RecordCopy = Record;
+  if (auto EC = Visitor.visitTypeRecord(RecordCopy))
     return EC;
   return Error::success();
 }
 
 Error CVTypeDumper::dump(const CVTypeArray &Types) {
   assert(W && "printer should not be null");
   TypeDeserializer Deserializer;
   TypeVisitorCallbackPipeline Pipeline;

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(const CVRecord<TypeLeafKind> &CVR,                    \
-                         Name##Record &Record) override;
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR, Name##Record &Record)    \
+      override;
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   TYPE_RECORD(EnumName, EnumVal, Name)
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
-  Error visitUnknownType(const CVRecord<TypeLeafKind> &Record) override;
+  Error visitUnknownType(CVRecord<TypeLeafKind> &Record) override;
 
-  Expected<TypeLeafKind>
-  visitTypeBegin(const CVRecord<TypeLeafKind> &Record) override;
-  Error visitTypeEnd(const CVRecord<TypeLeafKind> &Record) override;
+  Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override;
+  Error visitTypeEnd(CVRecord<TypeLeafKind> &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));
private:
 
   /// Map from source type index to destination type index. Indexed by source
   /// type index minus 0x1000.
   SmallVector<TypeIndex, 0> IndexMap;
 };
 
 } // end anonymous namespace
 
-Expected<TypeLeafKind>
-TypeStreamMerger::visitTypeBegin(const CVRecord<TypeLeafKind> &Rec) {
+Error TypeStreamMerger::visitTypeBegin(CVRecord<TypeLeafKind> &Rec) {
   if (Rec.Type == TypeLeafKind::LF_FIELDLIST) {
     assert(!IsInFieldList);
     IsInFieldList = true;
   } else
     BeginIndexMapSize = IndexMap.size();
-  return Rec.Type;
+  return Error::success();
 }
 
-Error TypeStreamMerger::visitTypeEnd(const CVRecord<TypeLeafKind> &Rec) {
+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();
 }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error TypeStreamMerger::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,  \
+  Error TypeStreamMerger::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,        \
                                            Name##Record &Record) {             \
     return visitKnownRecordImpl(Record);                                       \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  Error TypeStreamMerger::visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,  \
+  Error TypeStreamMerger::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,        \
                                            Name##Record &Record) {             \
     return visitKnownMemberRecordImpl(Record);                                 \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
-Error TypeStreamMerger::visitUnknownType(const CVRecord<TypeLeafKind> &Rec) {
+Error TypeStreamMerger::visitUnknownType(CVRecord<TypeLeafKind> &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/CodeView/TypeTableBuilder.cpp

 
 TypeIndex TypeTableBuilder::writeRecord(TypeRecordBuilder &Builder) {
   TypeIndex I = writeRecord(Builder.str());
   RecordKinds.push_back(Builder.kind());
   return I;
 }
 
 TypeIndex TypeTableBuilder::writeFieldList(FieldListRecordBuilder &FieldList) {
-  return FieldList.writeListRecord(*this);
+  TypeIndex I = FieldList.writeListRecord(*this);
+  RecordKinds.push_back(TypeRecordKind::FieldList);
+  return I;
 }
 
 TypeIndex
 TypeTableBuilder::writeKnownType(const MethodOverloadListRecord &Record) {
   TypeRecordBuilder Builder(Record.getKind());
   for (const OneMethodRecord &Method : Record.getMethods()) {
     uint16_t Flags = static_cast<uint16_t>(Method.getAccess());
     Flags |= static_cast<uint16_t>(Method.getKind())

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

 
 namespace {
 class TpiHashVerifier : public TypeVisitorCallbacks {
 public:
   TpiHashVerifier(FixedStreamArray<support::ulittle32_t> &HashValues,
                   uint32_t NumHashBuckets)
       : HashValues(HashValues), NumHashBuckets(NumHashBuckets) {}
 
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                          UdtSourceLineRecord &Rec) override {
     return verifySourceLine(Rec);
   }
 
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                          UdtModSourceLineRecord &Rec) override {
     return verifySourceLine(Rec);
   }
 
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                          ClassRecord &Rec) override {
     return verify(Rec);
   }
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                          EnumRecord &Rec) override {
     return verify(Rec);
   }
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,
+  Error visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
                          UnionRecord &Rec) override {
     return verify(Rec);
   }
 
-  Expected<TypeLeafKind>
-  visitTypeBegin(const CVRecord<TypeLeafKind> &Rec) override {
+  Error visitTypeBegin(CVRecord<TypeLeafKind> &Rec) override {
     ++Index;
     RawRecord = Rec;
-    return Rec.Type;
+    return Error::success();
   }
 
 private:
   template <typename T> Error verify(T &Rec) {
     uint32_t Hash = getTpiHash(Rec, RawRecord);
     if (Hash % NumHashBuckets != HashValues[Index])
       return errorInvalidHash();
     return Error::success();

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 Expected<TypeLeafKind>
-  visitTypeBegin(const CVRecord<TypeLeafKind> &Record) override;
+  virtual Error visitTypeBegin(CVRecord<TypeLeafKind> &Record) override;
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  Error visitKnownRecord(const CVRecord<TypeLeafKind> &CVR,                    \
-                         Name##Record &Record) override {                      \
+  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)
 #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 visitKnownRecordImpl(const char *Name, const CVType &Type, T &Record) {
+  void visitKnownRecordImpl(const char *Name, CVType &Type, T &Record) {
     YamlIO.mapRequired(Name, Record);
   }
 
-  void visitKnownRecordImpl(const char *Name, const CVType &CVR,
+  void visitKnownRecordImpl(const char *Name, CVType &CVR,
                             FieldListRecord &FieldList);
 
   llvm::yaml::IO &YamlIO;
   llvm::pdb::yaml::SerializationContext &Context;
 };
 }
 }
 namespace pdb {

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

public:
   explicit FieldListRecordSplitter(
       std::vector<llvm::pdb::yaml::PdbTpiRecord> &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(const CVType &CVT, Name##Record &Record) override {   \
+  Error visitKnownRecord(CVType &CVT, Name##Record &Record) override {         \
     visitKnownRecordImpl(CVT);                                                 \
     return Error::success();                                                   \
   }
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
 private:
-  void visitKnownRecordImpl(const CVType &CVT) {
+  void visitKnownRecordImpl(CVType &CVT) {
     llvm::pdb::yaml::PdbTpiRecord R;
     R.Record = CVT;
     Records.push_back(std::move(R));
   }
 
   std::vector<llvm::pdb::yaml::PdbTpiRecord> &Records;
 };
 }
void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
                                                         TypeLeafKind &Value) {
   auto TypeLeafNames = getTypeLeafNames();
   for (const auto &E : TypeLeafNames)
     io.enumCase(Value, E.Name.str().c_str(), E.Value);
 }
 }
 }
 
-Expected<TypeLeafKind>
-llvm::codeview::yaml::YamlTypeDumperCallbacks::visitTypeBegin(
-    const CVRecord<TypeLeafKind> &CVR) {
-  // When we're outputting, `CVR.Type` already has the right value in it.  But
-  // when we're inputting, we need to read the value.  Since `CVR.Type` is const
-  // we do it into a temp variable.
-  TypeLeafKind K = CVR.Type;
-  YamlIO.mapRequired("Kind", K);
-  return K;
+Error llvm::codeview::yaml::YamlTypeDumperCallbacks::visitTypeBegin(
+    CVRecord<TypeLeafKind> &CVR) {
+  YamlIO.mapRequired("Kind", CVR.Type);
+  return Error::success();
 }
 
 void llvm::codeview::yaml::YamlTypeDumperCallbacks::visitKnownRecordImpl(
-    const char *Name, const CVType &CVR, FieldListRecord &FieldList) {
+    const char *Name, CVType &CVR, FieldListRecord &FieldList) {
   std::vector<llvm::pdb::yaml::PdbTpiRecord> 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

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

if (IO.outputting()) {
     // For Yaml to PDB, extract from the high level record type, then write it
     // to bytes.
     Pipeline.addCallbackToPipeline(Context.Dumper);
     Pipeline.addCallbackToPipeline(Serializer);
   }
 
   codeview::CVTypeVisitor Visitor(Pipeline);
   consumeError(Visitor.visitTypeRecord(Obj.Record));
-
-  if (!IO.outputting()) {
-    // For Yaml to PDB, we need to update the input Object with the bytes for
-    // this record.
-    ArrayRef<StringRef> Records = Context.TypeTableBuilder.getRecords();
-    ArrayRef<codeview::TypeRecordKind> Kinds =
-        Context.TypeTableBuilder.getRecordKinds();
-
-    StringRef ThisRecord = Records.back();
-    Obj.Record.Type = static_cast<codeview::TypeLeafKind>(Kinds.back());
-    Obj.Record.Data =
-        ArrayRef<uint8_t>(ThisRecord.bytes_begin(), ThisRecord.bytes_end());
-    Obj.Record.RawData = Obj.Record.Data;
-    Obj.Record.Length = ThisRecord.size();
-  }
 }