[PDB] Use one func id DenseMap instead of per-source maps, NFC
[lldb.git] / lld / COFF / DebugTypes.h
1 //===- DebugTypes.h ---------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #ifndef LLD_COFF_DEBUGTYPES_H
10 #define LLD_COFF_DEBUGTYPES_H
11
12 #include "lld/Common/LLVM.h"
13 #include "llvm/ADT/BitVector.h"
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
16 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
17 #include "llvm/Support/Error.h"
18 #include "llvm/Support/MemoryBuffer.h"
19
20 namespace llvm {
21 namespace codeview {
22 struct GloballyHashedType;
23 } // namespace codeview
24 namespace pdb {
25 class NativeSession;
26 class TpiStream;
27 }
28 } // namespace llvm
29
30 namespace lld {
31 namespace coff {
32
33 using llvm::codeview::GloballyHashedType;
34 using llvm::codeview::TypeIndex;
35
36 class ObjFile;
37 class PDBInputFile;
38 class TypeMerger;
39 struct GHashState;
40
41 class TpiSource {
42 public:
43   enum TpiKind : uint8_t { Regular, PCH, UsingPCH, PDB, PDBIpi, UsingPDB };
44
45   TpiSource(TpiKind k, ObjFile *f);
46   virtual ~TpiSource();
47
48   /// Produce a mapping from the type and item indices used in the object
49   /// file to those in the destination PDB.
50   ///
51   /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
52   /// and IPI from the type server PDB and return a map for it. Each unique type
53   /// server PDB is merged at most once, so this may return an existing index
54   /// mapping.
55   ///
56   /// If the object does not use a type server PDB (compiled with /Z7), we merge
57   /// all the type and item records from the .debug$S stream and fill in the
58   /// caller-provided ObjectIndexMap.
59   virtual Error mergeDebugT(TypeMerger *m);
60
61   /// Load global hashes, either by hashing types directly, or by loading them
62   /// from LLVM's .debug$H section.
63   virtual void loadGHashes();
64
65   /// Use global hashes to merge type information.
66   virtual void remapTpiWithGHashes(GHashState *g);
67
68   // Remap a type index in place.
69   bool remapTypeIndex(TypeIndex &ti, llvm::codeview::TiRefKind refKind) const;
70
71 protected:
72   void remapRecord(MutableArrayRef<uint8_t> rec,
73                    ArrayRef<llvm::codeview::TiReference> typeRefs);
74
75   void mergeTypeRecord(TypeIndex curIndex, llvm::codeview::CVType ty);
76
77   // Merge the type records listed in uniqueTypes. beginIndex is the TypeIndex
78   // of the first record in this source, typically 0x1000. When PCHs are
79   // involved, it may start higher.
80   void mergeUniqueTypeRecords(
81       ArrayRef<uint8_t> debugTypes,
82       TypeIndex beginIndex = TypeIndex(TypeIndex::FirstNonSimpleIndex));
83
84   // Use the ghash table to construct a map from source type index to
85   // destination PDB type index. Usable for either TPI or IPI.
86   void fillMapFromGHashes(GHashState *m,
87                           llvm::SmallVectorImpl<TypeIndex> &indexMap);
88
89   // Copies ghashes from a vector into an array. These are long lived, so it's
90   // worth the time to copy these into an appropriately sized vector to reduce
91   // memory usage.
92   void assignGHashesFromVector(std::vector<GloballyHashedType> &&hashVec);
93
94   // Walk over file->debugTypes and fill in the isItemIndex bit vector.
95   void fillIsItemIndexFromDebugT();
96
97 public:
98   bool remapTypesInSymbolRecord(MutableArrayRef<uint8_t> rec);
99
100   void remapTypesInTypeRecord(MutableArrayRef<uint8_t> rec);
101
102   /// Is this a dependent file that needs to be processed first, before other
103   /// OBJs?
104   virtual bool isDependency() const { return false; }
105
106   /// Returns true if this type record should be omitted from the PDB, even if
107   /// it is unique. This prevents a record from being added to the input ghash
108   /// table.
109   bool shouldOmitFromPdb(uint32_t ghashIdx) {
110     return ghashIdx == endPrecompGHashIdx;
111   }
112
113   /// All sources of type information in the program.
114   static std::vector<TpiSource *> instances;
115
116   /// Dependency type sources, such as type servers or PCH object files. These
117   /// must be processed before objects that rely on them. Set by
118   /// TpiSources::sortDependencies.
119   static ArrayRef<TpiSource *> dependencySources;
120
121   /// Object file sources. These must be processed after dependencySources.
122   static ArrayRef<TpiSource *> objectSources;
123
124   /// Sorts the dependencies and reassigns TpiSource indices.
125   static void sortDependencies();
126
127   static uint32_t countTypeServerPDBs();
128   static uint32_t countPrecompObjs();
129
130   /// Free heap allocated ghashes.
131   static void clearGHashes();
132
133   /// Clear global data structures for TpiSources.
134   static void clear();
135
136   const TpiKind kind;
137   bool ownedGHashes = true;
138   uint32_t tpiSrcIdx = 0;
139
140 protected:
141   /// The ghash index (zero based, not 0x1000-based) of the LF_ENDPRECOMP record
142   /// in this object, if one exists. This is the all ones value otherwise. It is
143   /// recorded here so that it can be omitted from the final ghash table.
144   uint32_t endPrecompGHashIdx = ~0U;
145
146 public:
147   ObjFile *file;
148
149   /// An error encountered during type merging, if any.
150   Error typeMergingError = Error::success();
151
152   // Storage for tpiMap or ipiMap, depending on the kind of source.
153   llvm::SmallVector<TypeIndex, 0> indexMapStorage;
154
155   // Source type index to PDB type index mapping for type and item records.
156   // These mappings will be the same for /Z7 objects, and distinct for /Zi
157   // objects.
158   llvm::ArrayRef<TypeIndex> tpiMap;
159   llvm::ArrayRef<TypeIndex> ipiMap;
160
161   /// Array of global type hashes, indexed by TypeIndex. May be calculated on
162   /// demand, or present in input object files.
163   llvm::ArrayRef<llvm::codeview::GloballyHashedType> ghashes;
164
165   /// When ghashing is used, record the mapping from LF_[M]FUNC_ID to function
166   /// type index here. Both indices are PDB indices, not object type indexes.
167   std::vector<std::pair<TypeIndex, TypeIndex>> funcIdToType;
168
169   /// Indicates if a type record is an item index or a type index.
170   llvm::BitVector isItemIndex;
171
172   /// A list of all "unique" type indices which must be merged into the final
173   /// PDB. GHash type deduplication produces this list, and it should be
174   /// considerably smaller than the input.
175   std::vector<uint32_t> uniqueTypes;
176
177   struct MergedInfo {
178     std::vector<uint8_t> recs;
179     std::vector<uint16_t> recSizes;
180     std::vector<uint32_t> recHashes;
181   };
182
183   MergedInfo mergedTpi;
184   MergedInfo mergedIpi;
185 };
186
187 TpiSource *makeTpiSource(ObjFile *file);
188 TpiSource *makeTypeServerSource(PDBInputFile *pdbInputFile);
189 TpiSource *makeUseTypeServerSource(ObjFile *file,
190                                    llvm::codeview::TypeServer2Record ts);
191 TpiSource *makePrecompSource(ObjFile *file);
192 TpiSource *makeUsePrecompSource(ObjFile *file,
193                                 llvm::codeview::PrecompRecord ts);
194
195 } // namespace coff
196 } // namespace lld
197
198 #endif