[codeview] Pass CVRecord to visitTypeBegin callback.

[ruiu]

Summary

Both parameters to visitTypeBegin are actually members of CVRecord,
so we can just pass CVRecord instead of destructuring it.

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

 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   void visit##Name(Name##Record &Record) {}
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
   void visitTypeRecord(const CVRecord<TypeLeafKind> &Record) {
     ArrayRef<uint8_t> LeafData = Record.Data;
-    ArrayRef<uint8_t> RecordData = LeafData;
     auto *DerivedThis = static_cast<Derived *>(this);
-    DerivedThis->visitTypeBegin(Record.Type, RecordData);
+    DerivedThis->visitTypeBegin(Record);
     switch (Record.Type) {
     default:
-      DerivedThis->visitUnknownType(Record.Type, RecordData);
+      DerivedThis->visitUnknownType(Record);
       break;
     case LF_FIELDLIST:
       DerivedThis->visitFieldList(Record.Type, LeafData);
       break;
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   case EnumName: {                                                             \
     TypeRecordKind RK = static_cast<TypeRecordKind>(EnumName);                 \
     auto Result = Name##Record::deserialize(RK, LeafData);                     \
     if (Result.getError())                                                     \
       return parseError();                                                     \
     DerivedThis->visit##Name(*Result);                                         \
     break;                                                                     \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                  \
   TYPE_RECORD(EnumVal, EnumVal, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)
 #include "TypeRecords.def"
       }
-      DerivedThis->visitTypeEnd(Record.Type, RecordData);
+      DerivedThis->visitTypeEnd(Record);
   }
 
   /// Visits the type records in Data. Sets the error flag on parse failures.
   void visitTypeStream(const CVTypeArray &Types) {
     for (const auto &I : Types) {
       visitTypeRecord(I);
       if (hadError())
         break;
     }
   }
 
   /// Action to take on unknown types. By default, they are ignored.
-  void visitUnknownType(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {}
+  void visitUnknownType(const CVRecord<TypeLeafKind> &Record) {}
 
   /// Paired begin/end actions for all types. Receives all record data,
   /// including the fixed-length record prefix.
-  void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {}
-  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {}
+  void visitTypeBegin(const CVRecord<TypeLeafKind> &Record) {}
+  void visitTypeEnd(const CVRecord<TypeLeafKind> &Record) {}
 
   ArrayRef<uint8_t> skipPadding(ArrayRef<uint8_t> Data) {
     if (Data.empty())
       return Data;
     uint8_t Leaf = Data.front();
     if (Leaf < LF_PAD0)
       return Data;
     // Leaf is greater than 0xf0. We should advance by the number of bytes in

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

#define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   void visit##Name(Name##Record &Record);
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   void visit##Name(Name##Record &Record);
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
   void visitUnknownMember(TypeLeafKind Leaf);
-  void visitUnknownType(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
+  void visitUnknownType(const CVRecord<TypeLeafKind> &Record);
 
-  void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
-  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
+  void visitTypeBegin(const CVRecord<TypeLeafKind> &Record);
+  void visitTypeEnd(const CVRecord<TypeLeafKind> &Record);
 
   void printMemberAttributes(MemberAttributes Attrs);
   void printMemberAttributes(MemberAccess Access, MethodKind Kind,
                              MethodOptions Options);
 
 private:
   /// Forwards to the dumper, which holds the persistent state from visitation.
   StringRef getTypeName(TypeIndex TI) {
case ename:                                                                  \
     return #name;
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
   default:
     break;
   }
   return "UnknownLeaf";
 }
 
-void CVTypeDumperImpl::visitTypeBegin(TypeLeafKind Leaf,
-                                      ArrayRef<uint8_t> LeafData) {
+void CVTypeDumperImpl::visitTypeBegin(const CVRecord<TypeLeafKind> &Rec) {
   // Reset Name to the empty string. If the visitor sets it, we know it.
   Name = "";
 
-  W.startLine() << getLeafTypeName(Leaf) << " ("
+  W.startLine() << getLeafTypeName(Rec.Type) << " ("
                 << HexNumber(CVTD.getNextTypeIndex()) << ") {\n";
   W.indent();
-  W.printEnum("TypeLeafKind", unsigned(Leaf), makeArrayRef(LeafTypeNames));
+  W.printEnum("TypeLeafKind", unsigned(Rec.Type), makeArrayRef(LeafTypeNames));
 }
 
-void CVTypeDumperImpl::visitTypeEnd(TypeLeafKind Leaf,
-                                    ArrayRef<uint8_t> LeafData) {
+void CVTypeDumperImpl::visitTypeEnd(const CVRecord<TypeLeafKind> &Rec) {
   // Always record some name for every type, even if Name is empty. CVUDTNames
   // is indexed by type index, and must have one entry for every type.
   CVTD.recordType(Name);
-
   if (PrintRecordBytes)
-    W.printBinaryBlock("LeafData", getBytesAsCharacters(LeafData));
+    W.printBinaryBlock("LeafData", getBytesAsCharacters(Rec.Data));
 
   W.unindent();
   W.startLine() << "}\n";
 }
 
 void CVTypeDumperImpl::visitStringId(StringIdRecord &String) {
   printTypeIndex("Id", String.getId());
   W.printString("StringData", String.getString());
W.printFlags("MethodOptions", unsigned(Options),
                  makeArrayRef(MethodOptionNames));
   }
 }
 
 void CVTypeDumperImpl::visitUnknownMember(TypeLeafKind Leaf) {
   W.printHex("UnknownMember", unsigned(Leaf));
 }
 
-void CVTypeDumperImpl::visitUnknownType(TypeLeafKind Leaf,
-                                        ArrayRef<uint8_t> RecordData) {
+void CVTypeDumperImpl::visitUnknownType(const CVRecord<TypeLeafKind> &Rec) {
   DictScope S(W, "UnknownType");
-  W.printEnum("Kind", uint16_t(Leaf), makeArrayRef(LeafTypeNames));
-  W.printNumber("Length", uint32_t(RecordData.size()));
+  W.printEnum("Kind", uint16_t(Rec.Type), makeArrayRef(LeafTypeNames));
+  W.printNumber("Length", uint32_t(Rec.Data.size()));
 }
 
 void CVTypeDumperImpl::visitNestedType(NestedTypeRecord &Nested) {
   DictScope S(W, "NestedType");
   printTypeIndex("Type", Nested.getNestedType());
   W.printString("Name", Nested.getName());
   Name = Nested.getName();
 }

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

 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   void visit##Name(Name##Record &Record);
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   void visit##Name(Name##Record &Record);
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
-  void visitUnknownType(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
+  void visitUnknownType(const CVRecord<TypeLeafKind> &Record);
 
-  void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
-  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
+  void visitTypeBegin(const CVRecord<TypeLeafKind> &Record);
+  void visitTypeEnd(const CVRecord<TypeLeafKind> &Record);
 
   void visitFieldList(TypeLeafKind Leaf, ArrayRef<uint8_t> FieldData);
 
   bool mergeStream(const CVTypeArray &Types);
 
 private:
   bool hadError() { return FoundBadTypeIndex || CVTypeVisitor::hadError(); }
 
   bool FoundBadTypeIndex = false;
 
   FieldListRecordBuilder FieldBuilder;
 
   TypeTableBuilder &DestStream;
 
   size_t BeginIndexMapSize = 0;
 
   /// Map from source type index to destination type index. Indexed by source
   /// type index minus 0x1000.
   SmallVector<TypeIndex, 0> IndexMap;
 };
 
 } // end anonymous namespace
 
-void TypeStreamMerger::visitTypeBegin(TypeLeafKind Leaf,
-                                      ArrayRef<uint8_t> RecordData) {
+void TypeStreamMerger::visitTypeBegin(const CVRecord<TypeLeafKind> &Rec) {
   BeginIndexMapSize = IndexMap.size();
 }
 
-void TypeStreamMerger::visitTypeEnd(TypeLeafKind Leaf,
-                                    ArrayRef<uint8_t> RecordData) {
+void TypeStreamMerger::visitTypeEnd(const CVRecord<TypeLeafKind> &Rec) {
   assert(IndexMap.size() == BeginIndexMapSize + 1);
 }
 
 void TypeStreamMerger::visitFieldList(TypeLeafKind Leaf,
                                       ArrayRef<uint8_t> FieldData) {
   CVTypeVisitor::visitFieldList(Leaf, FieldData);
   IndexMap.push_back(DestStream.writeFieldList(FieldBuilder));
   FieldBuilder.reset();
 }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   void TypeStreamMerger::visit##Name(Name##Record &Record) {                   \
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);                   \
     IndexMap.push_back(DestStream.write##Name(Record));                        \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   void TypeStreamMerger::visit##Name(Name##Record &Record) {                   \
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);                   \
     FieldBuilder.write##Name(Record);                                          \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
-void TypeStreamMerger::visitUnknownType(TypeLeafKind Leaf,
-                                        ArrayRef<uint8_t> RecordData) {
+void TypeStreamMerger::visitUnknownType(const CVRecord<TypeLeafKind> &Rec) {
   // We failed to translate a type. Translate this index as "not translated".
   IndexMap.push_back(
       TypeIndex(SimpleTypeKind::NotTranslated, SimpleTypeMode::Direct));
   parseError();
 }
 
 bool TypeStreamMerger::mergeStream(const CVTypeArray &Types) {
   assert(IndexMap.empty());

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

public:
   }
 
   void visitClass(ClassRecord &Rec) { verify(Rec); }
   void visitEnum(EnumRecord &Rec) { verify(Rec); }
   void visitInterface(ClassRecord &Rec) { verify(Rec); }
   void visitStruct(ClassRecord &Rec) { verify(Rec); }
   void visitUnion(UnionRecord &Rec) { verify(Rec); }
 
-  void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {
-    ++Index;
-  }
+  void visitTypeEnd(const CVRecord<TypeLeafKind> &Record) { ++Index; }
 
 private:
   template <typename T> void verify(T &Rec) {
     uint32_t Hash = getTpiHash(Rec);
     if (Hash && Hash % NumHashBuckets != HashValues[Index])
       parseError();
   }