1 //===- llvm/unittest/DebugInfo/PDB/PDBApiTest.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 <unordered_map>
10 
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
13 #include "llvm/DebugInfo/PDB/IPDBInjectedSource.h"
14 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
15 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
16 #include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
17 #include "llvm/DebugInfo/PDB/IPDBSession.h"
18 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
19 #include "llvm/DebugInfo/PDB/IPDBTable.h"
20 
21 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
22 #include "llvm/DebugInfo/PDB/PDBSymbolAnnotation.h"
23 #include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
24 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
25 #include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
26 #include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
27 #include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
28 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
29 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
30 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
31 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
32 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
33 #include "llvm/DebugInfo/PDB/PDBSymbolLabel.h"
34 #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
35 #include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
36 #include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
37 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
38 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
39 #include "llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h"
40 #include "llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h"
41 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
42 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h"
43 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
44 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
45 #include "llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h"
46 #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
47 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
48 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
49 #include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"
50 #include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h"
51 #include "llvm/DebugInfo/PDB/PDBSymbolUnknown.h"
52 #include "llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h"
53 #include "llvm/DebugInfo/PDB/PDBTypes.h"
54 #include "gtest/gtest.h"
55 using namespace llvm;
56 using namespace llvm::pdb;
57 
58 namespace {
59 
60 #define MOCK_SYMBOL_ACCESSOR(Func)                                             \
61   decltype(std::declval<IPDBRawSymbol>().Func()) Func() const override {       \
62     typedef decltype(IPDBRawSymbol::Func()) ReturnType;                        \
63     return ReturnType();                                                       \
64   }
65 
66 class MockSession : public IPDBSession {
67   uint64_t getLoadAddress() const override { return 0; }
68   bool setLoadAddress(uint64_t Address) override { return false; }
69   std::unique_ptr<PDBSymbolExe> getGlobalScope() override { return nullptr; }
70   std::unique_ptr<PDBSymbol> getSymbolById(SymIndexId SymbolId) const override {
71     return nullptr;
72   }
73   std::unique_ptr<IPDBSourceFile>
74   getSourceFileById(uint32_t SymbolId) const override {
75     return nullptr;
76   }
77   bool addressForVA(uint64_t VA, uint32_t &Section,
78                     uint32_t &Offset) const override {
79     return false;
80   }
81   bool addressForRVA(uint32_t RVA, uint32_t &Section,
82                      uint32_t &Offset) const override {
83     return false;
84   }
85   std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
86                                                  PDB_SymType Type) override {
87     return nullptr;
88   }
89   std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
90                                              PDB_SymType Type) override {
91     return nullptr;
92   }
93   std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Sect,
94                                                     uint32_t Offset,
95                                                     PDB_SymType Type) override {
96     return nullptr;
97   }
98   std::unique_ptr<IPDBEnumLineNumbers>
99   findLineNumbers(const PDBSymbolCompiland &Compiland,
100                   const IPDBSourceFile &File) const override {
101     return nullptr;
102   }
103   std::unique_ptr<IPDBEnumLineNumbers>
104   findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override {
105     return nullptr;
106   }
107   std::unique_ptr<IPDBEnumLineNumbers>
108   findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override {
109     return nullptr;
110   }
111   std::unique_ptr<IPDBEnumLineNumbers>
112   findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
113                               uint32_t Length) const override {
114     return nullptr;
115   }
116   std::unique_ptr<IPDBEnumSourceFiles>
117   findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern,
118                   PDB_NameSearchFlags Flags) const override {
119     return nullptr;
120   }
121   std::unique_ptr<IPDBSourceFile>
122   findOneSourceFile(const PDBSymbolCompiland *Compiland,
123                     llvm::StringRef Pattern,
124                     PDB_NameSearchFlags Flags) const override {
125     return nullptr;
126   }
127   std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
128   findCompilandsForSourceFile(llvm::StringRef Pattern,
129                               PDB_NameSearchFlags Flags) const override {
130     return nullptr;
131   }
132   std::unique_ptr<PDBSymbolCompiland>
133   findOneCompilandForSourceFile(llvm::StringRef Pattern,
134                                 PDB_NameSearchFlags Flags) const override {
135     return nullptr;
136   }
137 
138   std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const override {
139     return nullptr;
140   }
141   std::unique_ptr<IPDBEnumSourceFiles> getSourceFilesForCompiland(
142       const PDBSymbolCompiland &Compiland) const override {
143     return nullptr;
144   }
145 
146   std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const override {
147     return nullptr;
148   }
149 
150   std::unique_ptr<IPDBEnumTables> getEnumTables() const override {
151     return nullptr;
152   }
153 
154   std::unique_ptr<IPDBEnumInjectedSources> getInjectedSources() const override {
155     return nullptr;
156   }
157 
158   std::unique_ptr<IPDBEnumSectionContribs> getSectionContribs() const override {
159     return nullptr;
160   }
161 
162   std::unique_ptr<IPDBEnumFrameData> getFrameData() const override {
163     return nullptr;
164   }
165 };
166 
167 class MockRawSymbol : public IPDBRawSymbol {
168 public:
169   MockRawSymbol(PDB_SymType SymType)
170       : Type(SymType) {}
171 
172   void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
173     PdbSymbolIdField RecurseIdFields) const override {}
174 
175   std::unique_ptr<IPDBEnumSymbols>
176   findChildren(PDB_SymType Type) const override {
177     return nullptr;
178   }
179   std::unique_ptr<IPDBEnumSymbols>
180   findChildren(PDB_SymType Type, StringRef Name,
181                PDB_NameSearchFlags Flags) const override {
182     return nullptr;
183   }
184   std::unique_ptr<IPDBEnumSymbols>
185   findChildrenByAddr(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
186                      uint32_t Section, uint32_t Offset) const override {
187     return nullptr;
188   }
189   std::unique_ptr<IPDBEnumSymbols>
190   findChildrenByVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
191                    uint64_t VA) const override {
192     return nullptr;
193   }
194   std::unique_ptr<IPDBEnumSymbols>
195   findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
196                     uint32_t RVA) const override {
197     return nullptr;
198   }
199   std::unique_ptr<IPDBEnumSymbols>
200   findInlineFramesByAddr(uint32_t Section, uint32_t Offset) const override {
201     return nullptr;
202   }
203   std::unique_ptr<IPDBEnumSymbols>
204   findInlineFramesByRVA(uint32_t RVA) const override {
205     return nullptr;
206   }
207   std::unique_ptr<IPDBEnumSymbols>
208   findInlineFramesByVA(uint64_t VA) const override {
209     return nullptr;
210   }
211   std::unique_ptr<IPDBEnumLineNumbers> findInlineeLines() const override {
212     return nullptr;
213   }
214   std::unique_ptr<IPDBEnumLineNumbers>
215   findInlineeLinesByAddr(uint32_t Section, uint32_t Offset,
216                          uint32_t Length) const override {
217     return nullptr;
218   }
219   std::unique_ptr<IPDBEnumLineNumbers>
220   findInlineeLinesByRVA(uint32_t RVA, uint32_t Length) const override {
221     return nullptr;
222   }
223   std::unique_ptr<IPDBEnumLineNumbers>
224   findInlineeLinesByVA(uint64_t VA, uint32_t Length) const override {
225     return nullptr;
226   }
227 
228   void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const override {}
229   void getFrontEndVersion(VersionInfo &Version) const override {}
230   void getBackEndVersion(VersionInfo &Version) const override {}
231 
232   PDB_SymType getSymTag() const override { return Type; }
233 
234   std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override {
235     return {};
236   }
237 
238   std::unique_ptr<IPDBLineNumber> getSrcLineOnTypeDefn() const override {
239     return nullptr;
240   }
241 
242   MOCK_SYMBOL_ACCESSOR(getAccess)
243   MOCK_SYMBOL_ACCESSOR(getAddressOffset)
244   MOCK_SYMBOL_ACCESSOR(getAddressSection)
245   MOCK_SYMBOL_ACCESSOR(getAge)
246   MOCK_SYMBOL_ACCESSOR(getArrayIndexTypeId)
247   MOCK_SYMBOL_ACCESSOR(getBaseDataOffset)
248   MOCK_SYMBOL_ACCESSOR(getBaseDataSlot)
249   MOCK_SYMBOL_ACCESSOR(getBaseSymbolId)
250   MOCK_SYMBOL_ACCESSOR(getBuiltinType)
251   MOCK_SYMBOL_ACCESSOR(getBitPosition)
252   MOCK_SYMBOL_ACCESSOR(getCallingConvention)
253   MOCK_SYMBOL_ACCESSOR(getClassParentId)
254   MOCK_SYMBOL_ACCESSOR(getCompilerName)
255   MOCK_SYMBOL_ACCESSOR(getCount)
256   MOCK_SYMBOL_ACCESSOR(getCountLiveRanges)
257   MOCK_SYMBOL_ACCESSOR(getLanguage)
258   MOCK_SYMBOL_ACCESSOR(getLexicalParentId)
259   MOCK_SYMBOL_ACCESSOR(getLibraryName)
260   MOCK_SYMBOL_ACCESSOR(getLiveRangeStartAddressOffset)
261   MOCK_SYMBOL_ACCESSOR(getLiveRangeStartAddressSection)
262   MOCK_SYMBOL_ACCESSOR(getLiveRangeStartRelativeVirtualAddress)
263   MOCK_SYMBOL_ACCESSOR(getLocalBasePointerRegisterId)
264   MOCK_SYMBOL_ACCESSOR(getLowerBoundId)
265   MOCK_SYMBOL_ACCESSOR(getMemorySpaceKind)
266   MOCK_SYMBOL_ACCESSOR(getName)
267   MOCK_SYMBOL_ACCESSOR(getNumberOfAcceleratorPointerTags)
268   MOCK_SYMBOL_ACCESSOR(getNumberOfColumns)
269   MOCK_SYMBOL_ACCESSOR(getNumberOfModifiers)
270   MOCK_SYMBOL_ACCESSOR(getNumberOfRegisterIndices)
271   MOCK_SYMBOL_ACCESSOR(getNumberOfRows)
272   MOCK_SYMBOL_ACCESSOR(getObjectFileName)
273   MOCK_SYMBOL_ACCESSOR(getOemId)
274   MOCK_SYMBOL_ACCESSOR(getOemSymbolId)
275   MOCK_SYMBOL_ACCESSOR(getOffsetInUdt)
276   MOCK_SYMBOL_ACCESSOR(getPlatform)
277   MOCK_SYMBOL_ACCESSOR(getRank)
278   MOCK_SYMBOL_ACCESSOR(getRegisterId)
279   MOCK_SYMBOL_ACCESSOR(getRegisterType)
280   MOCK_SYMBOL_ACCESSOR(getRelativeVirtualAddress)
281   MOCK_SYMBOL_ACCESSOR(getSamplerSlot)
282   MOCK_SYMBOL_ACCESSOR(getSignature)
283   MOCK_SYMBOL_ACCESSOR(getSizeInUdt)
284   MOCK_SYMBOL_ACCESSOR(getSlot)
285   MOCK_SYMBOL_ACCESSOR(getSourceFileName)
286   MOCK_SYMBOL_ACCESSOR(getStride)
287   MOCK_SYMBOL_ACCESSOR(getSubTypeId)
288   MOCK_SYMBOL_ACCESSOR(getSymbolsFileName)
289   MOCK_SYMBOL_ACCESSOR(getSymIndexId)
290   MOCK_SYMBOL_ACCESSOR(getTargetOffset)
291   MOCK_SYMBOL_ACCESSOR(getTargetRelativeVirtualAddress)
292   MOCK_SYMBOL_ACCESSOR(getTargetVirtualAddress)
293   MOCK_SYMBOL_ACCESSOR(getTargetSection)
294   MOCK_SYMBOL_ACCESSOR(getTextureSlot)
295   MOCK_SYMBOL_ACCESSOR(getTimeStamp)
296   MOCK_SYMBOL_ACCESSOR(getToken)
297   MOCK_SYMBOL_ACCESSOR(getTypeId)
298   MOCK_SYMBOL_ACCESSOR(getUavSlot)
299   MOCK_SYMBOL_ACCESSOR(getUndecoratedName)
300   MOCK_SYMBOL_ACCESSOR(getUnmodifiedTypeId)
301   MOCK_SYMBOL_ACCESSOR(getUpperBoundId)
302   MOCK_SYMBOL_ACCESSOR(getVirtualBaseDispIndex)
303   MOCK_SYMBOL_ACCESSOR(getVirtualBaseOffset)
304   MOCK_SYMBOL_ACCESSOR(getVirtualTableShapeId)
305   MOCK_SYMBOL_ACCESSOR(getDataKind)
306   MOCK_SYMBOL_ACCESSOR(getGuid)
307   MOCK_SYMBOL_ACCESSOR(getOffset)
308   MOCK_SYMBOL_ACCESSOR(getThisAdjust)
309   MOCK_SYMBOL_ACCESSOR(getVirtualBasePointerOffset)
310   MOCK_SYMBOL_ACCESSOR(getLocationType)
311   MOCK_SYMBOL_ACCESSOR(getMachineType)
312   MOCK_SYMBOL_ACCESSOR(getThunkOrdinal)
313   MOCK_SYMBOL_ACCESSOR(getLength)
314   MOCK_SYMBOL_ACCESSOR(getVirtualBaseTableType)
315   MOCK_SYMBOL_ACCESSOR(getLiveRangeLength)
316   MOCK_SYMBOL_ACCESSOR(getVirtualAddress)
317   MOCK_SYMBOL_ACCESSOR(getUdtKind)
318   MOCK_SYMBOL_ACCESSOR(hasConstructor)
319   MOCK_SYMBOL_ACCESSOR(hasCustomCallingConvention)
320   MOCK_SYMBOL_ACCESSOR(hasFarReturn)
321   MOCK_SYMBOL_ACCESSOR(isCode)
322   MOCK_SYMBOL_ACCESSOR(isCompilerGenerated)
323   MOCK_SYMBOL_ACCESSOR(isConstType)
324   MOCK_SYMBOL_ACCESSOR(isEditAndContinueEnabled)
325   MOCK_SYMBOL_ACCESSOR(isFunction)
326   MOCK_SYMBOL_ACCESSOR(getAddressTaken)
327   MOCK_SYMBOL_ACCESSOR(getNoStackOrdering)
328   MOCK_SYMBOL_ACCESSOR(hasAlloca)
329   MOCK_SYMBOL_ACCESSOR(hasAssignmentOperator)
330   MOCK_SYMBOL_ACCESSOR(hasCTypes)
331   MOCK_SYMBOL_ACCESSOR(hasCastOperator)
332   MOCK_SYMBOL_ACCESSOR(hasDebugInfo)
333   MOCK_SYMBOL_ACCESSOR(hasEH)
334   MOCK_SYMBOL_ACCESSOR(hasEHa)
335   MOCK_SYMBOL_ACCESSOR(hasFramePointer)
336   MOCK_SYMBOL_ACCESSOR(hasInlAsm)
337   MOCK_SYMBOL_ACCESSOR(hasInlineAttribute)
338   MOCK_SYMBOL_ACCESSOR(hasInterruptReturn)
339   MOCK_SYMBOL_ACCESSOR(hasLongJump)
340   MOCK_SYMBOL_ACCESSOR(hasManagedCode)
341   MOCK_SYMBOL_ACCESSOR(hasNestedTypes)
342   MOCK_SYMBOL_ACCESSOR(hasNoInlineAttribute)
343   MOCK_SYMBOL_ACCESSOR(hasNoReturnAttribute)
344   MOCK_SYMBOL_ACCESSOR(hasOptimizedCodeDebugInfo)
345   MOCK_SYMBOL_ACCESSOR(hasOverloadedOperator)
346   MOCK_SYMBOL_ACCESSOR(hasSEH)
347   MOCK_SYMBOL_ACCESSOR(hasSecurityChecks)
348   MOCK_SYMBOL_ACCESSOR(hasSetJump)
349   MOCK_SYMBOL_ACCESSOR(hasStrictGSCheck)
350   MOCK_SYMBOL_ACCESSOR(isAcceleratorGroupSharedLocal)
351   MOCK_SYMBOL_ACCESSOR(isAcceleratorPointerTagLiveRange)
352   MOCK_SYMBOL_ACCESSOR(isAcceleratorStubFunction)
353   MOCK_SYMBOL_ACCESSOR(isAggregated)
354   MOCK_SYMBOL_ACCESSOR(isIntroVirtualFunction)
355   MOCK_SYMBOL_ACCESSOR(isCVTCIL)
356   MOCK_SYMBOL_ACCESSOR(isConstructorVirtualBase)
357   MOCK_SYMBOL_ACCESSOR(isCxxReturnUdt)
358   MOCK_SYMBOL_ACCESSOR(isDataAligned)
359   MOCK_SYMBOL_ACCESSOR(isHLSLData)
360   MOCK_SYMBOL_ACCESSOR(isHotpatchable)
361   MOCK_SYMBOL_ACCESSOR(isIndirectVirtualBaseClass)
362   MOCK_SYMBOL_ACCESSOR(isInterfaceUdt)
363   MOCK_SYMBOL_ACCESSOR(isIntrinsic)
364   MOCK_SYMBOL_ACCESSOR(isLTCG)
365   MOCK_SYMBOL_ACCESSOR(isLocationControlFlowDependent)
366   MOCK_SYMBOL_ACCESSOR(isMSILNetmodule)
367   MOCK_SYMBOL_ACCESSOR(isMatrixRowMajor)
368   MOCK_SYMBOL_ACCESSOR(isManagedCode)
369   MOCK_SYMBOL_ACCESSOR(isMSILCode)
370   MOCK_SYMBOL_ACCESSOR(isMultipleInheritance)
371   MOCK_SYMBOL_ACCESSOR(isNaked)
372   MOCK_SYMBOL_ACCESSOR(isNested)
373   MOCK_SYMBOL_ACCESSOR(isOptimizedAway)
374   MOCK_SYMBOL_ACCESSOR(isPacked)
375   MOCK_SYMBOL_ACCESSOR(isPointerBasedOnSymbolValue)
376   MOCK_SYMBOL_ACCESSOR(isPointerToDataMember)
377   MOCK_SYMBOL_ACCESSOR(isPointerToMemberFunction)
378   MOCK_SYMBOL_ACCESSOR(isPureVirtual)
379   MOCK_SYMBOL_ACCESSOR(isRValueReference)
380   MOCK_SYMBOL_ACCESSOR(isRefUdt)
381   MOCK_SYMBOL_ACCESSOR(isReference)
382   MOCK_SYMBOL_ACCESSOR(isRestrictedType)
383   MOCK_SYMBOL_ACCESSOR(isReturnValue)
384   MOCK_SYMBOL_ACCESSOR(isSafeBuffers)
385   MOCK_SYMBOL_ACCESSOR(isScoped)
386   MOCK_SYMBOL_ACCESSOR(isSdl)
387   MOCK_SYMBOL_ACCESSOR(isSingleInheritance)
388   MOCK_SYMBOL_ACCESSOR(isSplitted)
389   MOCK_SYMBOL_ACCESSOR(isStatic)
390   MOCK_SYMBOL_ACCESSOR(hasPrivateSymbols)
391   MOCK_SYMBOL_ACCESSOR(isUnalignedType)
392   MOCK_SYMBOL_ACCESSOR(isUnreached)
393   MOCK_SYMBOL_ACCESSOR(isValueUdt)
394   MOCK_SYMBOL_ACCESSOR(isVirtual)
395   MOCK_SYMBOL_ACCESSOR(isVirtualBaseClass)
396   MOCK_SYMBOL_ACCESSOR(isVirtualInheritance)
397   MOCK_SYMBOL_ACCESSOR(isVolatileType)
398   MOCK_SYMBOL_ACCESSOR(getValue)
399   MOCK_SYMBOL_ACCESSOR(wasInlined)
400   MOCK_SYMBOL_ACCESSOR(getUnused)
401 
402 private:
403   PDB_SymType Type;
404 };
405 
406 class PDBApiTest : public testing::Test {
407 public:
408   std::unordered_map<PDB_SymType, std::unique_ptr<PDBSymbol>> SymbolMap;
409 
410   void SetUp() override {
411     Session.reset(new MockSession());
412 
413     InsertItemWithTag(PDB_SymType::None);
414     InsertItemWithTag(PDB_SymType::Exe);
415     InsertItemWithTag(PDB_SymType::Compiland);
416     InsertItemWithTag(PDB_SymType::CompilandDetails);
417     InsertItemWithTag(PDB_SymType::CompilandEnv);
418     InsertItemWithTag(PDB_SymType::Function);
419     InsertItemWithTag(PDB_SymType::Block);
420     InsertItemWithTag(PDB_SymType::Data);
421     InsertItemWithTag(PDB_SymType::Annotation);
422     InsertItemWithTag(PDB_SymType::Label);
423     InsertItemWithTag(PDB_SymType::PublicSymbol);
424     InsertItemWithTag(PDB_SymType::UDT);
425     InsertItemWithTag(PDB_SymType::Enum);
426     InsertItemWithTag(PDB_SymType::FunctionSig);
427     InsertItemWithTag(PDB_SymType::PointerType);
428     InsertItemWithTag(PDB_SymType::ArrayType);
429     InsertItemWithTag(PDB_SymType::BuiltinType);
430     InsertItemWithTag(PDB_SymType::Typedef);
431     InsertItemWithTag(PDB_SymType::BaseClass);
432     InsertItemWithTag(PDB_SymType::Friend);
433     InsertItemWithTag(PDB_SymType::FunctionArg);
434     InsertItemWithTag(PDB_SymType::FuncDebugStart);
435     InsertItemWithTag(PDB_SymType::FuncDebugEnd);
436     InsertItemWithTag(PDB_SymType::UsingNamespace);
437     InsertItemWithTag(PDB_SymType::VTableShape);
438     InsertItemWithTag(PDB_SymType::VTable);
439     InsertItemWithTag(PDB_SymType::Custom);
440     InsertItemWithTag(PDB_SymType::Thunk);
441     InsertItemWithTag(PDB_SymType::CustomType);
442     InsertItemWithTag(PDB_SymType::ManagedType);
443     InsertItemWithTag(PDB_SymType::Dimension);
444     InsertItemWithTag(PDB_SymType::Max);
445   }
446 
447   template <class ExpectedType> void VerifyDyncast(PDB_SymType Tag) {
448     for (auto item = SymbolMap.begin(); item != SymbolMap.end(); ++item) {
449       EXPECT_EQ(item->first == Tag, llvm::isa<ExpectedType>(*item->second));
450     }
451   }
452 
453   void VerifyUnknownDyncasts() {
454     for (auto item = SymbolMap.begin(); item != SymbolMap.end(); ++item) {
455       bool should_match = false;
456       if (item->first == PDB_SymType::None || item->first >= PDB_SymType::Max)
457         should_match = true;
458 
459       EXPECT_EQ(should_match, llvm::isa<PDBSymbolUnknown>(*item->second));
460     }
461   }
462 
463 private:
464   std::unique_ptr<IPDBSession> Session;
465 
466   void InsertItemWithTag(PDB_SymType Tag) {
467     auto RawSymbol = std::make_unique<MockRawSymbol>(Tag);
468     auto Symbol = PDBSymbol::create(*Session, std::move(RawSymbol));
469     SymbolMap.insert(std::make_pair(Tag, std::move(Symbol)));
470   }
471 };
472 
473 TEST_F(PDBApiTest, Dyncast) {
474 
475   // Most of the types have a one-to-one mapping between Tag and concrete type.
476   VerifyDyncast<PDBSymbolExe>(PDB_SymType::Exe);
477   VerifyDyncast<PDBSymbolCompiland>(PDB_SymType::Compiland);
478   VerifyDyncast<PDBSymbolCompilandDetails>(PDB_SymType::CompilandDetails);
479   VerifyDyncast<PDBSymbolCompilandEnv>(PDB_SymType::CompilandEnv);
480   VerifyDyncast<PDBSymbolFunc>(PDB_SymType::Function);
481   VerifyDyncast<PDBSymbolBlock>(PDB_SymType::Block);
482   VerifyDyncast<PDBSymbolData>(PDB_SymType::Data);
483   VerifyDyncast<PDBSymbolAnnotation>(PDB_SymType::Annotation);
484   VerifyDyncast<PDBSymbolLabel>(PDB_SymType::Label);
485   VerifyDyncast<PDBSymbolPublicSymbol>(PDB_SymType::PublicSymbol);
486   VerifyDyncast<PDBSymbolTypeUDT>(PDB_SymType::UDT);
487   VerifyDyncast<PDBSymbolTypeEnum>(PDB_SymType::Enum);
488   VerifyDyncast<PDBSymbolTypeFunctionSig>(PDB_SymType::FunctionSig);
489   VerifyDyncast<PDBSymbolTypePointer>(PDB_SymType::PointerType);
490   VerifyDyncast<PDBSymbolTypeArray>(PDB_SymType::ArrayType);
491   VerifyDyncast<PDBSymbolTypeBuiltin>(PDB_SymType::BuiltinType);
492   VerifyDyncast<PDBSymbolTypeTypedef>(PDB_SymType::Typedef);
493   VerifyDyncast<PDBSymbolTypeBaseClass>(PDB_SymType::BaseClass);
494   VerifyDyncast<PDBSymbolTypeFriend>(PDB_SymType::Friend);
495   VerifyDyncast<PDBSymbolTypeFunctionArg>(PDB_SymType::FunctionArg);
496   VerifyDyncast<PDBSymbolFuncDebugStart>(PDB_SymType::FuncDebugStart);
497   VerifyDyncast<PDBSymbolFuncDebugEnd>(PDB_SymType::FuncDebugEnd);
498   VerifyDyncast<PDBSymbolUsingNamespace>(PDB_SymType::UsingNamespace);
499   VerifyDyncast<PDBSymbolTypeVTableShape>(PDB_SymType::VTableShape);
500   VerifyDyncast<PDBSymbolTypeVTable>(PDB_SymType::VTable);
501   VerifyDyncast<PDBSymbolCustom>(PDB_SymType::Custom);
502   VerifyDyncast<PDBSymbolThunk>(PDB_SymType::Thunk);
503   VerifyDyncast<PDBSymbolTypeCustom>(PDB_SymType::CustomType);
504   VerifyDyncast<PDBSymbolTypeManaged>(PDB_SymType::ManagedType);
505   VerifyDyncast<PDBSymbolTypeDimension>(PDB_SymType::Dimension);
506 
507   VerifyUnknownDyncasts();
508 }
509 } // end anonymous namespace
510