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::codeview {
21 struct GloballyHashedType;
22 }
23 namespace llvm::pdb {
24 class NativeSession;
25 class TpiStream;
26 }
27 
28 namespace lld::coff {
29 
30 using llvm::codeview::GloballyHashedType;
31 using llvm::codeview::TypeIndex;
32 
33 class ObjFile;
34 class PDBInputFile;
35 class TypeMerger;
36 struct GHashState;
37 class COFFLinkerContext;
38 
39 class TpiSource {
40 public:
41   enum TpiKind : uint8_t { Regular, PCH, UsingPCH, PDB, PDBIpi, UsingPDB };
42 
43   TpiSource(COFFLinkerContext &ctx, TpiKind k, ObjFile *f);
44   virtual ~TpiSource();
45 
46   /// Produce a mapping from the type and item indices used in the object
47   /// file to those in the destination PDB.
48   ///
49   /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
50   /// and IPI from the type server PDB and return a map for it. Each unique type
51   /// server PDB is merged at most once, so this may return an existing index
52   /// mapping.
53   ///
54   /// If the object does not use a type server PDB (compiled with /Z7), we merge
55   /// all the type and item records from the .debug$S stream and fill in the
56   /// caller-provided ObjectIndexMap.
57   virtual Error mergeDebugT(TypeMerger *m);
58 
59   /// Load global hashes, either by hashing types directly, or by loading them
60   /// from LLVM's .debug$H section.
61   virtual void loadGHashes();
62 
63   /// Use global hashes to merge type information.
64   virtual void remapTpiWithGHashes(GHashState *g);
65 
66   // Remap a type index in place.
67   bool remapTypeIndex(TypeIndex &ti, llvm::codeview::TiRefKind refKind) const;
68 
69 protected:
70   void remapRecord(MutableArrayRef<uint8_t> rec,
71                    ArrayRef<llvm::codeview::TiReference> typeRefs);
72 
73   void mergeTypeRecord(TypeIndex curIndex, llvm::codeview::CVType ty);
74 
75   // Merge the type records listed in uniqueTypes. beginIndex is the TypeIndex
76   // of the first record in this source, typically 0x1000. When PCHs are
77   // involved, it may start higher.
78   void mergeUniqueTypeRecords(
79       ArrayRef<uint8_t> debugTypes,
80       TypeIndex beginIndex = TypeIndex(TypeIndex::FirstNonSimpleIndex));
81 
82   // Use the ghash table to construct a map from source type index to
83   // destination PDB type index. Usable for either TPI or IPI.
84   void fillMapFromGHashes(GHashState *m);
85 
86   // Copies ghashes from a vector into an array. These are long lived, so it's
87   // worth the time to copy these into an appropriately sized vector to reduce
88   // memory usage.
89   void assignGHashesFromVector(std::vector<GloballyHashedType> &&hashVec);
90 
91   // Walk over file->debugTypes and fill in the isItemIndex bit vector.
92   void fillIsItemIndexFromDebugT();
93 
94   COFFLinkerContext &ctx;
95 
96 public:
97   bool remapTypesInSymbolRecord(MutableArrayRef<uint8_t> rec);
98 
99   void remapTypesInTypeRecord(MutableArrayRef<uint8_t> rec);
100 
101   /// Is this a dependent file that needs to be processed first, before other
102   /// OBJs?
isDependency()103   virtual bool isDependency() const { return false; }
104 
105   /// Returns true if this type record should be omitted from the PDB, even if
106   /// it is unique. This prevents a record from being added to the input ghash
107   /// table.
shouldOmitFromPdb(uint32_t ghashIdx)108   bool shouldOmitFromPdb(uint32_t ghashIdx) {
109     return ghashIdx == endPrecompIdx;
110   }
111 
112   const TpiKind kind;
113   bool ownedGHashes = true;
114   uint32_t tpiSrcIdx = 0;
115 
116   /// The index (zero based, not 0x1000-based) of the LF_ENDPRECOMP record in
117   /// this object, if one exists. This is the all ones value otherwise. It is
118   /// recorded here for validation, and so that it can be omitted from the final
119   /// ghash table.
120   uint32_t endPrecompIdx = ~0U;
121 
122 public:
123   ObjFile *file;
124 
125   /// An error encountered during type merging, if any.
126   Error typeMergingError = Error::success();
127 
128   // Storage for tpiMap or ipiMap, depending on the kind of source.
129   llvm::SmallVector<TypeIndex, 0> indexMapStorage;
130 
131   // Source type index to PDB type index mapping for type and item records.
132   // These mappings will be the same for /Z7 objects, and distinct for /Zi
133   // objects.
134   llvm::ArrayRef<TypeIndex> tpiMap;
135   llvm::ArrayRef<TypeIndex> ipiMap;
136 
137   /// Array of global type hashes, indexed by TypeIndex. May be calculated on
138   /// demand, or present in input object files.
139   llvm::ArrayRef<llvm::codeview::GloballyHashedType> ghashes;
140 
141   /// When ghashing is used, record the mapping from LF_[M]FUNC_ID to function
142   /// type index here. Both indices are PDB indices, not object type indexes.
143   std::vector<std::pair<TypeIndex, TypeIndex>> funcIdToType;
144 
145   /// Indicates if a type record is an item index or a type index.
146   llvm::BitVector isItemIndex;
147 
148   /// A list of all "unique" type indices which must be merged into the final
149   /// PDB. GHash type deduplication produces this list, and it should be
150   /// considerably smaller than the input.
151   std::vector<uint32_t> uniqueTypes;
152 
153   struct MergedInfo {
154     std::vector<uint8_t> recs;
155     std::vector<uint16_t> recSizes;
156     std::vector<uint32_t> recHashes;
157   };
158 
159   MergedInfo mergedTpi;
160   MergedInfo mergedIpi;
161 
162   uint64_t nbTypeRecords = 0;
163   uint64_t nbTypeRecordsBytes = 0;
164 };
165 
166 TpiSource *makeTpiSource(COFFLinkerContext &ctx, ObjFile *f);
167 TpiSource *makeTypeServerSource(COFFLinkerContext &ctx,
168                                 PDBInputFile *pdbInputFile);
169 TpiSource *makeUseTypeServerSource(COFFLinkerContext &ctx, ObjFile *file,
170                                    llvm::codeview::TypeServer2Record ts);
171 TpiSource *makePrecompSource(COFFLinkerContext &ctx, ObjFile *file);
172 TpiSource *makeUsePrecompSource(COFFLinkerContext &ctx, ObjFile *file,
173                                 llvm::codeview::PrecompRecord ts);
174 
175 } // namespace lld::coff
176 
177 #endif
178