[PDB] Use one func id DenseMap instead of per-source maps, NFC
[lldb.git] / lld / COFF / DebugTypes.cpp
1 //===- DebugTypes.cpp -----------------------------------------------------===//
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 #include "DebugTypes.h"
10 #include "Chunks.h"
11 #include "Driver.h"
12 #include "InputFiles.h"
13 #include "PDB.h"
14 #include "TypeMerger.h"
15 #include "lld/Common/ErrorHandler.h"
16 #include "lld/Common/Memory.h"
17 #include "lld/Common/Timer.h"
18 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
19 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
20 #include "llvm/DebugInfo/CodeView/TypeRecordHelpers.h"
21 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
22 #include "llvm/DebugInfo/PDB/GenericError.h"
23 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
24 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
25 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
26 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
27 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
28 #include "llvm/Support/FormatVariadic.h"
29 #include "llvm/Support/Parallel.h"
30 #include "llvm/Support/Path.h"
31
32 using namespace llvm;
33 using namespace llvm::codeview;
34 using namespace lld;
35 using namespace lld::coff;
36
37 namespace {
38 class TypeServerIpiSource;
39
40 // The TypeServerSource class represents a PDB type server, a file referenced by
41 // OBJ files compiled with MSVC /Zi. A single PDB can be shared by several OBJ
42 // files, therefore there must be only once instance per OBJ lot. The file path
43 // is discovered from the dependent OBJ's debug type stream. The
44 // TypeServerSource object is then queued and loaded by the COFF Driver. The
45 // debug type stream for such PDB files will be merged first in the final PDB,
46 // before any dependent OBJ.
47 class TypeServerSource : public TpiSource {
48 public:
49   explicit TypeServerSource(PDBInputFile *f)
50       : TpiSource(PDB, nullptr), pdbInputFile(f) {
51     if (f->loadErr && *f->loadErr)
52       return;
53     pdb::PDBFile &file = f->session->getPDBFile();
54     auto expectedInfo = file.getPDBInfoStream();
55     if (!expectedInfo)
56       return;
57     auto it = mappings.emplace(expectedInfo->getGuid(), this);
58     assert(it.second);
59     (void)it;
60   }
61
62   Error mergeDebugT(TypeMerger *m) override;
63
64   void loadGHashes() override;
65   void remapTpiWithGHashes(GHashState *g) override;
66
67   bool isDependency() const override { return true; }
68
69   PDBInputFile *pdbInputFile = nullptr;
70
71   // TpiSource for IPI stream.
72   TypeServerIpiSource *ipiSrc = nullptr;
73
74   static std::map<codeview::GUID, TypeServerSource *> mappings;
75 };
76
77 // Companion to TypeServerSource. Stores the index map for the IPI stream in the
78 // PDB. Modeling PDBs with two sources for TPI and IPI helps establish the
79 // invariant of one type index space per source.
80 class TypeServerIpiSource : public TpiSource {
81 public:
82   explicit TypeServerIpiSource() : TpiSource(PDBIpi, nullptr) {}
83
84   friend class TypeServerSource;
85
86   // All of the TpiSource methods are no-ops. The parent TypeServerSource
87   // handles both TPI and IPI.
88   Error mergeDebugT(TypeMerger *m) override { return Error::success(); }
89   void loadGHashes() override {}
90   void remapTpiWithGHashes(GHashState *g) override {}
91   bool isDependency() const override { return true; }
92 };
93
94 // This class represents the debug type stream of an OBJ file that depends on a
95 // PDB type server (see TypeServerSource).
96 class UseTypeServerSource : public TpiSource {
97   Expected<TypeServerSource *> getTypeServerSource();
98
99 public:
100   UseTypeServerSource(ObjFile *f, TypeServer2Record ts)
101       : TpiSource(UsingPDB, f), typeServerDependency(ts) {}
102
103   Error mergeDebugT(TypeMerger *m) override;
104
105   // No need to load ghashes from /Zi objects.
106   void loadGHashes() override {}
107   void remapTpiWithGHashes(GHashState *g) override;
108
109   // Information about the PDB type server dependency, that needs to be loaded
110   // in before merging this OBJ.
111   TypeServer2Record typeServerDependency;
112 };
113
114 // This class represents the debug type stream of a Microsoft precompiled
115 // headers OBJ (PCH OBJ). This OBJ kind needs to be merged first in the output
116 // PDB, before any other OBJs that depend on this. Note that only MSVC generate
117 // such files, clang does not.
118 class PrecompSource : public TpiSource {
119 public:
120   PrecompSource(ObjFile *f) : TpiSource(PCH, f) {
121     if (!f->pchSignature || !*f->pchSignature)
122       fatal(toString(f) +
123             " claims to be a PCH object, but does not have a valid signature");
124     auto it = mappings.emplace(*f->pchSignature, this);
125     if (!it.second)
126       fatal("a PCH object with the same signature has already been provided (" +
127             toString(it.first->second->file) + " and " + toString(file) + ")");
128   }
129
130   void loadGHashes() override;
131
132   bool isDependency() const override { return true; }
133
134   static std::map<uint32_t, PrecompSource *> mappings;
135 };
136
137 // This class represents the debug type stream of an OBJ file that depends on a
138 // Microsoft precompiled headers OBJ (see PrecompSource).
139 class UsePrecompSource : public TpiSource {
140 public:
141   UsePrecompSource(ObjFile *f, PrecompRecord precomp)
142       : TpiSource(UsingPCH, f), precompDependency(precomp) {}
143
144   Error mergeDebugT(TypeMerger *m) override;
145
146   void loadGHashes() override;
147   void remapTpiWithGHashes(GHashState *g) override;
148
149 private:
150   Error mergeInPrecompHeaderObj();
151
152 public:
153   // Information about the Precomp OBJ dependency, that needs to be loaded in
154   // before merging this OBJ.
155   PrecompRecord precompDependency;
156 };
157 } // namespace
158
159 std::vector<TpiSource *> TpiSource::instances;
160 ArrayRef<TpiSource *> TpiSource::dependencySources;
161 ArrayRef<TpiSource *> TpiSource::objectSources;
162
163 TpiSource::TpiSource(TpiKind k, ObjFile *f)
164     : kind(k), tpiSrcIdx(instances.size()), file(f) {
165   instances.push_back(this);
166 }
167
168 // Vtable key method.
169 TpiSource::~TpiSource() {
170   // Silence any assertions about unchecked errors.
171   consumeError(std::move(typeMergingError));
172 }
173
174 void TpiSource::sortDependencies() {
175   // Order dependencies first, but preserve the existing order.
176   std::vector<TpiSource *> deps;
177   std::vector<TpiSource *> objs;
178   for (TpiSource *s : instances)
179     (s->isDependency() ? deps : objs).push_back(s);
180   uint32_t numDeps = deps.size();
181   uint32_t numObjs = objs.size();
182   instances = std::move(deps);
183   instances.insert(instances.end(), objs.begin(), objs.end());
184   for (uint32_t i = 0, e = instances.size(); i < e; ++i)
185     instances[i]->tpiSrcIdx = i;
186   dependencySources = makeArrayRef(instances.data(), numDeps);
187   objectSources = makeArrayRef(instances.data() + numDeps, numObjs);
188 }
189
190 TpiSource *lld::coff::makeTpiSource(ObjFile *file) {
191   return make<TpiSource>(TpiSource::Regular, file);
192 }
193
194 TpiSource *lld::coff::makeTypeServerSource(PDBInputFile *pdbInputFile) {
195   // Type server sources come in pairs: the TPI stream, and the IPI stream.
196   auto *tpiSource = make<TypeServerSource>(pdbInputFile);
197   if (pdbInputFile->session->getPDBFile().hasPDBIpiStream())
198     tpiSource->ipiSrc = make<TypeServerIpiSource>();
199   return tpiSource;
200 }
201
202 TpiSource *lld::coff::makeUseTypeServerSource(ObjFile *file,
203                                               TypeServer2Record ts) {
204   return make<UseTypeServerSource>(file, ts);
205 }
206
207 TpiSource *lld::coff::makePrecompSource(ObjFile *file) {
208   return make<PrecompSource>(file);
209 }
210
211 TpiSource *lld::coff::makeUsePrecompSource(ObjFile *file,
212                                            PrecompRecord precomp) {
213   return make<UsePrecompSource>(file, precomp);
214 }
215
216 std::map<codeview::GUID, TypeServerSource *> TypeServerSource::mappings;
217
218 std::map<uint32_t, PrecompSource *> PrecompSource::mappings;
219
220 bool TpiSource::remapTypeIndex(TypeIndex &ti, TiRefKind refKind) const {
221   if (ti.isSimple())
222     return true;
223
224   // This can be an item index or a type index. Choose the appropriate map.
225   ArrayRef<TypeIndex> tpiOrIpiMap =
226       (refKind == TiRefKind::IndexRef) ? ipiMap : tpiMap;
227   if (ti.toArrayIndex() >= tpiOrIpiMap.size())
228     return false;
229   ti = tpiOrIpiMap[ti.toArrayIndex()];
230   return true;
231 }
232
233 void TpiSource::remapRecord(MutableArrayRef<uint8_t> rec,
234                             ArrayRef<TiReference> typeRefs) {
235   MutableArrayRef<uint8_t> contents = rec.drop_front(sizeof(RecordPrefix));
236   for (const TiReference &ref : typeRefs) {
237     unsigned byteSize = ref.Count * sizeof(TypeIndex);
238     if (contents.size() < ref.Offset + byteSize)
239       fatal("symbol record too short");
240
241     MutableArrayRef<TypeIndex> indices(
242         reinterpret_cast<TypeIndex *>(contents.data() + ref.Offset), ref.Count);
243     for (TypeIndex &ti : indices) {
244       if (!remapTypeIndex(ti, ref.Kind)) {
245         if (config->verbose) {
246           uint16_t kind =
247               reinterpret_cast<const RecordPrefix *>(rec.data())->RecordKind;
248           StringRef fname = file ? file->getName() : "<unknown PDB>";
249           log("failed to remap type index in record of kind 0x" +
250               utohexstr(kind) + " in " + fname + " with bad " +
251               (ref.Kind == TiRefKind::IndexRef ? "item" : "type") +
252               " index 0x" + utohexstr(ti.getIndex()));
253         }
254         ti = TypeIndex(SimpleTypeKind::NotTranslated);
255         continue;
256       }
257     }
258   }
259 }
260
261 void TpiSource::remapTypesInTypeRecord(MutableArrayRef<uint8_t> rec) {
262   // TODO: Handle errors similar to symbols.
263   SmallVector<TiReference, 32> typeRefs;
264   discoverTypeIndices(CVType(rec), typeRefs);
265   remapRecord(rec, typeRefs);
266 }
267
268 bool TpiSource::remapTypesInSymbolRecord(MutableArrayRef<uint8_t> rec) {
269   // Discover type index references in the record. Skip it if we don't
270   // know where they are.
271   SmallVector<TiReference, 32> typeRefs;
272   if (!discoverTypeIndicesInSymbol(rec, typeRefs))
273     return false;
274   remapRecord(rec, typeRefs);
275   return true;
276 }
277
278 // A COFF .debug$H section is currently a clang extension.  This function checks
279 // if a .debug$H section is in a format that we expect / understand, so that we
280 // can ignore any sections which are coincidentally also named .debug$H but do
281 // not contain a format we recognize.
282 static bool canUseDebugH(ArrayRef<uint8_t> debugH) {
283   if (debugH.size() < sizeof(object::debug_h_header))
284     return false;
285   auto *header =
286       reinterpret_cast<const object::debug_h_header *>(debugH.data());
287   debugH = debugH.drop_front(sizeof(object::debug_h_header));
288   return header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
289          header->Version == 0 &&
290          header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) &&
291          (debugH.size() % 8 == 0);
292 }
293
294 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *file) {
295   SectionChunk *sec =
296       SectionChunk::findByName(file->getDebugChunks(), ".debug$H");
297   if (!sec)
298     return llvm::None;
299   ArrayRef<uint8_t> contents = sec->getContents();
300   if (!canUseDebugH(contents))
301     return None;
302   return contents;
303 }
304
305 static ArrayRef<GloballyHashedType>
306 getHashesFromDebugH(ArrayRef<uint8_t> debugH) {
307   assert(canUseDebugH(debugH));
308   debugH = debugH.drop_front(sizeof(object::debug_h_header));
309   uint32_t count = debugH.size() / sizeof(GloballyHashedType);
310   return {reinterpret_cast<const GloballyHashedType *>(debugH.data()), count};
311 }
312
313 // Merge .debug$T for a generic object file.
314 Error TpiSource::mergeDebugT(TypeMerger *m) {
315   assert(!config->debugGHashes &&
316          "use remapTpiWithGHashes when ghash is enabled");
317
318   CVTypeArray types;
319   BinaryStreamReader reader(file->debugTypes, support::little);
320   cantFail(reader.readArray(types, reader.getLength()));
321
322   if (auto err = mergeTypeAndIdRecords(
323           m->idTable, m->typeTable, indexMapStorage, types, file->pchSignature))
324     fatal("codeview::mergeTypeAndIdRecords failed: " +
325           toString(std::move(err)));
326
327   // In an object, there is only one mapping for both types and items.
328   tpiMap = indexMapStorage;
329   ipiMap = indexMapStorage;
330
331   if (config->showSummary) {
332     // Count how many times we saw each type record in our input. This
333     // calculation requires a second pass over the type records to classify each
334     // record as a type or index. This is slow, but this code executes when
335     // collecting statistics.
336     m->tpiCounts.resize(m->getTypeTable().size());
337     m->ipiCounts.resize(m->getIDTable().size());
338     uint32_t srcIdx = 0;
339     for (CVType &ty : types) {
340       TypeIndex dstIdx = tpiMap[srcIdx++];
341       // Type merging may fail, so a complex source type may become the simple
342       // NotTranslated type, which cannot be used as an array index.
343       if (dstIdx.isSimple())
344         continue;
345       SmallVectorImpl<uint32_t> &counts =
346           isIdRecord(ty.kind()) ? m->ipiCounts : m->tpiCounts;
347       ++counts[dstIdx.toArrayIndex()];
348     }
349   }
350
351   return Error::success();
352 }
353
354 // Merge types from a type server PDB.
355 Error TypeServerSource::mergeDebugT(TypeMerger *m) {
356   assert(!config->debugGHashes &&
357          "use remapTpiWithGHashes when ghash is enabled");
358
359   pdb::PDBFile &pdbFile = pdbInputFile->session->getPDBFile();
360   Expected<pdb::TpiStream &> expectedTpi = pdbFile.getPDBTpiStream();
361   if (auto e = expectedTpi.takeError())
362     fatal("Type server does not have TPI stream: " + toString(std::move(e)));
363   pdb::TpiStream *maybeIpi = nullptr;
364   if (pdbFile.hasPDBIpiStream()) {
365     Expected<pdb::TpiStream &> expectedIpi = pdbFile.getPDBIpiStream();
366     if (auto e = expectedIpi.takeError())
367       fatal("Error getting type server IPI stream: " + toString(std::move(e)));
368     maybeIpi = &*expectedIpi;
369   }
370
371   // Merge TPI first, because the IPI stream will reference type indices.
372   if (auto err = mergeTypeRecords(m->typeTable, indexMapStorage,
373                                   expectedTpi->typeArray()))
374     fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
375   tpiMap = indexMapStorage;
376
377   // Merge IPI.
378   if (maybeIpi) {
379     if (auto err = mergeIdRecords(m->idTable, tpiMap, ipiSrc->indexMapStorage,
380                                   maybeIpi->typeArray()))
381       fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
382     ipiMap = ipiSrc->indexMapStorage;
383   }
384
385   if (config->showSummary) {
386     // Count how many times we saw each type record in our input. If a
387     // destination type index is present in the source to destination type index
388     // map, that means we saw it once in the input. Add it to our histogram.
389     m->tpiCounts.resize(m->getTypeTable().size());
390     m->ipiCounts.resize(m->getIDTable().size());
391     for (TypeIndex ti : tpiMap)
392       if (!ti.isSimple())
393         ++m->tpiCounts[ti.toArrayIndex()];
394     for (TypeIndex ti : ipiMap)
395       if (!ti.isSimple())
396         ++m->ipiCounts[ti.toArrayIndex()];
397   }
398
399   return Error::success();
400 }
401
402 Expected<TypeServerSource *> UseTypeServerSource::getTypeServerSource() {
403   const codeview::GUID &tsId = typeServerDependency.getGuid();
404   StringRef tsPath = typeServerDependency.getName();
405
406   TypeServerSource *tsSrc;
407   auto it = TypeServerSource::mappings.find(tsId);
408   if (it != TypeServerSource::mappings.end()) {
409     tsSrc = it->second;
410   } else {
411     // The file failed to load, lookup by name
412     PDBInputFile *pdb = PDBInputFile::findFromRecordPath(tsPath, file);
413     if (!pdb)
414       return createFileError(tsPath, errorCodeToError(std::error_code(
415                                          ENOENT, std::generic_category())));
416     // If an error occurred during loading, throw it now
417     if (pdb->loadErr && *pdb->loadErr)
418       return createFileError(tsPath, std::move(*pdb->loadErr));
419
420     tsSrc = (TypeServerSource *)pdb->debugTypesObj;
421   }
422   return tsSrc;
423 }
424
425 Error UseTypeServerSource::mergeDebugT(TypeMerger *m) {
426   Expected<TypeServerSource *> tsSrc = getTypeServerSource();
427   if (!tsSrc)
428     return tsSrc.takeError();
429
430   pdb::PDBFile &pdbSession = (*tsSrc)->pdbInputFile->session->getPDBFile();
431   auto expectedInfo = pdbSession.getPDBInfoStream();
432   if (!expectedInfo)
433     return expectedInfo.takeError();
434
435   // Just because a file with a matching name was found and it was an actual
436   // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
437   // must match the GUID specified in the TypeServer2 record.
438   if (expectedInfo->getGuid() != typeServerDependency.getGuid())
439     return createFileError(
440         typeServerDependency.getName(),
441         make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
442
443   // Reuse the type index map of the type server.
444   tpiMap = (*tsSrc)->tpiMap;
445   ipiMap = (*tsSrc)->ipiMap;
446   return Error::success();
447 }
448
449 static bool equalsPath(StringRef path1, StringRef path2) {
450 #if defined(_WIN32)
451   return path1.equals_lower(path2);
452 #else
453   return path1.equals(path2);
454 #endif
455 }
456
457 // Find by name an OBJ provided on the command line
458 static PrecompSource *findObjByName(StringRef fileNameOnly) {
459   SmallString<128> currentPath;
460   for (auto kv : PrecompSource::mappings) {
461     StringRef currentFileName = sys::path::filename(kv.second->file->getName(),
462                                                     sys::path::Style::windows);
463
464     // Compare based solely on the file name (link.exe behavior)
465     if (equalsPath(currentFileName, fileNameOnly))
466       return kv.second;
467   }
468   return nullptr;
469 }
470
471 static PrecompSource *findPrecompSource(ObjFile *file, PrecompRecord &pr) {
472   // Cross-compile warning: given that Clang doesn't generate LF_PRECOMP
473   // records, we assume the OBJ comes from a Windows build of cl.exe. Thusly,
474   // the paths embedded in the OBJs are in the Windows format.
475   SmallString<128> prFileName =
476       sys::path::filename(pr.getPrecompFilePath(), sys::path::Style::windows);
477
478   auto it = PrecompSource::mappings.find(pr.getSignature());
479   if (it != PrecompSource::mappings.end()) {
480     return it->second;
481   }
482   // Lookup by name
483   return findObjByName(prFileName);
484 }
485
486 static Expected<PrecompSource *> findPrecompMap(ObjFile *file,
487                                                 PrecompRecord &pr) {
488   PrecompSource *precomp = findPrecompSource(file, pr);
489
490   if (!precomp)
491     return createFileError(
492         pr.getPrecompFilePath(),
493         make_error<pdb::PDBError>(pdb::pdb_error_code::no_matching_pch));
494
495   if (pr.getSignature() != file->pchSignature)
496     return createFileError(
497         toString(file),
498         make_error<pdb::PDBError>(pdb::pdb_error_code::no_matching_pch));
499
500   if (pr.getSignature() != *precomp->file->pchSignature)
501     return createFileError(
502         toString(precomp->file),
503         make_error<pdb::PDBError>(pdb::pdb_error_code::no_matching_pch));
504
505   return precomp;
506 }
507
508 /// Merges a precompiled headers TPI map into the current TPI map. The
509 /// precompiled headers object will also be loaded and remapped in the
510 /// process.
511 Error UsePrecompSource::mergeInPrecompHeaderObj() {
512   auto e = findPrecompMap(file, precompDependency);
513   if (!e)
514     return e.takeError();
515
516   PrecompSource *precompSrc = *e;
517   if (precompSrc->tpiMap.empty())
518     return Error::success();
519
520   assert(precompDependency.getStartTypeIndex() ==
521          TypeIndex::FirstNonSimpleIndex);
522   assert(precompDependency.getTypesCount() <= precompSrc->tpiMap.size());
523   // Use the previously remapped index map from the precompiled headers.
524   indexMapStorage.append(precompSrc->tpiMap.begin(),
525                          precompSrc->tpiMap.begin() +
526                              precompDependency.getTypesCount());
527
528   return Error::success();
529 }
530
531 Error UsePrecompSource::mergeDebugT(TypeMerger *m) {
532   // This object was compiled with /Yu, so process the corresponding
533   // precompiled headers object (/Yc) first. Some type indices in the current
534   // object are referencing data in the precompiled headers object, so we need
535   // both to be loaded.
536   if (Error e = mergeInPrecompHeaderObj())
537     return e;
538
539   return TpiSource::mergeDebugT(m);
540 }
541
542 uint32_t TpiSource::countTypeServerPDBs() {
543   return TypeServerSource::mappings.size();
544 }
545
546 uint32_t TpiSource::countPrecompObjs() {
547   return PrecompSource::mappings.size();
548 }
549
550 void TpiSource::clear() {
551   // Clean up any owned ghash allocations.
552   clearGHashes();
553   TpiSource::instances.clear();
554   TypeServerSource::mappings.clear();
555   PrecompSource::mappings.clear();
556 }
557
558 //===----------------------------------------------------------------------===//
559 // Parellel GHash type merging implementation.
560 //===----------------------------------------------------------------------===//
561
562 void TpiSource::loadGHashes() {
563   if (Optional<ArrayRef<uint8_t>> debugH = getDebugH(file)) {
564     ghashes = getHashesFromDebugH(*debugH);
565     ownedGHashes = false;
566   } else {
567     CVTypeArray types;
568     BinaryStreamReader reader(file->debugTypes, support::little);
569     cantFail(reader.readArray(types, reader.getLength()));
570     assignGHashesFromVector(GloballyHashedType::hashTypes(types));
571   }
572
573   fillIsItemIndexFromDebugT();
574 }
575
576 // Copies ghashes from a vector into an array. These are long lived, so it's
577 // worth the time to copy these into an appropriately sized vector to reduce
578 // memory usage.
579 void TpiSource::assignGHashesFromVector(
580     std::vector<GloballyHashedType> &&hashVec) {
581   GloballyHashedType *hashes = new GloballyHashedType[hashVec.size()];
582   memcpy(hashes, hashVec.data(), hashVec.size() * sizeof(GloballyHashedType));
583   ghashes = makeArrayRef(hashes, hashVec.size());
584   ownedGHashes = true;
585 }
586
587 // Faster way to iterate type records. forEachTypeChecked is faster than
588 // iterating CVTypeArray. It avoids virtual readBytes calls in inner loops.
589 static void forEachTypeChecked(ArrayRef<uint8_t> types,
590                                function_ref<void(const CVType &)> fn) {
591   checkError(
592       forEachCodeViewRecord<CVType>(types, [fn](const CVType &ty) -> Error {
593         fn(ty);
594         return Error::success();
595       }));
596 }
597
598 // Walk over file->debugTypes and fill in the isItemIndex bit vector.
599 // TODO: Store this information in .debug$H so that we don't have to recompute
600 // it. This is the main bottleneck slowing down parallel ghashing with one
601 // thread over single-threaded ghashing.
602 void TpiSource::fillIsItemIndexFromDebugT() {
603   uint32_t index = 0;
604   isItemIndex.resize(ghashes.size());
605   forEachTypeChecked(file->debugTypes, [&](const CVType &ty) {
606     if (isIdRecord(ty.kind()))
607       isItemIndex.set(index);
608     ++index;
609   });
610 }
611
612 void TpiSource::mergeTypeRecord(TypeIndex curIndex, CVType ty) {
613   // Decide if the merged type goes into TPI or IPI.
614   bool isItem = isIdRecord(ty.kind());
615   MergedInfo &merged = isItem ? mergedIpi : mergedTpi;
616
617   // Copy the type into our mutable buffer.
618   assert(ty.length() <= codeview::MaxRecordLength);
619   size_t offset = merged.recs.size();
620   size_t newSize = alignTo(ty.length(), 4);
621   merged.recs.resize(offset + newSize);
622   auto newRec = makeMutableArrayRef(&merged.recs[offset], newSize);
623   memcpy(newRec.data(), ty.data().data(), newSize);
624
625   // Fix up the record prefix and padding bytes if it required resizing.
626   if (newSize != ty.length()) {
627     reinterpret_cast<RecordPrefix *>(newRec.data())->RecordLen = newSize - 2;
628     for (size_t i = ty.length(); i < newSize; ++i)
629       newRec[i] = LF_PAD0 + (newSize - i);
630   }
631
632   // Remap the type indices in the new record.
633   remapTypesInTypeRecord(newRec);
634   uint32_t pdbHash = check(pdb::hashTypeRecord(CVType(newRec)));
635   merged.recSizes.push_back(static_cast<uint16_t>(newSize));
636   merged.recHashes.push_back(pdbHash);
637
638   // Retain a mapping from PDB function id to PDB function type. This mapping is
639   // used during symbol procesing to rewrite S_GPROC32_ID symbols to S_GPROC32
640   // symbols.
641   if (ty.kind() == LF_FUNC_ID || ty.kind() == LF_MFUNC_ID) {
642     bool success = ty.length() >= 12;
643     TypeIndex funcId = curIndex;
644     if (success)
645       success &= remapTypeIndex(funcId, TiRefKind::IndexRef);
646     TypeIndex funcType =
647         *reinterpret_cast<const TypeIndex *>(&newRec.data()[8]);
648     if (success) {
649       funcIdToType.push_back({funcId, funcType});
650     } else {
651       StringRef fname = file ? file->getName() : "<unknown PDB>";
652       warn("corrupt LF_[M]FUNC_ID record 0x" + utohexstr(curIndex.getIndex()) +
653            " in " + fname);
654     }
655   }
656 }
657
658 void TpiSource::mergeUniqueTypeRecords(ArrayRef<uint8_t> typeRecords,
659                                        TypeIndex beginIndex) {
660   // Re-sort the list of unique types by index.
661   if (kind == PDB)
662     assert(std::is_sorted(uniqueTypes.begin(), uniqueTypes.end()));
663   else
664     llvm::sort(uniqueTypes);
665
666   // Accumulate all the unique types into one buffer in mergedTypes.
667   uint32_t ghashIndex = 0;
668   auto nextUniqueIndex = uniqueTypes.begin();
669   assert(mergedTpi.recs.empty());
670   assert(mergedIpi.recs.empty());
671   forEachTypeChecked(typeRecords, [&](const CVType &ty) {
672     if (nextUniqueIndex != uniqueTypes.end() &&
673         *nextUniqueIndex == ghashIndex) {
674       mergeTypeRecord(beginIndex + ghashIndex, ty);
675       ++nextUniqueIndex;
676     }
677     ++ghashIndex;
678   });
679   assert(nextUniqueIndex == uniqueTypes.end() &&
680          "failed to merge all desired records");
681   assert(uniqueTypes.size() ==
682              mergedTpi.recSizes.size() + mergedIpi.recSizes.size() &&
683          "missing desired record");
684 }
685
686 void TpiSource::remapTpiWithGHashes(GHashState *g) {
687   assert(config->debugGHashes && "ghashes must be enabled");
688   fillMapFromGHashes(g, indexMapStorage);
689   tpiMap = indexMapStorage;
690   ipiMap = indexMapStorage;
691   mergeUniqueTypeRecords(file->debugTypes);
692   // TODO: Free all unneeded ghash resources now that we have a full index map.
693 }
694
695 // PDBs do not actually store global hashes, so when merging a type server
696 // PDB we have to synthesize global hashes.  To do this, we first synthesize
697 // global hashes for the TPI stream, since it is independent, then we
698 // synthesize hashes for the IPI stream, using the hashes for the TPI stream
699 // as inputs.
700 void TypeServerSource::loadGHashes() {
701   // Don't hash twice.
702   if (!ghashes.empty())
703     return;
704   pdb::PDBFile &pdbFile = pdbInputFile->session->getPDBFile();
705
706   // Hash TPI stream.
707   Expected<pdb::TpiStream &> expectedTpi = pdbFile.getPDBTpiStream();
708   if (auto e = expectedTpi.takeError())
709     fatal("Type server does not have TPI stream: " + toString(std::move(e)));
710   assignGHashesFromVector(
711       GloballyHashedType::hashTypes(expectedTpi->typeArray()));
712   isItemIndex.resize(ghashes.size());
713
714   // Hash IPI stream, which depends on TPI ghashes.
715   if (!pdbFile.hasPDBIpiStream())
716     return;
717   Expected<pdb::TpiStream &> expectedIpi = pdbFile.getPDBIpiStream();
718   if (auto e = expectedIpi.takeError())
719     fatal("error retreiving IPI stream: " + toString(std::move(e)));
720   ipiSrc->assignGHashesFromVector(
721       GloballyHashedType::hashIds(expectedIpi->typeArray(), ghashes));
722
723   // The IPI stream isItemIndex bitvector should be all ones.
724   ipiSrc->isItemIndex.resize(ipiSrc->ghashes.size());
725   ipiSrc->isItemIndex.set(0, ipiSrc->ghashes.size());
726 }
727
728 // Flatten discontiguous PDB type arrays to bytes so that we can use
729 // forEachTypeChecked instead of CVTypeArray iteration. Copying all types from
730 // type servers is faster than iterating all object files compiled with /Z7 with
731 // CVTypeArray, which has high overheads due to the virtual interface of
732 // BinaryStream::readBytes.
733 static ArrayRef<uint8_t> typeArrayToBytes(const CVTypeArray &types) {
734   BinaryStreamRef stream = types.getUnderlyingStream();
735   ArrayRef<uint8_t> debugTypes;
736   checkError(stream.readBytes(0, stream.getLength(), debugTypes));
737   return debugTypes;
738 }
739
740 // Merge types from a type server PDB.
741 void TypeServerSource::remapTpiWithGHashes(GHashState *g) {
742   assert(config->debugGHashes && "ghashes must be enabled");
743
744   // IPI merging depends on TPI, so do TPI first, then do IPI.  No need to
745   // propagate errors, those should've been handled during ghash loading.
746   pdb::PDBFile &pdbFile = pdbInputFile->session->getPDBFile();
747   pdb::TpiStream &tpi = check(pdbFile.getPDBTpiStream());
748   fillMapFromGHashes(g, indexMapStorage);
749   tpiMap = indexMapStorage;
750   mergeUniqueTypeRecords(typeArrayToBytes(tpi.typeArray()));
751   if (pdbFile.hasPDBIpiStream()) {
752     pdb::TpiStream &ipi = check(pdbFile.getPDBIpiStream());
753     ipiSrc->indexMapStorage.resize(ipiSrc->ghashes.size());
754     ipiSrc->fillMapFromGHashes(g, ipiSrc->indexMapStorage);
755     ipiMap = ipiSrc->indexMapStorage;
756     ipiSrc->tpiMap = tpiMap;
757     ipiSrc->ipiMap = ipiMap;
758     ipiSrc->mergeUniqueTypeRecords(typeArrayToBytes(ipi.typeArray()));
759   }
760 }
761
762 void UseTypeServerSource::remapTpiWithGHashes(GHashState *g) {
763   // No remapping to do with /Zi objects. Simply use the index map from the type
764   // server. Errors should have been reported earlier. Symbols from this object
765   // will be ignored.
766   Expected<TypeServerSource *> maybeTsSrc = getTypeServerSource();
767   if (!maybeTsSrc) {
768     typeMergingError =
769         joinErrors(std::move(typeMergingError), maybeTsSrc.takeError());
770     return;
771   }
772   TypeServerSource *tsSrc = *maybeTsSrc;
773   tpiMap = tsSrc->tpiMap;
774   ipiMap = tsSrc->ipiMap;
775 }
776
777 void PrecompSource::loadGHashes() {
778   if (getDebugH(file)) {
779     warn("ignoring .debug$H section; pch with ghash is not implemented");
780   }
781
782   uint32_t ghashIdx = 0;
783   std::vector<GloballyHashedType> hashVec;
784   forEachTypeChecked(file->debugTypes, [&](const CVType &ty) {
785     // Remember the index of the LF_ENDPRECOMP record so it can be excluded from
786     // the PDB. There must be an entry in the list of ghashes so that the type
787     // indexes of the following records in the /Yc PCH object line up.
788     if (ty.kind() == LF_ENDPRECOMP)
789       endPrecompGHashIdx = ghashIdx;
790
791     hashVec.push_back(GloballyHashedType::hashType(ty, hashVec, hashVec));
792     isItemIndex.push_back(isIdRecord(ty.kind()));
793     ++ghashIdx;
794   });
795   assignGHashesFromVector(std::move(hashVec));
796 }
797
798 void UsePrecompSource::loadGHashes() {
799   PrecompSource *pchSrc = findPrecompSource(file, precompDependency);
800   if (!pchSrc)
801     return;
802
803   // To compute ghashes of a /Yu object file, we need to build on the the
804   // ghashes of the /Yc PCH object. After we are done hashing, discard the
805   // ghashes from the PCH source so we don't unnecessarily try to deduplicate
806   // them.
807   std::vector<GloballyHashedType> hashVec =
808       pchSrc->ghashes.take_front(precompDependency.getTypesCount());
809   forEachTypeChecked(file->debugTypes, [&](const CVType &ty) {
810     hashVec.push_back(GloballyHashedType::hashType(ty, hashVec, hashVec));
811     isItemIndex.push_back(isIdRecord(ty.kind()));
812   });
813   hashVec.erase(hashVec.begin(),
814                 hashVec.begin() + precompDependency.getTypesCount());
815   assignGHashesFromVector(std::move(hashVec));
816 }
817
818 void UsePrecompSource::remapTpiWithGHashes(GHashState *g) {
819   // This object was compiled with /Yu, so process the corresponding
820   // precompiled headers object (/Yc) first. Some type indices in the current
821   // object are referencing data in the precompiled headers object, so we need
822   // both to be loaded.
823   if (Error e = mergeInPrecompHeaderObj()) {
824     typeMergingError = joinErrors(std::move(typeMergingError), std::move(e));
825     return;
826   }
827
828   fillMapFromGHashes(g, indexMapStorage);
829   tpiMap = indexMapStorage;
830   ipiMap = indexMapStorage;
831   mergeUniqueTypeRecords(file->debugTypes,
832                          TypeIndex(precompDependency.getStartTypeIndex() +
833                                    precompDependency.getTypesCount()));
834 }
835
836 namespace {
837 /// A concurrent hash table for global type hashing. It is based on this paper:
838 /// Concurrent Hash Tables: Fast and General(?)!
839 /// https://dl.acm.org/doi/10.1145/3309206
840 ///
841 /// This hash table is meant to be used in two phases:
842 /// 1. concurrent insertions
843 /// 2. concurrent reads
844 /// It does not support lookup, deletion, or rehashing. It uses linear probing.
845 ///
846 /// The paper describes storing a key-value pair in two machine words.
847 /// Generally, the values stored in this map are type indices, and we can use
848 /// those values to recover the ghash key from a side table. This allows us to
849 /// shrink the table entries further at the cost of some loads, and sidesteps
850 /// the need for a 128 bit atomic compare-and-swap operation.
851 ///
852 /// During insertion, a priority function is used to decide which insertion
853 /// should be preferred. This ensures that the output is deterministic. For
854 /// ghashing, lower tpiSrcIdx values (earlier inputs) are preferred.
855 ///
856 class GHashCell;
857 struct GHashTable {
858   GHashCell *table = nullptr;
859   uint32_t tableSize = 0;
860
861   GHashTable() = default;
862   ~GHashTable();
863
864   /// Initialize the table with the given size. Because the table cannot be
865   /// resized, the initial size of the table must be large enough to contain all
866   /// inputs, or insertion may not be able to find an empty cell.
867   void init(uint32_t newTableSize);
868
869   /// Insert the cell with the given ghash into the table. Return the insertion
870   /// position in the table. It is safe for the caller to store the insertion
871   /// position because the table cannot be resized.
872   uint32_t insert(GloballyHashedType ghash, GHashCell newCell);
873 };
874
875 /// A ghash table cell for deduplicating types from TpiSources.
876 class GHashCell {
877   uint64_t data = 0;
878
879 public:
880   GHashCell() = default;
881
882   // Construct data most to least significant so that sorting works well:
883   // - isItem
884   // - tpiSrcIdx
885   // - ghashIdx
886   // Add one to the tpiSrcIdx so that the 0th record from the 0th source has a
887   // non-zero representation.
888   GHashCell(bool isItem, uint32_t tpiSrcIdx, uint32_t ghashIdx)
889       : data((uint64_t(isItem) << 63U) | (uint64_t(tpiSrcIdx + 1) << 32ULL) |
890              ghashIdx) {
891     assert(tpiSrcIdx == getTpiSrcIdx() && "round trip failure");
892     assert(ghashIdx == getGHashIdx() && "round trip failure");
893   }
894
895   explicit GHashCell(uint64_t data) : data(data) {}
896
897   // The empty cell is all zeros.
898   bool isEmpty() const { return data == 0ULL; }
899
900   /// Extract the tpiSrcIdx.
901   uint32_t getTpiSrcIdx() const {
902     return ((uint32_t)(data >> 32U) & 0x7FFFFFFF) - 1;
903   }
904
905   /// Extract the index into the ghash array of the TpiSource.
906   uint32_t getGHashIdx() const { return (uint32_t)data; }
907
908   bool isItem() const { return data & (1ULL << 63U); }
909
910   /// Get the ghash key for this cell.
911   GloballyHashedType getGHash() const {
912     return TpiSource::instances[getTpiSrcIdx()]->ghashes[getGHashIdx()];
913   }
914
915   /// The priority function for the cell. The data is stored such that lower
916   /// tpiSrcIdx and ghashIdx values are preferred, which means that type record
917   /// from earlier sources are more likely to prevail.
918   friend inline bool operator<(const GHashCell &l, const GHashCell &r) {
919     return l.data < r.data;
920   }
921 };
922 } // namespace
923
924 namespace lld {
925 namespace coff {
926 /// This type is just a wrapper around GHashTable with external linkage so it
927 /// can be used from a header.
928 struct GHashState {
929   GHashTable table;
930 };
931 } // namespace coff
932 } // namespace lld
933
934 GHashTable::~GHashTable() { delete[] table; }
935
936 void GHashTable::init(uint32_t newTableSize) {
937   table = new GHashCell[newTableSize];
938   memset(table, 0, newTableSize * sizeof(GHashCell));
939   tableSize = newTableSize;
940 }
941
942 uint32_t GHashTable::insert(GloballyHashedType ghash, GHashCell newCell) {
943   assert(!newCell.isEmpty() && "cannot insert empty cell value");
944
945   // FIXME: The low bytes of SHA1 have low entropy for short records, which
946   // type records are. Swap the byte order for better entropy. A better ghash
947   // won't need this.
948   uint32_t startIdx =
949       ByteSwap_64(*reinterpret_cast<uint64_t *>(&ghash)) % tableSize;
950
951   // Do a linear probe starting at startIdx.
952   uint32_t idx = startIdx;
953   while (true) {
954     // Run a compare and swap loop. There are four cases:
955     // - cell is empty: CAS into place and return
956     // - cell has matching key, earlier priority: do nothing, return
957     // - cell has matching key, later priority: CAS into place and return
958     // - cell has non-matching key: hash collision, probe next cell
959     auto *cellPtr = reinterpret_cast<std::atomic<GHashCell> *>(&table[idx]);
960     GHashCell oldCell(cellPtr->load());
961     while (oldCell.isEmpty() || oldCell.getGHash() == ghash) {
962       // Check if there is an existing ghash entry with a higher priority
963       // (earlier ordering). If so, this is a duplicate, we are done.
964       if (!oldCell.isEmpty() && oldCell < newCell)
965         return idx;
966       // Either the cell is empty, or our value is higher priority. Try to
967       // compare and swap. If it succeeds, we are done.
968       if (cellPtr->compare_exchange_weak(oldCell, newCell))
969         return idx;
970       // If the CAS failed, check this cell again.
971     }
972
973     // Advance the probe. Wrap around to the beginning if we run off the end.
974     ++idx;
975     idx = idx == tableSize ? 0 : idx;
976     if (idx == startIdx) {
977       // If this becomes an issue, we could mark failure and rehash from the
978       // beginning with a bigger table. There is no difference between rehashing
979       // internally and starting over.
980       report_fatal_error("ghash table is full");
981     }
982   }
983   llvm_unreachable("left infloop");
984 }
985
986 TypeMerger::TypeMerger(llvm::BumpPtrAllocator &alloc)
987     : typeTable(alloc), idTable(alloc) {}
988
989 TypeMerger::~TypeMerger() = default;
990
991 void TypeMerger::mergeTypesWithGHash() {
992   // Load ghashes. Do type servers and PCH objects first.
993   {
994     ScopedTimer t1(loadGHashTimer);
995     parallelForEach(TpiSource::dependencySources,
996                     [&](TpiSource *source) { source->loadGHashes(); });
997     parallelForEach(TpiSource::objectSources,
998                     [&](TpiSource *source) { source->loadGHashes(); });
999   }
1000
1001   ScopedTimer t2(mergeGHashTimer);
1002   GHashState ghashState;
1003
1004   // Estimate the size of hash table needed to deduplicate ghashes. This *must*
1005   // be larger than the number of unique types, or hash table insertion may not
1006   // be able to find a vacant slot. Summing the input types guarantees this, but
1007   // it is a gross overestimate. The table size could be reduced to save memory,
1008   // but it would require implementing rehashing, and this table is generally
1009   // small compared to total memory usage, at eight bytes per input type record,
1010   // and most input type records are larger than eight bytes.
1011   size_t tableSize = 0;
1012   for (TpiSource *source : TpiSource::instances)
1013     tableSize += source->ghashes.size();
1014
1015   // Cap the table size so that we can use 32-bit cell indices. Type indices are
1016   // also 32-bit, so this is an inherent PDB file format limit anyway.
1017   tableSize = std::min(size_t(INT32_MAX), tableSize);
1018   ghashState.table.init(static_cast<uint32_t>(tableSize));
1019
1020   // Insert ghashes in parallel. During concurrent insertion, we cannot observe
1021   // the contents of the hash table cell, but we can remember the insertion
1022   // position. Because the table does not rehash, the position will not change
1023   // under insertion. After insertion is done, the value of the cell can be read
1024   // to retreive the final PDB type index.
1025   parallelForEachN(0, TpiSource::instances.size(), [&](size_t tpiSrcIdx) {
1026     TpiSource *source = TpiSource::instances[tpiSrcIdx];
1027     source->indexMapStorage.resize(source->ghashes.size());
1028     for (uint32_t i = 0, e = source->ghashes.size(); i < e; i++) {
1029       if (source->shouldOmitFromPdb(i)) {
1030         source->indexMapStorage[i] = TypeIndex(SimpleTypeKind::NotTranslated);
1031         continue;
1032       }
1033       GloballyHashedType ghash = source->ghashes[i];
1034       bool isItem = source->isItemIndex.test(i);
1035       uint32_t cellIdx =
1036           ghashState.table.insert(ghash, GHashCell(isItem, tpiSrcIdx, i));
1037
1038       // Store the ghash cell index as a type index in indexMapStorage. Later
1039       // we will replace it with the PDB type index.
1040       source->indexMapStorage[i] = TypeIndex::fromArrayIndex(cellIdx);
1041     }
1042   });
1043
1044   // Collect all non-empty cells and sort them. This will implicitly assign
1045   // destination type indices, and partition the entries into type records and
1046   // item records. It arranges types in this order:
1047   // - type records
1048   //   - source 0, type 0...
1049   //   - source 1, type 1...
1050   // - item records
1051   //   - source 0, type 1...
1052   //   - source 1, type 0...
1053   std::vector<GHashCell> entries;
1054   for (const GHashCell &cell :
1055        makeArrayRef(ghashState.table.table, tableSize)) {
1056     if (!cell.isEmpty())
1057       entries.push_back(cell);
1058   }
1059   parallelSort(entries, std::less<GHashCell>());
1060   log(formatv("ghash table load factor: {0:p} (size {1} / capacity {2})\n",
1061               double(entries.size()) / tableSize, entries.size(), tableSize));
1062
1063   // Find out how many type and item indices there are.
1064   auto mid =
1065       std::lower_bound(entries.begin(), entries.end(), GHashCell(true, 0, 0));
1066   assert((mid == entries.end() || mid->isItem()) &&
1067          (mid == entries.begin() || !std::prev(mid)->isItem()) &&
1068          "midpoint is not midpoint");
1069   uint32_t numTypes = std::distance(entries.begin(), mid);
1070   uint32_t numItems = std::distance(mid, entries.end());
1071   log("Tpi record count: " + Twine(numTypes));
1072   log("Ipi record count: " + Twine(numItems));
1073
1074   // Make a list of the "unique" type records to merge for each tpi source. Type
1075   // merging will skip indices not on this list. Store the destination PDB type
1076   // index for these unique types in the tpiMap for each source. The entries for
1077   // non-unique types will be filled in prior to type merging.
1078   for (uint32_t i = 0, e = entries.size(); i < e; ++i) {
1079     auto &cell = entries[i];
1080     uint32_t tpiSrcIdx = cell.getTpiSrcIdx();
1081     TpiSource *source = TpiSource::instances[tpiSrcIdx];
1082     source->uniqueTypes.push_back(cell.getGHashIdx());
1083
1084     // Update the ghash table to store the destination PDB type index in the
1085     // table.
1086     uint32_t pdbTypeIndex = i < numTypes ? i : i - numTypes;
1087     uint32_t ghashCellIndex =
1088         source->indexMapStorage[cell.getGHashIdx()].toArrayIndex();
1089     ghashState.table.table[ghashCellIndex] =
1090         GHashCell(cell.isItem(), cell.getTpiSrcIdx(), pdbTypeIndex);
1091   }
1092
1093   // In parallel, remap all types.
1094   for_each(TpiSource::dependencySources, [&](TpiSource *source) {
1095     source->remapTpiWithGHashes(&ghashState);
1096   });
1097   parallelForEach(TpiSource::objectSources, [&](TpiSource *source) {
1098     source->remapTpiWithGHashes(&ghashState);
1099   });
1100
1101   // Build a global map of from function ID to function type.
1102   for (TpiSource *source : TpiSource::instances) {
1103     for (auto idToType : source->funcIdToType)
1104       funcIdToType.insert(idToType);
1105     source->funcIdToType.clear();
1106   }
1107
1108   TpiSource::clearGHashes();
1109 }
1110
1111 /// Given the index into the ghash table for a particular type, return the type
1112 /// index for that type in the output PDB.
1113 static TypeIndex loadPdbTypeIndexFromCell(GHashState *g,
1114                                           uint32_t ghashCellIdx) {
1115   GHashCell cell = g->table.table[ghashCellIdx];
1116   return TypeIndex::fromArrayIndex(cell.getGHashIdx());
1117 }
1118
1119 // Fill in a TPI or IPI index map using ghashes. For each source type, use its
1120 // ghash to lookup its final type index in the PDB, and store that in the map.
1121 void TpiSource::fillMapFromGHashes(GHashState *g,
1122                                    SmallVectorImpl<TypeIndex> &mapToFill) {
1123   for (size_t i = 0, e = ghashes.size(); i < e; ++i) {
1124     TypeIndex fakeCellIndex = indexMapStorage[i];
1125     if (fakeCellIndex.isSimple())
1126       mapToFill[i] = fakeCellIndex;
1127     else
1128       mapToFill[i] = loadPdbTypeIndexFromCell(g, fakeCellIndex.toArrayIndex());
1129   }
1130 }
1131
1132 void TpiSource::clearGHashes() {
1133   for (TpiSource *src : TpiSource::instances) {
1134     if (src->ownedGHashes)
1135       delete[] src->ghashes.data();
1136     src->ghashes = {};
1137     src->isItemIndex.clear();
1138     src->uniqueTypes.clear();
1139   }
1140 }