Don't keep re-allocating the temp serializer.

[zturner]

Summary

Previously, every time we wanted to serialize a field list record, we would create a new copy of FieldListRecordBuilder, which would in turn create a temporary instance of TypeSerializer, which itself had a std::vector<> that was about 128K in size. So this 128K allocation was happening every time. We can re-use the same instance over and over, we just have to clear its internal hash table and seen records list between each run. This saves us from the constant re-allocations.

This is worth an ~18.5% speed increase (3.75s -> 3.05s) in my tests.

[rnk]

lgtm

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

class TypeSerializer : public TypeVisitorCallbacks {
 
   Expected<MutableArrayRef<uint8_t>>
   addPadding(MutableArrayRef<uint8_t> Record);
 
 public:
   explicit TypeSerializer(BumpPtrAllocator &Storage, bool Hash = true);
   ~TypeSerializer();
 
+  void reset();
+
   ArrayRef<ArrayRef<uint8_t>> records() const;
   TypeIndex insertRecordBytes(ArrayRef<uint8_t> &Record);
   TypeIndex insertRecord(const RemappedType &Record);
   Expected<TypeIndex> visitTypeEndGetIndex(CVType &Record);
 
   Error visitTypeBegin(CVType &Record) override;
   Error visitTypeEnd(CVType &Record) override;
   Error visitMemberBegin(CVMemberRecord &Record) override;

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

 
 public:
   explicit FieldListRecordBuilder(TypeTableBuilder &TypeTable)
       : TypeTable(TypeTable), TempSerializer(Allocator, false) {
     Type.Type = TypeLeafKind::LF_FIELDLIST;
   }
 
   void begin() {
+    TempSerializer.reset();
+
     if (auto EC = TempSerializer.visitTypeBegin(Type))
       consumeError(std::move(EC));
   }
 
   template <typename T> void writeMemberType(T &Record) {
     CVMemberRecord CVMR;
     CVMR.Kind = static_cast<TypeLeafKind>(Record.getKind());
     if (auto EC = TempSerializer.visitMemberBegin(CVMR))
       consumeError(std::move(EC));
     if (auto EC = TempSerializer.visitKnownMember(CVMR, Record))
       consumeError(std::move(EC));
     if (auto EC = TempSerializer.visitMemberEnd(CVMR))
       consumeError(std::move(EC));
   }
 
-  TypeIndex end() {
+  TypeIndex end(bool Write) {
+    TypeIndex Index;
     if (auto EC = TempSerializer.visitTypeEnd(Type)) {
       consumeError(std::move(EC));
       return TypeIndex();
     }
 
-    TypeIndex Index;
-    for (auto Record : TempSerializer.records()) {
+    if (Write) {
+      for (auto Record : TempSerializer.records())
         Index = TypeTable.writeSerializedRecord(Record);
     }
-    return Index;
-  }
 
-  /// Stop building the record.
-  void reset() {
-    if (auto EC = TempSerializer.visitTypeEnd(Type))
-      consumeError(std::move(EC));
+    return Index;
   }
 };
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_TYPETABLEBUILDER_H

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

for (const DINode *Element : Ty->getElements()) {
       if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
         EnumeratorRecord ER(MemberAccess::Public,
                             APSInt::getUnsigned(Enumerator->getValue()),
                             Enumerator->getName());
         FLRB.writeMemberType(ER);
         EnumeratorCount++;
       }
     }
-    FTI = FLRB.end();
+    FTI = FLRB.end(true);
   }
 
   std::string FullName = getFullyQualifiedName(Ty);
 
   EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
                 getTypeIndex(Ty->getBaseType()));
   return TypeTable.writeKnownType(ER);
 }
CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
 
   // Create nested classes.
   for (const DICompositeType *Nested : Info.NestedClasses) {
     NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
     FLBR.writeMemberType(R);
     MemberCount++;
   }
 
-  TypeIndex FieldTI = FLBR.end();
+  TypeIndex FieldTI = FLBR.end(true);
   return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount,
                          !Info.NestedClasses.empty());
 }
 
 TypeIndex CodeViewDebug::getVBPTypeIndex() {
   if (!VBPType.getIndex()) {
     // Make a 'const int *' type.
     ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);

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

private:
   /// because it recomputes the hash value of every key when it grows. This
   /// value type stores the hash out of line in KeyStorage, so that table
   /// entries are small and easy to rehash.
   DenseSet<HashedTypePtr> HashedRecords;
 
 public:
   TypeHasher(BumpPtrAllocator &RecordStorage) : RecordStorage(RecordStorage) {}
 
+  void reset() { HashedRecords.clear(); }
+
   /// Takes the bytes of type record, inserts them into the hash table, saves
   /// them, and returns a pointer to an identical stable type record along with
   /// its type index in the destination stream.
   TypeIndex getOrCreateRecord(ArrayRef<uint8_t> &Record, TypeIndex TI);
 };
 
 TypeIndex TypeHasher::getOrCreateRecord(ArrayRef<uint8_t> &Record,
                                         TypeIndex TI) {

 }
 
 TypeSerializer::~TypeSerializer() = default;
 
 ArrayRef<ArrayRef<uint8_t>> TypeSerializer::records() const {
   return SeenRecords;
 }
 
+void TypeSerializer::reset() {
+  if (Hasher)
+    Hasher->reset();
+  Writer.setOffset(0);
+  CurrentSegment = RecordSegment();
+  FieldListSegments.clear();
+  TypeKind.reset();
+  MemberKind.reset();
+  SeenRecords.clear();
+}
+
 TypeIndex TypeSerializer::insertRecordBytes(ArrayRef<uint8_t> &Record) {
   assert(!TypeKind.hasValue() && "Already in a type mapping!");
   assert(Writer.getOffset() == 0 && "Stream has data already!");
 
   if (Hasher) {
     TypeIndex ActualTI = Hasher->getOrCreateRecord(Record, nextTypeIndex());
     if (nextTypeIndex() == ActualTI)
       SeenRecords.push_back(Record);

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

for (OneMethodRecord &Meth : R.Methods)
     Success &= remapTypeIndex(Meth.Type);
   return writeKnownTypeRecord(R, Success);
 }
 
 Error TypeStreamMerger::visitKnownRecord(CVType &CVR, FieldListRecord &R) {
   assert(DestTypeStream);
   // Visit the members inside the field list.
   HadUntranslatedMember = false;
-  FieldListBuilder = llvm::make_unique<FieldListRecordBuilder>(*DestTypeStream);
+  if (!FieldListBuilder)
+    FieldListBuilder =
+        llvm::make_unique<FieldListRecordBuilder>(*DestTypeStream);
 
   FieldListBuilder->begin();
   if (auto EC = codeview::visitMemberRecordStream(CVR.content(), *this))
     return EC;
 
   // Write the record if we translated all field list members.
-  TypeIndex DestIdx = Untranslated;
-  if (!HadUntranslatedMember)
-    DestIdx = FieldListBuilder->end();
-  else
-    FieldListBuilder->reset();
-  addMapping(DestIdx);
+  TypeIndex DestIdx = FieldListBuilder->end(!HadUntranslatedMember);
+  addMapping(HadUntranslatedMember ? Untranslated : DestIdx);
 
-  FieldListBuilder.reset();
   return Error::success();
 }
 
 //----------------------------------------------------------------------------//
 // Member records
 //----------------------------------------------------------------------------//
 
 Error TypeStreamMerger::visitKnownMember(CVMemberRecord &,