1 #include "llvm/DebugInfo/PDB/Native/SymbolCache.h"
3 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
4 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
5 #include "llvm/DebugInfo/CodeView/TypeRecordHelpers.h"
6 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
7 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
8 #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
9 #include "llvm/DebugInfo/PDB/Native/NativeEnumGlobals.h"
10 #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
11 #include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
12 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
13 #include "llvm/DebugInfo/PDB/Native/NativeTypeArray.h"
14 #include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
15 #include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
16 #include "llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h"
17 #include "llvm/DebugInfo/PDB/Native/NativeTypePointer.h"
18 #include "llvm/DebugInfo/PDB/Native/NativeTypeTypedef.h"
19 #include "llvm/DebugInfo/PDB/Native/NativeTypeUDT.h"
20 #include "llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h"
21 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
22 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
23 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
24 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
25 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
26 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
29 using namespace llvm::codeview;
30 using namespace llvm::pdb;
32 // Maps codeview::SimpleTypeKind of a built-in type to the parameters necessary
33 // to instantiate a NativeBuiltinSymbol for that type.
34 static const struct BuiltinTypeEntry {
35 codeview::SimpleTypeKind Kind;
39 {codeview::SimpleTypeKind::None, PDB_BuiltinType::None, 0},
40 {codeview::SimpleTypeKind::Void, PDB_BuiltinType::Void, 0},
41 {codeview::SimpleTypeKind::HResult, PDB_BuiltinType::HResult, 4},
42 {codeview::SimpleTypeKind::Int16Short, PDB_BuiltinType::Int, 2},
43 {codeview::SimpleTypeKind::UInt16Short, PDB_BuiltinType::UInt, 2},
44 {codeview::SimpleTypeKind::Int32, PDB_BuiltinType::Int, 4},
45 {codeview::SimpleTypeKind::UInt32, PDB_BuiltinType::UInt, 4},
46 {codeview::SimpleTypeKind::Int32Long, PDB_BuiltinType::Int, 4},
47 {codeview::SimpleTypeKind::UInt32Long, PDB_BuiltinType::UInt, 4},
48 {codeview::SimpleTypeKind::Int64Quad, PDB_BuiltinType::Int, 8},
49 {codeview::SimpleTypeKind::UInt64Quad, PDB_BuiltinType::UInt, 8},
50 {codeview::SimpleTypeKind::NarrowCharacter, PDB_BuiltinType::Char, 1},
51 {codeview::SimpleTypeKind::WideCharacter, PDB_BuiltinType::WCharT, 2},
52 {codeview::SimpleTypeKind::Character16, PDB_BuiltinType::Char16, 2},
53 {codeview::SimpleTypeKind::Character32, PDB_BuiltinType::Char32, 4},
54 {codeview::SimpleTypeKind::SignedCharacter, PDB_BuiltinType::Char, 1},
55 {codeview::SimpleTypeKind::UnsignedCharacter, PDB_BuiltinType::UInt, 1},
56 {codeview::SimpleTypeKind::Float32, PDB_BuiltinType::Float, 4},
57 {codeview::SimpleTypeKind::Float64, PDB_BuiltinType::Float, 8},
58 {codeview::SimpleTypeKind::Float80, PDB_BuiltinType::Float, 10},
59 {codeview::SimpleTypeKind::Boolean8, PDB_BuiltinType::Bool, 1},
60 // This table can be grown as necessary, but these are the only types we've
64 SymbolCache::SymbolCache(NativeSession &Session, DbiStream *Dbi)
65 : Session(Session), Dbi(Dbi) {
66 // Id 0 is reserved for the invalid symbol.
67 Cache.push_back(nullptr);
70 Compilands.resize(Dbi->modules().getModuleCount());
73 std::unique_ptr<IPDBEnumSymbols>
74 SymbolCache::createTypeEnumerator(TypeLeafKind Kind) {
75 return createTypeEnumerator(std::vector<TypeLeafKind>{Kind});
78 std::unique_ptr<IPDBEnumSymbols>
79 SymbolCache::createTypeEnumerator(std::vector<TypeLeafKind> Kinds) {
80 auto Tpi = Session.getPDBFile().getPDBTpiStream();
82 consumeError(Tpi.takeError());
85 auto &Types = Tpi->typeCollection();
86 return std::unique_ptr<IPDBEnumSymbols>(
87 new NativeEnumTypes(Session, Types, std::move(Kinds)));
90 std::unique_ptr<IPDBEnumSymbols>
91 SymbolCache::createGlobalsEnumerator(codeview::SymbolKind Kind) {
92 return std::unique_ptr<IPDBEnumSymbols>(
93 new NativeEnumGlobals(Session, {Kind}));
96 SymIndexId SymbolCache::createSimpleType(TypeIndex Index,
97 ModifierOptions Mods) {
98 if (Index.getSimpleMode() != codeview::SimpleTypeMode::Direct)
99 return createSymbol<NativeTypePointer>(Index);
101 const auto Kind = Index.getSimpleKind();
102 const auto It = std::find_if(
103 std::begin(BuiltinTypes), std::end(BuiltinTypes),
104 [Kind](const BuiltinTypeEntry &Builtin) { return Builtin.Kind == Kind; });
105 if (It == std::end(BuiltinTypes))
107 return createSymbol<NativeTypeBuiltin>(Mods, It->Type, It->Size);
111 SymbolCache::createSymbolForModifiedType(codeview::TypeIndex ModifierTI,
112 codeview::CVType CVT) {
113 ModifierRecord Record;
114 if (auto EC = TypeDeserializer::deserializeAs<ModifierRecord>(CVT, Record)) {
115 consumeError(std::move(EC));
119 if (Record.ModifiedType.isSimple())
120 return createSimpleType(Record.ModifiedType, Record.Modifiers);
122 // Make sure we create and cache a record for the unmodified type.
123 SymIndexId UnmodifiedId = findSymbolByTypeIndex(Record.ModifiedType);
124 NativeRawSymbol &UnmodifiedNRS = *Cache[UnmodifiedId];
126 switch (UnmodifiedNRS.getSymTag()) {
127 case PDB_SymType::Enum:
128 return createSymbol<NativeTypeEnum>(
129 static_cast<NativeTypeEnum &>(UnmodifiedNRS), std::move(Record));
130 case PDB_SymType::UDT:
131 return createSymbol<NativeTypeUDT>(
132 static_cast<NativeTypeUDT &>(UnmodifiedNRS), std::move(Record));
134 // No other types can be modified. (LF_POINTER, for example, records
135 // its modifiers a different way.
136 assert(false && "Invalid LF_MODIFIER record");
142 SymIndexId SymbolCache::findSymbolByTypeIndex(codeview::TypeIndex Index) {
143 // First see if it's already in our cache.
144 const auto Entry = TypeIndexToSymbolId.find(Index);
145 if (Entry != TypeIndexToSymbolId.end())
146 return Entry->second;
148 // Symbols for built-in types are created on the fly.
149 if (Index.isSimple()) {
150 SymIndexId Result = createSimpleType(Index, ModifierOptions::None);
151 assert(TypeIndexToSymbolId.count(Index) == 0);
152 TypeIndexToSymbolId[Index] = Result;
156 // We need to instantiate and cache the desired type symbol.
157 auto Tpi = Session.getPDBFile().getPDBTpiStream();
159 consumeError(Tpi.takeError());
162 codeview::LazyRandomTypeCollection &Types = Tpi->typeCollection();
163 codeview::CVType CVT = Types.getType(Index);
165 if (isUdtForwardRef(CVT)) {
166 Expected<TypeIndex> EFD = Tpi->findFullDeclForForwardRef(Index);
169 consumeError(EFD.takeError());
170 else if (*EFD != Index) {
171 assert(!isUdtForwardRef(Types.getType(*EFD)));
172 SymIndexId Result = findSymbolByTypeIndex(*EFD);
173 // Record a mapping from ForwardRef -> SymIndex of complete type so that
174 // we'll take the fast path next time.
175 assert(TypeIndexToSymbolId.count(Index) == 0);
176 TypeIndexToSymbolId[Index] = Result;
181 // At this point if we still have a forward ref udt it means the full decl was
182 // not in the PDB. We just have to deal with it and use the forward ref.
184 switch (CVT.kind()) {
185 case codeview::LF_ENUM:
186 Id = createSymbolForType<NativeTypeEnum, EnumRecord>(Index, std::move(CVT));
188 case codeview::LF_ARRAY:
189 Id = createSymbolForType<NativeTypeArray, ArrayRecord>(Index,
192 case codeview::LF_CLASS:
193 case codeview::LF_STRUCTURE:
194 case codeview::LF_INTERFACE:
195 Id = createSymbolForType<NativeTypeUDT, ClassRecord>(Index, std::move(CVT));
197 case codeview::LF_UNION:
198 Id = createSymbolForType<NativeTypeUDT, UnionRecord>(Index, std::move(CVT));
200 case codeview::LF_POINTER:
201 Id = createSymbolForType<NativeTypePointer, PointerRecord>(Index,
204 case codeview::LF_MODIFIER:
205 Id = createSymbolForModifiedType(Index, std::move(CVT));
207 case codeview::LF_PROCEDURE:
208 Id = createSymbolForType<NativeTypeFunctionSig, ProcedureRecord>(
209 Index, std::move(CVT));
211 case codeview::LF_MFUNCTION:
212 Id = createSymbolForType<NativeTypeFunctionSig, MemberFunctionRecord>(
213 Index, std::move(CVT));
215 case codeview::LF_VTSHAPE:
216 Id = createSymbolForType<NativeTypeVTShape, VFTableShapeRecord>(
217 Index, std::move(CVT));
220 Id = createSymbolPlaceholder();
224 assert(TypeIndexToSymbolId.count(Index) == 0);
225 TypeIndexToSymbolId[Index] = Id;
230 std::unique_ptr<PDBSymbol>
231 SymbolCache::getSymbolById(SymIndexId SymbolId) const {
232 assert(SymbolId < Cache.size());
235 if (SymbolId == 0 || SymbolId >= Cache.size())
238 // Make sure to handle the case where we've inserted a placeholder symbol
239 // for types we don't yet suppport.
240 NativeRawSymbol *NRS = Cache[SymbolId].get();
244 return PDBSymbol::create(Session, *NRS);
247 NativeRawSymbol &SymbolCache::getNativeSymbolById(SymIndexId SymbolId) const {
248 return *Cache[SymbolId];
251 uint32_t SymbolCache::getNumCompilands() const {
255 return Dbi->modules().getModuleCount();
258 SymIndexId SymbolCache::getOrCreateGlobalSymbolByOffset(uint32_t Offset) {
259 auto Iter = GlobalOffsetToSymbolId.find(Offset);
260 if (Iter != GlobalOffsetToSymbolId.end())
263 SymbolStream &SS = cantFail(Session.getPDBFile().getPDBSymbolStream());
264 CVSymbol CVS = SS.readRecord(Offset);
266 switch (CVS.kind()) {
267 case SymbolKind::S_UDT: {
268 UDTSym US = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(CVS));
269 Id = createSymbol<NativeTypeTypedef>(std::move(US));
273 Id = createSymbolPlaceholder();
277 assert(GlobalOffsetToSymbolId.count(Offset) == 0);
278 GlobalOffsetToSymbolId[Offset] = Id;
284 std::unique_ptr<PDBSymbolCompiland>
285 SymbolCache::getOrCreateCompiland(uint32_t Index) {
289 if (Index >= Compilands.size())
292 if (Compilands[Index] == 0) {
293 const DbiModuleList &Modules = Dbi->modules();
295 createSymbol<NativeCompilandSymbol>(Modules.getModuleDescriptor(Index));
298 return Session.getConcreteSymbolById<PDBSymbolCompiland>(Compilands[Index]);