1#include "llvm/DebugInfo/PDB/Native/SymbolCache.h"
2
3#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
4#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
5#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
6#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
7#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
8#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
9#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
10#include "llvm/DebugInfo/CodeView/TypeRecord.h"
11#include "llvm/DebugInfo/CodeView/TypeRecordHelpers.h"
12#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
13#include "llvm/DebugInfo/PDB/Native/DbiModuleList.h"
14#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
15#include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
16#include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
17#include "llvm/DebugInfo/PDB/Native/NativeEnumGlobals.h"
18#include "llvm/DebugInfo/PDB/Native/NativeEnumLineNumbers.h"
19#include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
20#include "llvm/DebugInfo/PDB/Native/NativeFunctionSymbol.h"
21#include "llvm/DebugInfo/PDB/Native/NativeInlineSiteSymbol.h"
22#include "llvm/DebugInfo/PDB/Native/NativeLineNumber.h"
23#include "llvm/DebugInfo/PDB/Native/NativePublicSymbol.h"
24#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
25#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
26#include "llvm/DebugInfo/PDB/Native/NativeTypeArray.h"
27#include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
28#include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
29#include "llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h"
30#include "llvm/DebugInfo/PDB/Native/NativeTypePointer.h"
31#include "llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h"
32#include "llvm/DebugInfo/PDB/Native/NativeTypeUDT.h"
33#include "llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h"
34#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
35#include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
36#include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
37#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
38#include "llvm/DebugInfo/PDB/PDBSymbol.h"
39#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
40
41using namespace llvm;
42using namespace llvm::codeview;
43using namespace llvm::pdb;
44
45// Maps codeview::SimpleTypeKind of a built-in type to the parameters necessary
46// to instantiate a NativeBuiltinSymbol for that type.
47static const struct BuiltinTypeEntry {
48 codeview::SimpleTypeKind Kind;
49 PDB_BuiltinType Type;
50 uint32_t Size;
51} BuiltinTypes[] = {
52 {.Kind: codeview::SimpleTypeKind::None, .Type: PDB_BuiltinType::None, .Size: 0},
53 {.Kind: codeview::SimpleTypeKind::Void, .Type: PDB_BuiltinType::Void, .Size: 0},
54 {.Kind: codeview::SimpleTypeKind::HResult, .Type: PDB_BuiltinType::HResult, .Size: 4},
55 {.Kind: codeview::SimpleTypeKind::Int16Short, .Type: PDB_BuiltinType::Int, .Size: 2},
56 {.Kind: codeview::SimpleTypeKind::UInt16Short, .Type: PDB_BuiltinType::UInt, .Size: 2},
57 {.Kind: codeview::SimpleTypeKind::Int32, .Type: PDB_BuiltinType::Int, .Size: 4},
58 {.Kind: codeview::SimpleTypeKind::UInt32, .Type: PDB_BuiltinType::UInt, .Size: 4},
59 {.Kind: codeview::SimpleTypeKind::Int32Long, .Type: PDB_BuiltinType::Int, .Size: 4},
60 {.Kind: codeview::SimpleTypeKind::UInt32Long, .Type: PDB_BuiltinType::UInt, .Size: 4},
61 {.Kind: codeview::SimpleTypeKind::Int64Quad, .Type: PDB_BuiltinType::Int, .Size: 8},
62 {.Kind: codeview::SimpleTypeKind::UInt64Quad, .Type: PDB_BuiltinType::UInt, .Size: 8},
63 {.Kind: codeview::SimpleTypeKind::NarrowCharacter, .Type: PDB_BuiltinType::Char, .Size: 1},
64 {.Kind: codeview::SimpleTypeKind::WideCharacter, .Type: PDB_BuiltinType::WCharT, .Size: 2},
65 {.Kind: codeview::SimpleTypeKind::Character16, .Type: PDB_BuiltinType::Char16, .Size: 2},
66 {.Kind: codeview::SimpleTypeKind::Character32, .Type: PDB_BuiltinType::Char32, .Size: 4},
67 {.Kind: codeview::SimpleTypeKind::Character8, .Type: PDB_BuiltinType::Char8, .Size: 1},
68 {.Kind: codeview::SimpleTypeKind::SignedCharacter, .Type: PDB_BuiltinType::Char, .Size: 1},
69 {.Kind: codeview::SimpleTypeKind::UnsignedCharacter, .Type: PDB_BuiltinType::UInt, .Size: 1},
70 {.Kind: codeview::SimpleTypeKind::Float32, .Type: PDB_BuiltinType::Float, .Size: 4},
71 {.Kind: codeview::SimpleTypeKind::Float64, .Type: PDB_BuiltinType::Float, .Size: 8},
72 {.Kind: codeview::SimpleTypeKind::Float80, .Type: PDB_BuiltinType::Float, .Size: 10},
73 {.Kind: codeview::SimpleTypeKind::Boolean8, .Type: PDB_BuiltinType::Bool, .Size: 1},
74 // This table can be grown as necessary, but these are the only types we've
75 // needed so far.
76};
77
78SymbolCache::SymbolCache(NativeSession &Session, DbiStream *Dbi)
79 : Session(Session), Dbi(Dbi), AddressToSymbolId(IMapAllocator) {
80 // Id 0 is reserved for the invalid symbol.
81 Cache.push_back(x: nullptr);
82 SourceFiles.push_back(x: nullptr);
83
84 if (Dbi)
85 Compilands.resize(new_size: Dbi->modules().getModuleCount());
86}
87
88std::unique_ptr<IPDBEnumSymbols>
89SymbolCache::createTypeEnumerator(TypeLeafKind Kind) {
90 return createTypeEnumerator(Kinds: std::vector<TypeLeafKind>{Kind});
91}
92
93std::unique_ptr<IPDBEnumSymbols>
94SymbolCache::createTypeEnumerator(std::vector<TypeLeafKind> Kinds) {
95 auto Tpi = Session.getPDBFile().getPDBTpiStream();
96 if (!Tpi) {
97 consumeError(Err: Tpi.takeError());
98 return nullptr;
99 }
100 auto &Types = Tpi->typeCollection();
101 return std::unique_ptr<IPDBEnumSymbols>(
102 new NativeEnumTypes(Session, Types, std::move(Kinds)));
103}
104
105std::unique_ptr<IPDBEnumSymbols>
106SymbolCache::createGlobalsEnumerator(codeview::SymbolKind Kind) {
107 return std::unique_ptr<IPDBEnumSymbols>(
108 new NativeEnumGlobals(Session, {Kind}));
109}
110
111SymIndexId SymbolCache::createSimpleType(TypeIndex Index,
112 ModifierOptions Mods) const {
113 if (Index.getSimpleMode() != codeview::SimpleTypeMode::Direct)
114 return createSymbol<NativeTypePointer>(ConstructorArgs&: Index);
115
116 const auto Kind = Index.getSimpleKind();
117 const auto It =
118 llvm::find_if(Range: BuiltinTypes, P: [Kind](const BuiltinTypeEntry &Builtin) {
119 return Builtin.Kind == Kind;
120 });
121 if (It == std::end(arr: BuiltinTypes))
122 return 0;
123 return createSymbol<NativeTypeBuiltin>(ConstructorArgs&: Mods, ConstructorArgs: It->Type, ConstructorArgs: It->Size);
124}
125
126SymIndexId
127SymbolCache::createSymbolForModifiedType(codeview::TypeIndex ModifierTI,
128 codeview::CVType CVT) const {
129 ModifierRecord Record;
130 if (auto EC = TypeDeserializer::deserializeAs<ModifierRecord>(CVT, Record)) {
131 consumeError(Err: std::move(EC));
132 return 0;
133 }
134
135 if (Record.ModifiedType.isSimple())
136 return createSimpleType(Index: Record.ModifiedType, Mods: Record.Modifiers);
137
138 // Make sure we create and cache a record for the unmodified type.
139 SymIndexId UnmodifiedId = findSymbolByTypeIndex(TI: Record.ModifiedType);
140 NativeRawSymbol &UnmodifiedNRS = *Cache[UnmodifiedId];
141
142 switch (UnmodifiedNRS.getSymTag()) {
143 case PDB_SymType::Enum:
144 return createSymbol<NativeTypeEnum>(
145 ConstructorArgs&: static_cast<NativeTypeEnum &>(UnmodifiedNRS), ConstructorArgs: std::move(Record));
146 case PDB_SymType::UDT:
147 return createSymbol<NativeTypeUDT>(
148 ConstructorArgs&: static_cast<NativeTypeUDT &>(UnmodifiedNRS), ConstructorArgs: std::move(Record));
149 default:
150 // No other types can be modified. (LF_POINTER, for example, records
151 // its modifiers a different way.
152 assert(false && "Invalid LF_MODIFIER record");
153 break;
154 }
155 return 0;
156}
157
158SymIndexId SymbolCache::findSymbolByTypeIndex(codeview::TypeIndex Index) const {
159 // First see if it's already in our cache.
160 const auto Entry = TypeIndexToSymbolId.find(Val: Index);
161 if (Entry != TypeIndexToSymbolId.end())
162 return Entry->second;
163
164 // Symbols for built-in types are created on the fly.
165 if (Index.isSimple()) {
166 SymIndexId Result = createSimpleType(Index, Mods: ModifierOptions::None);
167 assert(TypeIndexToSymbolId.count(Index) == 0);
168 TypeIndexToSymbolId[Index] = Result;
169 return Result;
170 }
171
172 // We need to instantiate and cache the desired type symbol.
173 auto Tpi = Session.getPDBFile().getPDBTpiStream();
174 if (!Tpi) {
175 consumeError(Err: Tpi.takeError());
176 return 0;
177 }
178 codeview::LazyRandomTypeCollection &Types = Tpi->typeCollection();
179 codeview::CVType CVT = Types.getType(Index);
180
181 if (isUdtForwardRef(CVT)) {
182 Expected<TypeIndex> EFD = Tpi->findFullDeclForForwardRef(ForwardRefTI: Index);
183
184 if (!EFD)
185 consumeError(Err: EFD.takeError());
186 else if (*EFD != Index) {
187 assert(!isUdtForwardRef(Types.getType(*EFD)));
188 SymIndexId Result = findSymbolByTypeIndex(Index: *EFD);
189 // Record a mapping from ForwardRef -> SymIndex of complete type so that
190 // we'll take the fast path next time.
191 assert(TypeIndexToSymbolId.count(Index) == 0);
192 TypeIndexToSymbolId[Index] = Result;
193 return Result;
194 }
195 }
196
197 // At this point if we still have a forward ref udt it means the full decl was
198 // not in the PDB. We just have to deal with it and use the forward ref.
199 SymIndexId Id = 0;
200 switch (CVT.kind()) {
201 case codeview::LF_ENUM:
202 Id = createSymbolForType<NativeTypeEnum, EnumRecord>(TI: Index, CVT: std::move(CVT));
203 break;
204 case codeview::LF_ARRAY:
205 Id = createSymbolForType<NativeTypeArray, ArrayRecord>(TI: Index,
206 CVT: std::move(CVT));
207 break;
208 case codeview::LF_CLASS:
209 case codeview::LF_CLASS2:
210 case codeview::LF_STRUCTURE:
211 case codeview::LF_STRUCTURE2:
212 case codeview::LF_INTERFACE:
213 case codeview::LF_INTERFACE2:
214 Id = createSymbolForType<NativeTypeUDT, ClassRecord>(TI: Index, CVT: std::move(CVT));
215 break;
216 case codeview::LF_UNION:
217 case codeview::LF_UNION2:
218 Id = createSymbolForType<NativeTypeUDT, UnionRecord>(TI: Index, CVT: std::move(CVT));
219 break;
220 case codeview::LF_POINTER:
221 Id = createSymbolForType<NativeTypePointer, PointerRecord>(TI: Index,
222 CVT: std::move(CVT));
223 break;
224 case codeview::LF_MODIFIER:
225 Id = createSymbolForModifiedType(ModifierTI: Index, CVT: std::move(CVT));
226 break;
227 case codeview::LF_PROCEDURE:
228 Id = createSymbolForType<NativeTypeFunctionSig, ProcedureRecord>(
229 TI: Index, CVT: std::move(CVT));
230 break;
231 case codeview::LF_MFUNCTION:
232 Id = createSymbolForType<NativeTypeFunctionSig, MemberFunctionRecord>(
233 TI: Index, CVT: std::move(CVT));
234 break;
235 case codeview::LF_VTSHAPE:
236 Id = createSymbolForType<NativeTypeVTShape, VFTableShapeRecord>(
237 TI: Index, CVT: std::move(CVT));
238 break;
239 default:
240 Id = createSymbolPlaceholder();
241 break;
242 }
243 if (Id != 0) {
244 assert(TypeIndexToSymbolId.count(Index) == 0);
245 TypeIndexToSymbolId[Index] = Id;
246 }
247 return Id;
248}
249
250std::unique_ptr<PDBSymbol>
251SymbolCache::getSymbolById(SymIndexId SymbolId) const {
252 assert(SymbolId < Cache.size());
253
254 // Id 0 is reserved.
255 if (SymbolId == 0 || SymbolId >= Cache.size())
256 return nullptr;
257
258 // Make sure to handle the case where we've inserted a placeholder symbol
259 // for types we don't yet support.
260 NativeRawSymbol *NRS = Cache[SymbolId].get();
261 if (!NRS)
262 return nullptr;
263
264 return PDBSymbol::create(PDBSession: Session, RawSymbol&: *NRS);
265}
266
267NativeRawSymbol &SymbolCache::getNativeSymbolById(SymIndexId SymbolId) const {
268 return *Cache[SymbolId];
269}
270
271uint32_t SymbolCache::getNumCompilands() const {
272 if (!Dbi)
273 return 0;
274
275 return Dbi->modules().getModuleCount();
276}
277
278SymIndexId SymbolCache::getOrCreateGlobalSymbolByOffset(uint32_t Offset) {
279 auto Iter = GlobalOffsetToSymbolId.find(Val: Offset);
280 if (Iter != GlobalOffsetToSymbolId.end())
281 return Iter->second;
282
283 SymbolStream &SS = cantFail(ValOrErr: Session.getPDBFile().getPDBSymbolStream());
284 CVSymbol CVS = SS.readRecord(Offset);
285 SymIndexId Id = 0;
286 switch (CVS.kind()) {
287 case SymbolKind::S_UDT: {
288 UDTSym US = cantFail(ValOrErr: SymbolDeserializer::deserializeAs<UDTSym>(Symbol: CVS));
289 Id = createSymbol<NativeTypeTypedef>(ConstructorArgs: std::move(US));
290 break;
291 }
292 default:
293 Id = createSymbolPlaceholder();
294 break;
295 }
296 if (Id != 0) {
297 assert(GlobalOffsetToSymbolId.count(Offset) == 0);
298 GlobalOffsetToSymbolId[Offset] = Id;
299 }
300
301 return Id;
302}
303
304SymIndexId SymbolCache::getOrCreateInlineSymbol(InlineSiteSym Sym,
305 uint64_t ParentAddr,
306 uint16_t Modi,
307 uint32_t RecordOffset) const {
308 auto Iter = SymTabOffsetToSymbolId.find(Val: {Modi, RecordOffset});
309 if (Iter != SymTabOffsetToSymbolId.end())
310 return Iter->second;
311
312 SymIndexId Id = createSymbol<NativeInlineSiteSymbol>(ConstructorArgs&: Sym, ConstructorArgs&: ParentAddr);
313 SymTabOffsetToSymbolId.insert(KV: {{Modi, RecordOffset}, Id});
314 return Id;
315}
316
317std::unique_ptr<PDBSymbol> SymbolCache::findSymbolByVA(uint64_t VA,
318 PDB_SymType Type) {
319 switch (Type) {
320 case PDB_SymType::Function:
321 return findFunctionSymbolByVA(VA);
322 case PDB_SymType::PublicSymbol: {
323 uint32_t Sect, Offset;
324 Session.addressForVA(VA, Section&: Sect, Offset);
325 return findPublicSymbolBySectOffset(Sect, Offset);
326 }
327 case PDB_SymType::Compiland: {
328 uint16_t Modi;
329 if (!Session.moduleIndexForVA(VA, ModuleIndex&: Modi))
330 return nullptr;
331 return getOrCreateCompiland(Index: Modi);
332 }
333 case PDB_SymType::None: {
334 // FIXME: Implement for PDB_SymType::Data. The symbolizer calls this but
335 // only uses it to find the symbol length.
336 if (auto Sym = findFunctionSymbolByVA(VA))
337 return Sym;
338 return nullptr;
339 }
340 default:
341 return nullptr;
342 }
343}
344
345std::unique_ptr<PDBSymbol> SymbolCache::findFunctionSymbolByVA(uint64_t VA) {
346 if (!Dbi)
347 return nullptr;
348
349 auto findIdInCache = [this](uint64_t VA) -> SymIndexId {
350 auto Iter = AddressToSymbolId.find(x: VA);
351 if (Iter.valid() && !IMapTy::KeyTraits::startLess(x: VA, a: Iter.start()))
352 return *Iter;
353 return 0;
354 };
355
356 if (SymIndexId Id = findIdInCache(VA))
357 return getSymbolById(SymbolId: Id);
358
359 uint16_t Modi;
360 if (!Session.moduleIndexForVA(VA, ModuleIndex&: Modi))
361 return nullptr;
362
363 // Module has already been decoded and no cached symbols found.
364 if (!FuncSymCachedModIndexes.insert(V: Modi).second)
365 return nullptr;
366
367 Expected<ModuleDebugStreamRef> ExpectedModS =
368 Session.getModuleDebugStream(Index: Modi);
369 if (!ExpectedModS) {
370 consumeError(Err: ExpectedModS.takeError());
371 return nullptr;
372 }
373
374 // Return empty intervals in AddressToSymbolId from Start to Stop.
375 auto getInsertRanges = [this](uint64_t Start, uint64_t Stop) {
376 SmallVector<std::pair<uint64_t, uint64_t>> Ranges;
377 auto Iter = AddressToSymbolId.find(x: Start);
378 while (Iter.valid() && IMapTy::KeyTraits::nonEmpty(a: Start, b: Stop)) {
379 if (IMapTy::KeyTraits::startLess(x: Start, a: Iter.start()))
380 Ranges.push_back(Elt: {Start, std::min(a: Iter.start(), b: Stop)});
381
382 // Same result as Start = std::min(Stop, Iter.stop()).
383 Start = Iter.stop();
384 ++Iter;
385 }
386 if (IMapTy::KeyTraits::nonEmpty(a: Start, b: Stop))
387 Ranges.push_back(Elt: {Start, Stop});
388
389 return Ranges;
390 };
391
392 // Decode symbols in this module.
393 CVSymbolArray Syms = ExpectedModS->getSymbolArray();
394 for (auto I = Syms.begin(), E = Syms.end(); I != E; ++I) {
395 if (I->kind() != S_LPROC32 && I->kind() != S_GPROC32)
396 continue;
397
398 auto PS = cantFail(ValOrErr: SymbolDeserializer::deserializeAs<ProcSym>(Symbol: *I));
399 uint64_t SymStart = Session.getVAFromSectOffset(Section: PS.Segment, Offset: PS.CodeOffset);
400 uint64_t SymStop = SymStart + PS.CodeSize;
401 if (LLVM_UNLIKELY(!IMapTy::KeyTraits::nonEmpty(SymStart, SymStop))) {
402 I = Syms.at(Offset: PS.End);
403 continue;
404 }
405#ifndef NDEBUG
406 Session.checkSymbolRange(SymStart, SymStop);
407#endif
408 // Only care about range that is in this module.
409 uint16_t SymModi;
410 if (!Session.moduleIndexForVA(VA: SymStart, ModuleIndex&: SymModi) || SymModi != Modi)
411 continue;
412
413 auto Ranges = getInsertRanges(SymStart, SymStop);
414 if (!Ranges.empty()) {
415 SymIndexId Id = createSymbol<NativeFunctionSymbol>(ConstructorArgs&: PS, ConstructorArgs: I.offset());
416 for (auto [Start, Stop] : Ranges)
417 AddressToSymbolId.insert(a: Start, b: Stop, y: Id);
418 }
419
420 // Jump to the end of this ProcSym.
421 I = Syms.at(Offset: PS.End);
422 }
423
424 if (SymIndexId Id = findIdInCache(VA))
425 return getSymbolById(SymbolId: Id);
426
427 return nullptr;
428}
429
430std::unique_ptr<PDBSymbol>
431SymbolCache::findPublicSymbolBySectOffset(uint32_t Sect, uint32_t Offset) {
432 auto Iter = AddressToPublicSymId.find(Val: {Sect, Offset});
433 if (Iter != AddressToPublicSymId.end())
434 return getSymbolById(SymbolId: Iter->second);
435
436 auto Publics = Session.getPDBFile().getPDBPublicsStream();
437 if (!Publics) {
438 consumeError(Err: Publics.takeError());
439 return nullptr;
440 }
441
442 auto ExpectedSyms = Session.getPDBFile().getPDBSymbolStream();
443 if (!ExpectedSyms) {
444 consumeError(Err: ExpectedSyms.takeError());
445 return nullptr;
446 }
447 BinaryStreamRef SymStream =
448 ExpectedSyms->getSymbolArray().getUnderlyingStream();
449
450 // Use binary search to find the first public symbol with an address greater
451 // than or equal to Sect, Offset.
452 auto AddrMap = Publics->getAddressMap();
453 auto First = AddrMap.begin();
454 auto It = AddrMap.begin();
455 size_t Count = AddrMap.size();
456 size_t Half;
457 while (Count > 0) {
458 It = First;
459 Half = Count / 2;
460 It += Half;
461 Expected<CVSymbol> Sym = readSymbolFromStream(Stream: SymStream, Offset: *It);
462 if (!Sym) {
463 consumeError(Err: Sym.takeError());
464 return nullptr;
465 }
466
467 auto PS =
468 cantFail(ValOrErr: SymbolDeserializer::deserializeAs<PublicSym32>(Symbol: Sym.get()));
469 if (PS.Segment < Sect || (PS.Segment == Sect && PS.Offset <= Offset)) {
470 First = ++It;
471 Count -= Half + 1;
472 } else
473 Count = Half;
474 }
475 if (It == AddrMap.begin())
476 return nullptr;
477 --It;
478
479 Expected<CVSymbol> Sym = readSymbolFromStream(Stream: SymStream, Offset: *It);
480 if (!Sym) {
481 consumeError(Err: Sym.takeError());
482 return nullptr;
483 }
484
485 // Check if the symbol is already cached.
486 auto PS = cantFail(ValOrErr: SymbolDeserializer::deserializeAs<PublicSym32>(Symbol: Sym.get()));
487 auto Found = AddressToPublicSymId.find(Val: {PS.Segment, PS.Offset});
488 if (Found != AddressToPublicSymId.end())
489 return getSymbolById(SymbolId: Found->second);
490
491 // Otherwise, create a new symbol.
492 SymIndexId Id = createSymbol<NativePublicSymbol>(ConstructorArgs&: PS);
493 AddressToPublicSymId.insert(KV: {{PS.Segment, PS.Offset}, Id});
494 return getSymbolById(SymbolId: Id);
495}
496
497std::vector<SymbolCache::LineTableEntry>
498SymbolCache::findLineTable(uint16_t Modi) const {
499 // Check if this module has already been added.
500 auto [LineTableIter, Inserted] = LineTable.try_emplace(Key: Modi);
501 if (!Inserted)
502 return LineTableIter->second;
503
504 std::vector<LineTableEntry> &ModuleLineTable = LineTableIter->second;
505
506 // If there is an error or there are no lines, just return the
507 // empty vector.
508 Expected<ModuleDebugStreamRef> ExpectedModS =
509 Session.getModuleDebugStream(Index: Modi);
510 if (!ExpectedModS) {
511 consumeError(Err: ExpectedModS.takeError());
512 return ModuleLineTable;
513 }
514
515 std::vector<std::vector<LineTableEntry>> EntryList;
516 for (const auto &SS : ExpectedModS->getSubsectionsArray()) {
517 if (SS.kind() != DebugSubsectionKind::Lines)
518 continue;
519
520 DebugLinesSubsectionRef Lines;
521 BinaryStreamReader Reader(SS.getRecordData());
522 if (auto EC = Lines.initialize(Reader)) {
523 consumeError(Err: std::move(EC));
524 continue;
525 }
526
527 uint32_t RelocSegment = Lines.header()->RelocSegment;
528 uint32_t RelocOffset = Lines.header()->RelocOffset;
529 for (const LineColumnEntry &Group : Lines) {
530 if (Group.LineNumbers.empty())
531 continue;
532
533 std::vector<LineTableEntry> Entries;
534
535 // If there are column numbers, then they should be in a parallel stream
536 // to the line numbers.
537 auto ColIt = Group.Columns.begin();
538 auto ColsEnd = Group.Columns.end();
539
540 // Add a line to mark the beginning of this section.
541 uint64_t StartAddr =
542 Session.getVAFromSectOffset(Section: RelocSegment, Offset: RelocOffset);
543 LineInfo FirstLine(Group.LineNumbers.front().Flags);
544 uint32_t ColNum =
545 (Lines.hasColumnInfo()) ? Group.Columns.front().StartColumn : 0;
546 Entries.push_back(x: {.Addr: StartAddr, .Line: FirstLine, .ColumnNumber: ColNum, .FileNameIndex: Group.NameIndex, .IsTerminalEntry: false});
547
548 for (const LineNumberEntry &LN : Group.LineNumbers) {
549 uint64_t VA =
550 Session.getVAFromSectOffset(Section: RelocSegment, Offset: RelocOffset + LN.Offset);
551 LineInfo Line(LN.Flags);
552 ColNum = 0;
553
554 if (Lines.hasColumnInfo() && ColIt != ColsEnd) {
555 ColNum = ColIt->StartColumn;
556 ++ColIt;
557 }
558 Entries.push_back(x: {.Addr: VA, .Line: Line, .ColumnNumber: ColNum, .FileNameIndex: Group.NameIndex, .IsTerminalEntry: false});
559 }
560
561 // Add a terminal entry line to mark the end of this subsection.
562 uint64_t EndAddr = StartAddr + Lines.header()->CodeSize;
563 LineInfo LastLine(Group.LineNumbers.back().Flags);
564 ColNum = (Lines.hasColumnInfo()) ? Group.Columns.back().StartColumn : 0;
565 Entries.push_back(x: {.Addr: EndAddr, .Line: LastLine, .ColumnNumber: ColNum, .FileNameIndex: Group.NameIndex, .IsTerminalEntry: true});
566
567 EntryList.push_back(x: Entries);
568 }
569 }
570
571 // Sort EntryList, and add flattened contents to the line table.
572 llvm::sort(C&: EntryList, Comp: [](const std::vector<LineTableEntry> &LHS,
573 const std::vector<LineTableEntry> &RHS) {
574 return LHS[0].Addr < RHS[0].Addr;
575 });
576 for (std::vector<LineTableEntry> &I : EntryList)
577 llvm::append_range(C&: ModuleLineTable, R&: I);
578
579 return ModuleLineTable;
580}
581
582std::unique_ptr<IPDBEnumLineNumbers>
583SymbolCache::findLineNumbersByVA(uint64_t VA, uint32_t Length) const {
584 uint16_t Modi;
585 if (!Session.moduleIndexForVA(VA, ModuleIndex&: Modi))
586 return nullptr;
587
588 std::vector<LineTableEntry> Lines = findLineTable(Modi);
589 if (Lines.empty())
590 return nullptr;
591
592 // Find the first line in the line table whose address is not greater than
593 // the one we are searching for.
594 auto LineIter = llvm::partition_point(Range&: Lines, P: [&](const LineTableEntry &E) {
595 return (E.Addr < VA || (E.Addr == VA && E.IsTerminalEntry));
596 });
597
598 // Try to back up if we've gone too far.
599 if (LineIter == Lines.end() || LineIter->Addr > VA) {
600 if (LineIter == Lines.begin() || std::prev(x: LineIter)->IsTerminalEntry)
601 return nullptr;
602 --LineIter;
603 }
604
605 Expected<ModuleDebugStreamRef> ExpectedModS =
606 Session.getModuleDebugStream(Index: Modi);
607 if (!ExpectedModS) {
608 consumeError(Err: ExpectedModS.takeError());
609 return nullptr;
610 }
611 Expected<DebugChecksumsSubsectionRef> ExpectedChecksums =
612 ExpectedModS->findChecksumsSubsection();
613 if (!ExpectedChecksums) {
614 consumeError(Err: ExpectedChecksums.takeError());
615 return nullptr;
616 }
617
618 // Populate a vector of NativeLineNumbers that have addresses in the given
619 // address range.
620 std::vector<NativeLineNumber> LineNumbers;
621 while (LineIter != Lines.end()) {
622 if (LineIter->IsTerminalEntry) {
623 ++LineIter;
624 continue;
625 }
626
627 // If the line is still within the address range, create a NativeLineNumber
628 // and add to the list.
629 if (LineIter->Addr > VA + Length)
630 break;
631
632 uint32_t LineSect, LineOff;
633 Session.addressForVA(VA: LineIter->Addr, Section&: LineSect, Offset&: LineOff);
634 uint32_t LineLength = std::next(x: LineIter)->Addr - LineIter->Addr;
635 auto ChecksumIter =
636 ExpectedChecksums->getArray().at(Offset: LineIter->FileNameIndex);
637 uint32_t SrcFileId = getOrCreateSourceFile(Checksum: *ChecksumIter);
638 NativeLineNumber LineNum(Session, LineIter->Line, LineIter->ColumnNumber,
639 LineSect, LineOff, LineLength, SrcFileId, Modi);
640 LineNumbers.push_back(x: LineNum);
641 ++LineIter;
642 }
643 return std::make_unique<NativeEnumLineNumbers>(args: std::move(LineNumbers));
644}
645
646std::unique_ptr<PDBSymbolCompiland>
647SymbolCache::getOrCreateCompiland(uint32_t Index) {
648 if (!Dbi)
649 return nullptr;
650
651 if (Index >= Compilands.size())
652 return nullptr;
653
654 if (Compilands[Index] == 0) {
655 const DbiModuleList &Modules = Dbi->modules();
656 Compilands[Index] =
657 createSymbol<NativeCompilandSymbol>(ConstructorArgs: Modules.getModuleDescriptor(Modi: Index));
658 }
659
660 return Session.getConcreteSymbolById<PDBSymbolCompiland>(SymbolId: Compilands[Index]);
661}
662
663std::unique_ptr<IPDBSourceFile>
664SymbolCache::getSourceFileById(SymIndexId FileId) const {
665 assert(FileId < SourceFiles.size());
666
667 // Id 0 is reserved.
668 if (FileId == 0)
669 return nullptr;
670
671 return std::make_unique<NativeSourceFile>(args&: *SourceFiles[FileId].get());
672}
673
674SymIndexId
675SymbolCache::getOrCreateSourceFile(const FileChecksumEntry &Checksums) const {
676 auto [Iter, Inserted] =
677 FileNameOffsetToId.try_emplace(Key: Checksums.FileNameOffset);
678 if (!Inserted)
679 return Iter->second;
680
681 SymIndexId Id = SourceFiles.size();
682 auto SrcFile = std::make_unique<NativeSourceFile>(args&: Session, args&: Id, args: Checksums);
683 SourceFiles.push_back(x: std::move(SrcFile));
684 Iter->second = Id;
685 return Id;
686}
687
688
689