RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 03:33:20 +01:00
Code Issues Projects Releases Wiki Activity
70207b468c
llvm-mirror/unittests/DebugInfo/PDB/PDBApiTest.cpp
Amy Huang 48fecb2d18 [NativeSession] Implement NativeSession::findSymbolByAddress. 
Summary: This implements searching for function symbols and public symbols by address.

More specifically,
-Implements NativeSession::findSymbolByAddress for function symbols and
public symbols. I think data symbols are also searched for, but isn't
implemented in this patch.
-Adds classes for NativeFunctionSymbol and NativePublicSymbol
-Adds a '-use-native-pdb-reader' option to llvm-symbolizer, for testing
purposes.

Reviewers: rnk, amccarth, labath

Subscribers: mgorny, hiraditya, MaskRay, rupprecht, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D79269
2020-05-13 09:39:25 -07:00

510 lines
20 KiB
C++
Raw Blame History

//===- llvm/unittest/DebugInfo/PDB/PDBApiTest.cpp -------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <unordered_map>
#include "llvm/ADT/STLExtras.h"
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBInjectedSource.h"
#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
#include "llvm/DebugInfo/PDB/IPDBTable.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolAnnotation.h"
#include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
#include "llvm/DebugInfo/PDB/PDBSymbolLabel.h"
#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h"
#include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUnknown.h"
#include "llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
#include "gtest/gtest.h"
using namespace llvm;
using namespace llvm::pdb;
namespace {
#define MOCK_SYMBOL_ACCESSOR(Func) \
decltype(std::declval<IPDBRawSymbol>().Func()) Func() const override { \
typedef decltype(IPDBRawSymbol::Func()) ReturnType; \
return ReturnType(); \
}
class MockSession : public IPDBSession {
uint64_t getLoadAddress() const override { return 0; }
bool setLoadAddress(uint64_t Address) override { return false; }
std::unique_ptr<PDBSymbolExe> getGlobalScope() override { return nullptr; }
std::unique_ptr<PDBSymbol> getSymbolById(SymIndexId SymbolId) const override {
return nullptr;
}
std::unique_ptr<IPDBSourceFile>
getSourceFileById(uint32_t SymbolId) const override {
return nullptr;
}
bool addressForVA(uint64_t VA, uint32_t &Section,
uint32_t &Offset) const override {
return false;
}
bool addressForRVA(uint32_t RVA, uint32_t &Section,
uint32_t &Offset) const override {
return false;
}
std::unique_ptr<PDBSymbol> findSymbolByAddress(uint64_t Address,
PDB_SymType Type) override {
return nullptr;
}
std::unique_ptr<PDBSymbol> findSymbolByRVA(uint32_t RVA,
PDB_SymType Type) override {
return nullptr;
}
std::unique_ptr<PDBSymbol> findSymbolBySectOffset(uint32_t Sect,
uint32_t Offset,
PDB_SymType Type) override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbers(const PDBSymbolCompiland &Compiland,
const IPDBSourceFile &File) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersByAddress(uint64_t Address, uint32_t Length) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
uint32_t Length) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSourceFiles>
findSourceFiles(const PDBSymbolCompiland *Compiland, llvm::StringRef Pattern,
PDB_NameSearchFlags Flags) const override {
return nullptr;
}
std::unique_ptr<IPDBSourceFile>
findOneSourceFile(const PDBSymbolCompiland *Compiland,
llvm::StringRef Pattern,
PDB_NameSearchFlags Flags) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
findCompilandsForSourceFile(llvm::StringRef Pattern,
PDB_NameSearchFlags Flags) const override {
return nullptr;
}
std::unique_ptr<PDBSymbolCompiland>
findOneCompilandForSourceFile(llvm::StringRef Pattern,
PDB_NameSearchFlags Flags) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSourceFiles> getAllSourceFiles() const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSourceFiles> getSourceFilesForCompiland(
const PDBSymbolCompiland &Compiland) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const override {
return nullptr;
}
std::unique_ptr<IPDBEnumTables> getEnumTables() const override {
return nullptr;
}
std::unique_ptr<IPDBEnumInjectedSources> getInjectedSources() const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSectionContribs> getSectionContribs() const override {
return nullptr;
}
std::unique_ptr<IPDBEnumFrameData> getFrameData() const override {
return nullptr;
}
};
class MockRawSymbol : public IPDBRawSymbol {
public:
MockRawSymbol(PDB_SymType SymType)
: Type(SymType) {}
void dump(raw_ostream &OS, int Indent, PdbSymbolIdField ShowIdFields,
PdbSymbolIdField RecurseIdFields) const override {}
std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findChildrenByAddr(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint32_t Section, uint32_t Offset) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findChildrenByVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint64_t VA) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint32_t RVA) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByAddr(uint32_t Section, uint32_t Offset) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByRVA(uint32_t RVA) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByVA(uint64_t VA) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers> findInlineeLines() const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findInlineeLinesByAddr(uint32_t Section, uint32_t Offset,
uint32_t Length) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findInlineeLinesByRVA(uint32_t RVA, uint32_t Length) const override {
return nullptr;
}
std::unique_ptr<IPDBEnumLineNumbers>
findInlineeLinesByVA(uint64_t VA, uint32_t Length) const override {
return nullptr;
}
void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const override {}
void getFrontEndVersion(VersionInfo &Version) const override {}
void getBackEndVersion(VersionInfo &Version) const override {}
PDB_SymType getSymTag() const override { return Type; }
std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override {
return {};
}
std::unique_ptr<IPDBLineNumber> getSrcLineOnTypeDefn() const override {
return nullptr;
}
MOCK_SYMBOL_ACCESSOR(getAccess)
MOCK_SYMBOL_ACCESSOR(getAddressOffset)
MOCK_SYMBOL_ACCESSOR(getAddressSection)
MOCK_SYMBOL_ACCESSOR(getAge)
MOCK_SYMBOL_ACCESSOR(getArrayIndexTypeId)
MOCK_SYMBOL_ACCESSOR(getBaseDataOffset)
MOCK_SYMBOL_ACCESSOR(getBaseDataSlot)
MOCK_SYMBOL_ACCESSOR(getBaseSymbolId)
MOCK_SYMBOL_ACCESSOR(getBuiltinType)
MOCK_SYMBOL_ACCESSOR(getBitPosition)
MOCK_SYMBOL_ACCESSOR(getCallingConvention)
MOCK_SYMBOL_ACCESSOR(getClassParentId)
MOCK_SYMBOL_ACCESSOR(getCompilerName)
MOCK_SYMBOL_ACCESSOR(getCount)
MOCK_SYMBOL_ACCESSOR(getCountLiveRanges)
MOCK_SYMBOL_ACCESSOR(getLanguage)
MOCK_SYMBOL_ACCESSOR(getLexicalParentId)
MOCK_SYMBOL_ACCESSOR(getLibraryName)
MOCK_SYMBOL_ACCESSOR(getLiveRangeStartAddressOffset)
MOCK_SYMBOL_ACCESSOR(getLiveRangeStartAddressSection)
MOCK_SYMBOL_ACCESSOR(getLiveRangeStartRelativeVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getLocalBasePointerRegisterId)
MOCK_SYMBOL_ACCESSOR(getLowerBoundId)
MOCK_SYMBOL_ACCESSOR(getMemorySpaceKind)
MOCK_SYMBOL_ACCESSOR(getName)
MOCK_SYMBOL_ACCESSOR(getNumberOfAcceleratorPointerTags)
MOCK_SYMBOL_ACCESSOR(getNumberOfColumns)
MOCK_SYMBOL_ACCESSOR(getNumberOfModifiers)
MOCK_SYMBOL_ACCESSOR(getNumberOfRegisterIndices)
MOCK_SYMBOL_ACCESSOR(getNumberOfRows)
MOCK_SYMBOL_ACCESSOR(getObjectFileName)
MOCK_SYMBOL_ACCESSOR(getOemId)
MOCK_SYMBOL_ACCESSOR(getOemSymbolId)
MOCK_SYMBOL_ACCESSOR(getOffsetInUdt)
MOCK_SYMBOL_ACCESSOR(getPlatform)
MOCK_SYMBOL_ACCESSOR(getRank)
MOCK_SYMBOL_ACCESSOR(getRegisterId)
MOCK_SYMBOL_ACCESSOR(getRegisterType)
MOCK_SYMBOL_ACCESSOR(getRelativeVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getSamplerSlot)
MOCK_SYMBOL_ACCESSOR(getSignature)
MOCK_SYMBOL_ACCESSOR(getSizeInUdt)
MOCK_SYMBOL_ACCESSOR(getSlot)
MOCK_SYMBOL_ACCESSOR(getSourceFileName)
MOCK_SYMBOL_ACCESSOR(getStride)
MOCK_SYMBOL_ACCESSOR(getSubTypeId)
MOCK_SYMBOL_ACCESSOR(getSymbolsFileName)
MOCK_SYMBOL_ACCESSOR(getSymIndexId)
MOCK_SYMBOL_ACCESSOR(getTargetOffset)
MOCK_SYMBOL_ACCESSOR(getTargetRelativeVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getTargetVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getTargetSection)
MOCK_SYMBOL_ACCESSOR(getTextureSlot)
MOCK_SYMBOL_ACCESSOR(getTimeStamp)
MOCK_SYMBOL_ACCESSOR(getToken)
MOCK_SYMBOL_ACCESSOR(getTypeId)
MOCK_SYMBOL_ACCESSOR(getUavSlot)
MOCK_SYMBOL_ACCESSOR(getUndecoratedName)
MOCK_SYMBOL_ACCESSOR(getUnmodifiedTypeId)
MOCK_SYMBOL_ACCESSOR(getUpperBoundId)
MOCK_SYMBOL_ACCESSOR(getVirtualBaseDispIndex)
MOCK_SYMBOL_ACCESSOR(getVirtualBaseOffset)
MOCK_SYMBOL_ACCESSOR(getVirtualTableShapeId)
MOCK_SYMBOL_ACCESSOR(getDataKind)
MOCK_SYMBOL_ACCESSOR(getGuid)
MOCK_SYMBOL_ACCESSOR(getOffset)
MOCK_SYMBOL_ACCESSOR(getThisAdjust)
MOCK_SYMBOL_ACCESSOR(getVirtualBasePointerOffset)
MOCK_SYMBOL_ACCESSOR(getLocationType)
MOCK_SYMBOL_ACCESSOR(getMachineType)
MOCK_SYMBOL_ACCESSOR(getThunkOrdinal)
MOCK_SYMBOL_ACCESSOR(getLength)
MOCK_SYMBOL_ACCESSOR(getVirtualBaseTableType)
MOCK_SYMBOL_ACCESSOR(getLiveRangeLength)
MOCK_SYMBOL_ACCESSOR(getVirtualAddress)
MOCK_SYMBOL_ACCESSOR(getUdtKind)
MOCK_SYMBOL_ACCESSOR(hasConstructor)
MOCK_SYMBOL_ACCESSOR(hasCustomCallingConvention)
MOCK_SYMBOL_ACCESSOR(hasFarReturn)
MOCK_SYMBOL_ACCESSOR(isCode)
MOCK_SYMBOL_ACCESSOR(isCompilerGenerated)
MOCK_SYMBOL_ACCESSOR(isConstType)
MOCK_SYMBOL_ACCESSOR(isEditAndContinueEnabled)
MOCK_SYMBOL_ACCESSOR(isFunction)
MOCK_SYMBOL_ACCESSOR(getAddressTaken)
MOCK_SYMBOL_ACCESSOR(getNoStackOrdering)
MOCK_SYMBOL_ACCESSOR(hasAlloca)
MOCK_SYMBOL_ACCESSOR(hasAssignmentOperator)
MOCK_SYMBOL_ACCESSOR(hasCTypes)
MOCK_SYMBOL_ACCESSOR(hasCastOperator)
MOCK_SYMBOL_ACCESSOR(hasDebugInfo)
MOCK_SYMBOL_ACCESSOR(hasEH)
MOCK_SYMBOL_ACCESSOR(hasEHa)
MOCK_SYMBOL_ACCESSOR(hasFramePointer)
MOCK_SYMBOL_ACCESSOR(hasInlAsm)
MOCK_SYMBOL_ACCESSOR(hasInlineAttribute)
MOCK_SYMBOL_ACCESSOR(hasInterruptReturn)
MOCK_SYMBOL_ACCESSOR(hasLongJump)
MOCK_SYMBOL_ACCESSOR(hasManagedCode)
MOCK_SYMBOL_ACCESSOR(hasNestedTypes)
MOCK_SYMBOL_ACCESSOR(hasNoInlineAttribute)
MOCK_SYMBOL_ACCESSOR(hasNoReturnAttribute)
MOCK_SYMBOL_ACCESSOR(hasOptimizedCodeDebugInfo)
MOCK_SYMBOL_ACCESSOR(hasOverloadedOperator)
MOCK_SYMBOL_ACCESSOR(hasSEH)
MOCK_SYMBOL_ACCESSOR(hasSecurityChecks)
MOCK_SYMBOL_ACCESSOR(hasSetJump)
MOCK_SYMBOL_ACCESSOR(hasStrictGSCheck)
MOCK_SYMBOL_ACCESSOR(isAcceleratorGroupSharedLocal)
MOCK_SYMBOL_ACCESSOR(isAcceleratorPointerTagLiveRange)
MOCK_SYMBOL_ACCESSOR(isAcceleratorStubFunction)
MOCK_SYMBOL_ACCESSOR(isAggregated)
MOCK_SYMBOL_ACCESSOR(isIntroVirtualFunction)
MOCK_SYMBOL_ACCESSOR(isCVTCIL)
MOCK_SYMBOL_ACCESSOR(isConstructorVirtualBase)
MOCK_SYMBOL_ACCESSOR(isCxxReturnUdt)
MOCK_SYMBOL_ACCESSOR(isDataAligned)
MOCK_SYMBOL_ACCESSOR(isHLSLData)
MOCK_SYMBOL_ACCESSOR(isHotpatchable)
MOCK_SYMBOL_ACCESSOR(isIndirectVirtualBaseClass)
MOCK_SYMBOL_ACCESSOR(isInterfaceUdt)
MOCK_SYMBOL_ACCESSOR(isIntrinsic)
MOCK_SYMBOL_ACCESSOR(isLTCG)
MOCK_SYMBOL_ACCESSOR(isLocationControlFlowDependent)
MOCK_SYMBOL_ACCESSOR(isMSILNetmodule)
MOCK_SYMBOL_ACCESSOR(isMatrixRowMajor)
MOCK_SYMBOL_ACCESSOR(isManagedCode)
MOCK_SYMBOL_ACCESSOR(isMSILCode)
MOCK_SYMBOL_ACCESSOR(isMultipleInheritance)
MOCK_SYMBOL_ACCESSOR(isNaked)
MOCK_SYMBOL_ACCESSOR(isNested)
MOCK_SYMBOL_ACCESSOR(isOptimizedAway)
MOCK_SYMBOL_ACCESSOR(isPacked)
MOCK_SYMBOL_ACCESSOR(isPointerBasedOnSymbolValue)
MOCK_SYMBOL_ACCESSOR(isPointerToDataMember)
MOCK_SYMBOL_ACCESSOR(isPointerToMemberFunction)
MOCK_SYMBOL_ACCESSOR(isPureVirtual)
MOCK_SYMBOL_ACCESSOR(isRValueReference)
MOCK_SYMBOL_ACCESSOR(isRefUdt)
MOCK_SYMBOL_ACCESSOR(isReference)
MOCK_SYMBOL_ACCESSOR(isRestrictedType)
MOCK_SYMBOL_ACCESSOR(isReturnValue)
MOCK_SYMBOL_ACCESSOR(isSafeBuffers)
MOCK_SYMBOL_ACCESSOR(isScoped)
MOCK_SYMBOL_ACCESSOR(isSdl)
MOCK_SYMBOL_ACCESSOR(isSingleInheritance)
MOCK_SYMBOL_ACCESSOR(isSplitted)
MOCK_SYMBOL_ACCESSOR(isStatic)
MOCK_SYMBOL_ACCESSOR(hasPrivateSymbols)
MOCK_SYMBOL_ACCESSOR(isUnalignedType)
MOCK_SYMBOL_ACCESSOR(isUnreached)
MOCK_SYMBOL_ACCESSOR(isValueUdt)
MOCK_SYMBOL_ACCESSOR(isVirtual)
MOCK_SYMBOL_ACCESSOR(isVirtualBaseClass)
MOCK_SYMBOL_ACCESSOR(isVirtualInheritance)
MOCK_SYMBOL_ACCESSOR(isVolatileType)
MOCK_SYMBOL_ACCESSOR(getValue)
MOCK_SYMBOL_ACCESSOR(wasInlined)
MOCK_SYMBOL_ACCESSOR(getUnused)
private:
PDB_SymType Type;
};
class PDBApiTest : public testing::Test {
public:
std::unordered_map<PDB_SymType, std::unique_ptr<PDBSymbol>> SymbolMap;
void SetUp() override {
Session.reset(new MockSession());
InsertItemWithTag(PDB_SymType::None);
InsertItemWithTag(PDB_SymType::Exe);
InsertItemWithTag(PDB_SymType::Compiland);
InsertItemWithTag(PDB_SymType::CompilandDetails);
InsertItemWithTag(PDB_SymType::CompilandEnv);
InsertItemWithTag(PDB_SymType::Function);
InsertItemWithTag(PDB_SymType::Block);
InsertItemWithTag(PDB_SymType::Data);
InsertItemWithTag(PDB_SymType::Annotation);
InsertItemWithTag(PDB_SymType::Label);
InsertItemWithTag(PDB_SymType::PublicSymbol);
InsertItemWithTag(PDB_SymType::UDT);
InsertItemWithTag(PDB_SymType::Enum);
InsertItemWithTag(PDB_SymType::FunctionSig);
InsertItemWithTag(PDB_SymType::PointerType);
InsertItemWithTag(PDB_SymType::ArrayType);
InsertItemWithTag(PDB_SymType::BuiltinType);
InsertItemWithTag(PDB_SymType::Typedef);
InsertItemWithTag(PDB_SymType::BaseClass);
InsertItemWithTag(PDB_SymType::Friend);
InsertItemWithTag(PDB_SymType::FunctionArg);
InsertItemWithTag(PDB_SymType::FuncDebugStart);
InsertItemWithTag(PDB_SymType::FuncDebugEnd);
InsertItemWithTag(PDB_SymType::UsingNamespace);
InsertItemWithTag(PDB_SymType::VTableShape);
InsertItemWithTag(PDB_SymType::VTable);
InsertItemWithTag(PDB_SymType::Custom);
InsertItemWithTag(PDB_SymType::Thunk);
InsertItemWithTag(PDB_SymType::CustomType);
InsertItemWithTag(PDB_SymType::ManagedType);
InsertItemWithTag(PDB_SymType::Dimension);
InsertItemWithTag(PDB_SymType::Max);
}
template <class ExpectedType> void VerifyDyncast(PDB_SymType Tag) {
for (auto item = SymbolMap.begin(); item != SymbolMap.end(); ++item) {
EXPECT_EQ(item->first == Tag, llvm::isa<ExpectedType>(*item->second));
}
}
void VerifyUnknownDyncasts() {
for (auto item = SymbolMap.begin(); item != SymbolMap.end(); ++item) {
bool should_match = false;
if (item->first == PDB_SymType::None || item->first >= PDB_SymType::Max)
should_match = true;
EXPECT_EQ(should_match, llvm::isa<PDBSymbolUnknown>(*item->second));
}
}
private:
std::unique_ptr<IPDBSession> Session;
void InsertItemWithTag(PDB_SymType Tag) {
auto RawSymbol = std::make_unique<MockRawSymbol>(Tag);
auto Symbol = PDBSymbol::create(*Session, std::move(RawSymbol));
SymbolMap.insert(std::make_pair(Tag, std::move(Symbol)));
}
};
TEST_F(PDBApiTest, Dyncast) {
// Most of the types have a one-to-one mapping between Tag and concrete type.
VerifyDyncast<PDBSymbolExe>(PDB_SymType::Exe);
VerifyDyncast<PDBSymbolCompiland>(PDB_SymType::Compiland);
VerifyDyncast<PDBSymbolCompilandDetails>(PDB_SymType::CompilandDetails);
VerifyDyncast<PDBSymbolCompilandEnv>(PDB_SymType::CompilandEnv);
VerifyDyncast<PDBSymbolFunc>(PDB_SymType::Function);
VerifyDyncast<PDBSymbolBlock>(PDB_SymType::Block);
VerifyDyncast<PDBSymbolData>(PDB_SymType::Data);
VerifyDyncast<PDBSymbolAnnotation>(PDB_SymType::Annotation);
VerifyDyncast<PDBSymbolLabel>(PDB_SymType::Label);
VerifyDyncast<PDBSymbolPublicSymbol>(PDB_SymType::PublicSymbol);
VerifyDyncast<PDBSymbolTypeUDT>(PDB_SymType::UDT);
VerifyDyncast<PDBSymbolTypeEnum>(PDB_SymType::Enum);
VerifyDyncast<PDBSymbolTypeFunctionSig>(PDB_SymType::FunctionSig);
VerifyDyncast<PDBSymbolTypePointer>(PDB_SymType::PointerType);
VerifyDyncast<PDBSymbolTypeArray>(PDB_SymType::ArrayType);
VerifyDyncast<PDBSymbolTypeBuiltin>(PDB_SymType::BuiltinType);
VerifyDyncast<PDBSymbolTypeTypedef>(PDB_SymType::Typedef);
VerifyDyncast<PDBSymbolTypeBaseClass>(PDB_SymType::BaseClass);
VerifyDyncast<PDBSymbolTypeFriend>(PDB_SymType::Friend);
VerifyDyncast<PDBSymbolTypeFunctionArg>(PDB_SymType::FunctionArg);
VerifyDyncast<PDBSymbolFuncDebugStart>(PDB_SymType::FuncDebugStart);
VerifyDyncast<PDBSymbolFuncDebugEnd>(PDB_SymType::FuncDebugEnd);
VerifyDyncast<PDBSymbolUsingNamespace>(PDB_SymType::UsingNamespace);
VerifyDyncast<PDBSymbolTypeVTableShape>(PDB_SymType::VTableShape);
VerifyDyncast<PDBSymbolTypeVTable>(PDB_SymType::VTable);
VerifyDyncast<PDBSymbolCustom>(PDB_SymType::Custom);
VerifyDyncast<PDBSymbolThunk>(PDB_SymType::Thunk);
VerifyDyncast<PDBSymbolTypeCustom>(PDB_SymType::CustomType);
VerifyDyncast<PDBSymbolTypeManaged>(PDB_SymType::ManagedType);
VerifyDyncast<PDBSymbolTypeDimension>(PDB_SymType::Dimension);
VerifyUnknownDyncasts();
}
} // end anonymous namespace
Reference in New Issue View Git Blame Copy Permalink