llvm/unittests/DebugInfo/PDB/PDBApiTest.cpp

   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