[LLD][COFF] Move type merging structures out of PDB.cpp. NFC

[aganea]

Summary

Introduce a new TypeMerger class, out of some type-merge-specific structures from PDB.cpp

No changes intended / this is only moving code around.

This patch is step 3. in "Proposed commit strategy" in D59226

[rnk]

lgtm

COFF/TypeMerger.h

20 ↗

(On Diff #193105)

This thing actually has methods, and maybe one day it will have private members, so let's make it a class:
https://llvm.org/docs/CodingStandards.html#use-of-class-and-struct-keywords

lld/COFF/PDB.cpp

 //===- PDB.cpp ------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PDB.h"
 #include "Chunks.h"
 #include "Config.h"
 #include "DebugTypes.h"
 #include "Driver.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "TypeMerger.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Timer.h"
 #include "lld/Common/Threads.h"
 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"

 static Timer AddObjectsTimer("Add Objects", TotalPdbLinkTimer);
 static Timer TypeMergingTimer("Type Merging", AddObjectsTimer);
 static Timer SymbolMergingTimer("Symbol Merging", AddObjectsTimer);
 static Timer GlobalsLayoutTimer("Globals Stream Layout", TotalPdbLinkTimer);
 static Timer TpiStreamLayoutTimer("TPI Stream Layout", TotalPdbLinkTimer);
 static Timer DiskCommitTimer("Commit to Disk", TotalPdbLinkTimer);
 
 namespace {
-/// Map from type index and item index in a type server PDB to the
-/// corresponding index in the destination PDB.
-struct CVIndexMap {
-  SmallVector<TypeIndex, 0> TPIMap;
-  SmallVector<TypeIndex, 0> IPIMap;
-  bool IsTypeServerMap = false;
-  bool IsPrecompiledTypeMap = false;
-};
-
 class DebugSHandler;
 
 class PDBLinker {
   friend DebugSHandler;
 
 public:
   PDBLinker(SymbolTable *Symtab)
-      : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
-        IDTable(Alloc), GlobalTypeTable(Alloc), GlobalIDTable(Alloc) {
+      : Alloc(), Symtab(Symtab), Builder(Alloc), TMerger(Alloc) {
     // This isn't strictly necessary, but link.exe usually puts an empty string
     // as the first "valid" string in the string table, so we do the same in
     // order to maintain as much byte-for-byte compatibility as possible.
     PDBStrTab.insert("");
   }
 
   /// Emit the basic PDB structure: initial streams, headers, etc.
   void initialize(llvm::codeview::DebugInfo *BuildId);
public:
   void mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
                           std::vector<ulittle32_t *> &StringTableRefs,
                           BinaryStreamRef SymData);
 
   /// Add the section map and section contributions to the PDB.
   void addSections(ArrayRef<OutputSection *> OutputSections,
                    ArrayRef<uint8_t> SectionTable);
 
-  /// Get the type table or the global type table if /DEBUG:GHASH is enabled.
-  TypeCollection &getTypeTable() {
-    if (Config->DebugGHashes)
-      return GlobalTypeTable;
-    return TypeTable;
-  }
-
-  /// Get the ID table or the global ID table if /DEBUG:GHASH is enabled.
-  TypeCollection &getIDTable() {
-    if (Config->DebugGHashes)
-      return GlobalIDTable;
-    return IDTable;
-  }
-
   /// Write the PDB to disk and store the Guid generated for it in *Guid.
   void commit(codeview::GUID *Guid);
 
   // Print statistics regarding the final PDB
   void printStats();
 
 private:
   BumpPtrAllocator Alloc;
 
   SymbolTable *Symtab;
 
   pdb::PDBFileBuilder Builder;
 
-  /// Type records that will go into the PDB TPI stream.
-  MergingTypeTableBuilder TypeTable;
-
-  /// Item records that will go into the PDB IPI stream.
-  MergingTypeTableBuilder IDTable;
-
-  /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
-  GlobalTypeTableBuilder GlobalTypeTable;
-
-  /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
-  GlobalTypeTableBuilder GlobalIDTable;
+  TypeMerger TMerger;
 
   /// PDBs use a single global string table for filenames in the file checksum
   /// table.
   DebugStringTableSubsection PDBStrTab;
 
   llvm::SmallString<128> NativePath;
 
   /// A list of other PDBs which are loaded during the linking process and which
if (Config->DebugGHashes) {
     std::vector<GloballyHashedType> OwnedHashes;
     if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File))
       Hashes = getHashesFromDebugH(*DebugH);
     else {
       OwnedHashes = GloballyHashedType::hashTypes(Types);
       Hashes = OwnedHashes;
     }
 
-    if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
-                                         ObjectIndexMap->TPIMap, Types, Hashes,
-                                         File->PCHSignature))
+    if (auto Err = mergeTypeAndIdRecords(
+            TMerger.GlobalIDTable, TMerger.GlobalTypeTable,
+            ObjectIndexMap->TPIMap, Types, Hashes, File->PCHSignature))
       fatal("codeview::mergeTypeAndIdRecords failed: " +
             toString(std::move(Err)));
   } else {
-    if (auto Err =
-            mergeTypeAndIdRecords(IDTable, TypeTable, ObjectIndexMap->TPIMap,
-                                  Types, File->PCHSignature))
+    if (auto Err = mergeTypeAndIdRecords(TMerger.IDTable, TMerger.TypeTable,
+                                         ObjectIndexMap->TPIMap, Types,
+                                         File->PCHSignature))
       fatal("codeview::mergeTypeAndIdRecords failed: " +
             toString(std::move(Err)));
   }
   return *ObjectIndexMap;
 }
 
 static Expected<std::unique_ptr<pdb::NativeSession>>
 tryToLoadPDB(const codeview::GUID &GuidFromObj, StringRef TSPath) {
if (Config->DebugGHashes) {
     // synthesize hashes for the IPI stream, using the hashes for the TPI stream
     // as inputs.
     auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
     auto IpiHashes =
         GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
 
     Optional<uint32_t> EndPrecomp;
     // Merge TPI first, because the IPI stream will reference type indices.
-    if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
-                                    ExpectedTpi->typeArray(), TpiHashes, EndPrecomp))
+    if (auto Err =
+            mergeTypeRecords(TMerger.GlobalTypeTable, IndexMap.TPIMap,
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
-    if (auto Err =
-            mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
-                           ExpectedIpi->typeArray(), IpiHashes))
+    if (auto Err = mergeIdRecords(TMerger.GlobalIDTable, IndexMap.TPIMap,
+                                  IndexMap.IPIMap, ExpectedIpi->typeArray(),
+                                  IpiHashes))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   } else {
     // Merge TPI first, because the IPI stream will reference type indices.
-    if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
+    if (auto Err = mergeTypeRecords(TMerger.TypeTable, IndexMap.TPIMap,
                                     ExpectedTpi->typeArray()))
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
-    if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
-                                  ExpectedIpi->typeArray()))
+    if (auto Err = mergeIdRecords(TMerger.IDTable, IndexMap.TPIMap,
+                                  IndexMap.IPIMap, ExpectedIpi->typeArray()))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   }
 
   return IndexMap;
 }
 
 Error PDBLinker::mergeInPrecompHeaderObj(ObjFile *File,
                                          CVIndexMap *ObjectIndexMap) {
cantFail(forEachCodeViewRecord<CVSymbol>(
         }
 
         // Re-map all the type index references.
         remapTypesInSymbolRecord(File, Sym.kind(), RecordBytes, IndexMap,
                                  TypeRefs);
 
         // An object file may have S_xxx_ID symbols, but these get converted to
         // "real" symbols in a PDB.
-        translateIdSymbols(RecordBytes, getIDTable());
+        translateIdSymbols(RecordBytes, TMerger.getIDTable());
         Sym = CVSymbol(symbolKind(RecordBytes), RecordBytes);
 
         // If this record refers to an offset in the object file's string table,
         // add that item to the global PDB string table and re-write the index.
         recordStringTableReferences(Sym.kind(), RecordBytes, StringTableRefs);
 
         // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
         if (symbolOpensScope(Sym.kind()))
void PDBLinker::addObjectsToPDB() {
   for (ObjFile *File : ObjFile::Instances)
     addObjFile(File);
 
   Builder.getStringTableBuilder().setStrings(PDBStrTab);
   T1.stop();
 
   // Construct TPI and IPI stream contents.
   ScopedTimer T2(TpiStreamLayoutTimer);
-  addTypeInfo(Builder.getTpiBuilder(), getTypeTable());
-  addTypeInfo(Builder.getIpiBuilder(), getIDTable());
+  addTypeInfo(Builder.getTpiBuilder(), TMerger.getTypeTable());
+  addTypeInfo(Builder.getIpiBuilder(), TMerger.getIDTable());
   T2.stop();
 
   ScopedTimer T3(GlobalsLayoutTimer);
   // Compute the public and global symbols.
   auto &GsiBuilder = Builder.getGsiBuilder();
   std::vector<PublicSym32> Publics;
   Symtab->forEachSymbol([&Publics](Symbol *S) {
     // Only emit defined, live symbols that have a chunk.
void PDBLinker::printStats() {
   auto Print = [&](uint64_t V, StringRef S) {
     Stream << format_decimal(V, 15) << " " << S << '\n';
   };
 
   Print(ObjFile::Instances.size(),
         "Input OBJ files (expanded from all cmd-line inputs)");
   Print(TypeServerIndexMappings.size(), "PDB type server dependencies");
   Print(PrecompTypeIndexMappings.size(), "Precomp OBJ dependencies");
-  Print(getTypeTable().size() + getIDTable().size(), "Merged TPI records");
+  Print(TMerger.getTypeTable().size() + TMerger.getIDTable().size(),
+        "Merged TPI records");
   Print(PDBStrTab.size(), "Output PDB strings");
   Print(GlobalSymbols, "Global symbol records");
   Print(ModuleSymbols, "Module symbol records");
   Print(PublicSymbols, "Public symbol records");
 
   message(Buffer);
 }
 

lld/COFF/TypeMerger.h

+//===- TypeMerger.h ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_TYPEMERGER_H
+#define LLD_COFF_TYPEMERGER_H
+
+#include "Config.h"
+#include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
+#include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
+#include "llvm/Support/Allocator.h"
+
+namespace lld {
+namespace coff {
+
+class TypeMerger {
+public:
+  TypeMerger(llvm::BumpPtrAllocator &Alloc)
+      : TypeTable(Alloc), IDTable(Alloc), GlobalTypeTable(Alloc),
+        GlobalIDTable(Alloc) {}
+
+  /// Get the type table or the global type table if /DEBUG:GHASH is enabled.
+  inline llvm::codeview::TypeCollection &getTypeTable() {
+    if (Config->DebugGHashes)
+      return GlobalTypeTable;
+    return TypeTable;
+  }
+
+  /// Get the ID table or the global ID table if /DEBUG:GHASH is enabled.
+  inline llvm::codeview::TypeCollection &getIDTable() {
+    if (Config->DebugGHashes)
+      return GlobalIDTable;
+    return IDTable;
+  }
+
+  /// Type records that will go into the PDB TPI stream.
+  llvm::codeview::MergingTypeTableBuilder TypeTable;
+
+  /// Item records that will go into the PDB IPI stream.
+  llvm::codeview::MergingTypeTableBuilder IDTable;
+
+  /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
+  llvm::codeview::GlobalTypeTableBuilder GlobalTypeTable;
+
+  /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
+  llvm::codeview::GlobalTypeTableBuilder GlobalIDTable;
+};
+
+/// Map from type index and item index in a type server PDB to the
+/// corresponding index in the destination PDB.
+struct CVIndexMap {
+  llvm::SmallVector<llvm::codeview::TypeIndex, 0> TPIMap;
+  llvm::SmallVector<llvm::codeview::TypeIndex, 0> IPIMap;
+  bool IsTypeServerMap = false;
+  bool IsPrecompiledTypeMap = false;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif
 No newline at end of file