6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-03-13 08:35:46 +00:00
Code Issues Projects Releases Wiki Activity

Revert "Create lib/DebugInfo/PDB."

Browse Source 
This reverts commit 21028, as it is causing failures in LLVMConfig.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@228431 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Zachary Turner 2015-02-06 20:00:18 +00:00
parent 9b13b8c338
commit 9c505a5d38
53 changed files with 2 additions and 2822 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
include/llvm/DebugInfo/PDB/IPDBDataStream.h
View File

@ -1,38 +0,0 @@
//===- IPDBDataStream.h - base interface for child enumerator -*- C++ ---*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBDATASTREAM_H
#define LLVM_DEBUGINFO_PDB_IPDBDATASTREAM_H
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Optional.h"
#include "PDBTypes.h"
namespace llvm {
/// IPDBDataStream defines an interface used to represent a stream consisting
/// of a name and a series of records whose formats depend on the particular
/// stream type.
class IPDBDataStream {
public:
typedef llvm::SmallVector<uint8_t, 32> RecordType;
virtual ~IPDBDataStream();
virtual uint32_t getRecordCount() const = 0;
virtual std::string getName() const = 0;
virtual llvm::Optional<RecordType> getItemAtIndex(uint32_t Index) const = 0;
virtual bool getNext(RecordType &Record) = 0;
virtual void reset() = 0;
virtual std::unique_ptr<IPDBDataStream> clone() const = 0;
};
}
#endif

33
include/llvm/DebugInfo/PDB/IPDBEnumChildren.h
View File

@ -1,33 +0,0 @@
//===- IPDBEnumChildren.h - base interface for child enumerator -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBENUMCHILDREN_H
#define LLVM_DEBUGINFO_PDB_IPDBENUMCHILDREN_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
template <typename ChildType> class IPDBEnumChildren {
public:
typedef std::unique_ptr<ChildType> ChildTypePtr;
typedef std::unique_ptr<IPDBEnumChildren<ChildType>> MyTypePtr;
virtual ~IPDBEnumChildren() {}
virtual uint32_t getChildCount() const = 0;
virtual ChildTypePtr getChildAtIndex(uint32_t Index) const = 0;
virtual ChildTypePtr getNext() = 0;
virtual void reset() = 0;
virtual MyTypePtr clone() const = 0;
};
}
#endif

36
include/llvm/DebugInfo/PDB/IPDBLineNumber.h
View File

@ -1,36 +0,0 @@
//===- IPDBLineNumber.h - base interface for PDB line no. info ---*- C++-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBLINENUMBER_H
#define LLVM_DEBUGINFO_PDB_IPDBLINENUMBER_H
#include "PDBTypes.h"
namespace llvm {
class IPDBLineNumber {
public:
virtual ~IPDBLineNumber();
virtual uint32_t getLineNumber() const = 0;
virtual uint32_t getLineNumberEnd() const = 0;
virtual uint32_t getColumnNumber() const = 0;
virtual uint32_t getColumnNumberEnd() const = 0;
virtual uint32_t getAddressSection() const = 0;
virtual uint32_t getAddressOffset() const = 0;
virtual uint32_t getRelativeVirtualAddress() const = 0;
virtual uint64_t getVirtualAddress() const = 0;
virtual uint32_t getLength() const = 0;
virtual uint32_t getSourceFileId() const = 0;
virtual uint32_t getCompilandId() const = 0;
virtual bool isStatement() const = 0;
};
}
#endif

209
include/llvm/DebugInfo/PDB/IPDBRawSymbol.h
View File

@ -1,209 +0,0 @@
//===- IPDBRawSymbol.h - base interface for PDB symbol types ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBRAWSYMBOL_H
#define LLVM_DEBUGINFO_PDB_IPDBRAWSYMBOL_H
#include <memory>
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/COFF.h"
#include "llvm/Support/raw_ostream.h"
#include "PDBTypes.h"
namespace llvm {
/// IPDBRawSymbol defines an interface used to represent an arbitrary symbol.
/// It exposes a monolithic interface consisting of accessors for the union of
/// all properties that are valid for any symbol type. This interface is then
/// wrapped by a concrete class which exposes only those set of methods valid
/// for this particular symbol type. See PDBSymbol.h for more details.
class IPDBRawSymbol {
public:
virtual ~IPDBRawSymbol();
virtual void dump(llvm::raw_ostream &OS) const = 0;
virtual std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const = 0;
virtual std::unique_ptr<IPDBEnumSymbols>
findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint32_t RVA) const = 0;
virtual std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByRVA(uint32_t RVA) const = 0;
virtual void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const = 0;
virtual PDB_MemberAccess getAccess() const = 0;
virtual uint32_t getAddressOffset() const = 0;
virtual uint32_t getAddressSection() const = 0;
virtual uint32_t getAge() const = 0;
virtual uint32_t getArrayIndexTypeId() const = 0;
virtual uint32_t getBackEndBuild() const = 0;
virtual uint32_t getBackEndMajor() const = 0;
virtual uint32_t getBackEndMinor() const = 0;
virtual uint32_t getBaseDataOffset() const = 0;
virtual uint32_t getBaseDataSlot() const = 0;
virtual uint32_t getBaseSymbolId() const = 0;
virtual PDB_BuiltinType getBuiltinType() const = 0;
virtual uint32_t getBitPosition() const = 0;
virtual PDB_CallingConv getCallingConvention() const = 0;
virtual uint32_t getClassParentId() const = 0;
virtual std::string getCompilerName() const = 0;
virtual uint32_t getCount() const = 0;
virtual uint32_t getCountLiveRanges() const = 0;
virtual uint32_t getFrontEndBuild() const = 0;
virtual uint32_t getFrontEndMajor() const = 0;
virtual uint32_t getFrontEndMinor() const = 0;
virtual PDB_Lang getLanguage() const = 0;
virtual uint32_t getLexicalParentId() const = 0;
virtual std::string getLibraryName() const = 0;
virtual uint32_t getLiveRangeStartAddressOffset() const = 0;
virtual uint32_t getLiveRangeStartAddressSection() const = 0;
virtual uint32_t getLiveRangeStartRelativeVirtualAddress() const = 0;
virtual uint32_t getLocalBasePointerRegisterId() const = 0;
virtual uint32_t getLowerBoundId() const = 0;
virtual uint32_t getMemorySpaceKind() const = 0;
virtual std::string getName() const = 0;
virtual uint32_t getNumberOfAcceleratorPointerTags() const = 0;
virtual uint32_t getNumberOfColumns() const = 0;
virtual uint32_t getNumberOfModifiers() const = 0;
virtual uint32_t getNumberOfRegisterIndices() const = 0;
virtual uint32_t getNumberOfRows() const = 0;
virtual std::string getObjectFileName() const = 0;
virtual uint32_t getOemId() const = 0;
virtual uint32_t getOemSymbolId() const = 0;
virtual uint32_t getOffsetInUdt() const = 0;
virtual PDB_Cpu getPlatform() const = 0;
virtual uint32_t getRank() const = 0;
virtual uint32_t getRegisterId() const = 0;
virtual uint32_t getRegisterType() const = 0;
virtual uint32_t getRelativeVirtualAddress() const = 0;
virtual uint32_t getSamplerSlot() const = 0;
virtual uint32_t getSignature() const = 0;
virtual uint32_t getSizeInUdt() const = 0;
virtual uint32_t getSlot() const = 0;
virtual std::string getSourceFileName() const = 0;
virtual uint32_t getStride() const = 0;
virtual uint32_t getSubTypeId() const = 0;
virtual std::string getSymbolsFileName() const = 0;
virtual uint32_t getSymIndexId() const = 0;
virtual uint32_t getTargetOffset() const = 0;
virtual uint32_t getTargetRelativeVirtualAddress() const = 0;
virtual uint64_t getTargetVirtualAddress() const = 0;
virtual uint32_t getTargetSection() const = 0;
virtual uint32_t getTextureSlot() const = 0;
virtual uint32_t getTimeStamp() const = 0;
virtual uint32_t getToken() const = 0;
virtual uint32_t getTypeId() const = 0;
virtual uint32_t getUavSlot() const = 0;
virtual std::string getUndecoratedName() const = 0;
virtual uint32_t getUnmodifiedTypeId() const = 0;
virtual uint32_t getUpperBoundId() const = 0;
virtual uint32_t getVirtualBaseDispIndex() const = 0;
virtual uint32_t getVirtualBaseOffset() const = 0;
virtual uint32_t getVirtualTableShapeId() const = 0;
virtual PDB_DataKind getDataKind() const = 0;
virtual PDB_SymType getSymTag() const = 0;
virtual PDB_UniqueId getGuid() const = 0;
virtual int32_t getOffset() const = 0;
virtual int32_t getThisAdjust() const = 0;
virtual int32_t getVirtualBasePointerOffset() const = 0;
virtual PDB_LocType getLocationType() const = 0;
virtual COFF::MachineTypes getMachineType() const = 0;
virtual PDB_ThunkOrdinal getThunkOrdinal() const = 0;
virtual uint64_t getLength() const = 0;
virtual uint64_t getLiveRangeLength() const = 0;
virtual uint64_t getVirtualAddress() const = 0;
virtual PDB_UdtType getUdtKind() const = 0;
virtual bool hasConstructor() const = 0;
virtual bool hasCustomCallingConvention() const = 0;
virtual bool hasFarReturn() const = 0;
virtual bool isCode() const = 0;
virtual bool isCompilerGenerated() const = 0;
virtual bool isConstType() const = 0;
virtual bool isEditAndContinueEnabled() const = 0;
virtual bool isFunction() const = 0;
virtual bool getAddressTaken() const = 0;
virtual bool getNoStackOrdering() const = 0;
virtual bool hasAlloca() const = 0;
virtual bool hasAssignmentOperator() const = 0;
virtual bool hasCTypes() const = 0;
virtual bool hasCastOperator() const = 0;
virtual bool hasDebugInfo() const = 0;
virtual bool hasEH() const = 0;
virtual bool hasEHa() const = 0;
virtual bool hasInlAsm() const = 0;
virtual bool hasInlineAttribute() const = 0;
virtual bool hasInterruptReturn() const = 0;
virtual bool hasLongJump() const = 0;
virtual bool hasManagedCode() const = 0;
virtual bool hasNestedTypes() const = 0;
virtual bool hasNoInlineAttribute() const = 0;
virtual bool hasNoReturnAttribute() const = 0;
virtual bool hasOptimizedCodeDebugInfo() const = 0;
virtual bool hasOverloadedOperator() const = 0;
virtual bool hasSEH() const = 0;
virtual bool hasSecurityChecks() const = 0;
virtual bool hasSetJump() const = 0;
virtual bool hasStrictGSCheck() const = 0;
virtual bool isAcceleratorGroupSharedLocal() const = 0;
virtual bool isAcceleratorPointerTagLiveRange() const = 0;
virtual bool isAcceleratorStubFunction() const = 0;
virtual bool isAggregated() const = 0;
virtual bool isIntroVirtualFunction() const = 0;
virtual bool isCVTCIL() const = 0;
virtual bool isConstructorVirtualBase() const = 0;
virtual bool isCxxReturnUdt() const = 0;
virtual bool isDataAligned() const = 0;
virtual bool isHLSLData() const = 0;
virtual bool isHotpatchable() const = 0;
virtual bool isIndirectVirtualBaseClass() const = 0;
virtual bool isInterfaceUdt() const = 0;
virtual bool isIntrinsic() const = 0;
virtual bool isLTCG() const = 0;
virtual bool isLocationControlFlowDependent() const = 0;
virtual bool isMSILNetmodule() const = 0;
virtual bool isMatrixRowMajor() const = 0;
virtual bool isManagedCode() const = 0;
virtual bool isMSILCode() const = 0;
virtual bool isMultipleInheritance() const = 0;
virtual bool isNaked() const = 0;
virtual bool isNested() const = 0;
virtual bool isOptimizedAway() const = 0;
virtual bool isPacked() const = 0;
virtual bool isPointerBasedOnSymbolValue() const = 0;
virtual bool isPointerToDataMember() const = 0;
virtual bool isPointerToMemberFunction() const = 0;
virtual bool isPureVirtual() const = 0;
virtual bool isRValueReference() const = 0;
virtual bool isRefUdt() const = 0;
virtual bool isReference() const = 0;
virtual bool isRestrictedType() const = 0;
virtual bool isReturnValue() const = 0;
virtual bool isSafeBuffers() const = 0;
virtual bool isScoped() const = 0;
virtual bool isSdl() const = 0;
virtual bool isSingleInheritance() const = 0;
virtual bool isSplitted() const = 0;
virtual bool isStatic() const = 0;
virtual bool hasPrivateSymbols() const = 0;
virtual bool isUnalignedType() const = 0;
virtual bool isUnreached() const = 0;
virtual bool isValueUdt() const = 0;
virtual bool isVirtual() const = 0;
virtual bool isVirtualBaseClass() const = 0;
virtual bool isVirtualInheritance() const = 0;
virtual bool isVolatileType() const = 0;
};
} // namespace llvm
#endif

37
include/llvm/DebugInfo/PDB/IPDBSession.h
View File

@ -1,37 +0,0 @@
//===- IPDBSession.h - base interface for a PDB symbol context --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBSESSION_H
#define LLVM_DEBUGINFO_PDB_IPDBSESSION_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolExe;
/// IPDBSession defines an interface used to provide a context for querying
/// debug information from a debug data source (for example, a PDB).
class IPDBSession {
public:
virtual ~IPDBSession();
virtual uint64_t getLoadAddress() const = 0;
virtual void setLoadAddress(uint64_t Address) = 0;
virtual std::unique_ptr<PDBSymbolExe> getGlobalScope() const = 0;
virtual std::unique_ptr<PDBSymbol> getSymbolById() const = 0;
virtual std::unique_ptr<IPDBSourceFile> getSourceFileById() const = 0;
virtual std::unique_ptr<IPDBEnumDataStreams> getDebugStreams() const = 0;
};
}
#endif

33
include/llvm/DebugInfo/PDB/IPDBSourceFile.h
View File

@ -1,33 +0,0 @@
//===- IPDBSourceFile.h - base interface for a PDB source file --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBSOURCEFILE_H
#define LLVM_DEBUGINFO_PDB_IPDBSOURCEFILE_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
/// IPDBSourceFile defines an interface used to represent source files whose
/// information are stored in the PDB.
class IPDBSourceFile {
public:
virtual ~IPDBSourceFile();
virtual std::string getFileName() const = 0;
virtual uint32_t getUniqueId() const = 0;
virtual std::string getChecksum() const = 0;
virtual PDB_Checksum getChecksumType() const = 0;
virtual std::unique_ptr<IPDBEnumCompilands> getCompilands() const = 0;
};
}
#endif

24
include/llvm/DebugInfo/PDB/PDB.h
View File

@ -1,24 +0,0 @@
//===- PDB.h - base header file for creating a PDB reader -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDB_H
#define LLVM_DEBUGINFO_PDB_PDB_H
#include <memory>
#include "PDBTypes.h"
namespace llvm {
class StringRef;
std::unique_ptr<IPDBSession> createPDBReader(PDB_ReaderType Type,
StringRef Path);
}
#endif

70
include/llvm/DebugInfo/PDB/PDBSymbol.h
View File

@ -1,70 +0,0 @@
//===- PDBSymbol.h - base class for user-facing symbol types -----*- C++-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_IPDBSYMBOL_H
#define LLVM_DEBUGINFO_PDB_IPDBSYMBOL_H
#include <memory>
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Casting.h"
#include "IPDBRawSymbol.h"
#include "PDBTypes.h"
#define FORWARD_SYMBOL_METHOD(MethodName) \
auto MethodName() const->decltype(RawSymbol->MethodName()) { \
return RawSymbol->MethodName(); \
}
namespace llvm {
class IPDBRawSymbol;
/// PDBSymbol defines the base of the inheritance hierarchy for concrete symbol
/// types (e.g. functions, executables, vtables, etc). All concrete symbol
/// types inherit from PDBSymbol and expose the exact set of methods that are
/// valid for that particular symbol type, as described in the Microsoft
/// reference "Lexical and Class Hierarchy of Symbol Types":
/// https://msdn.microsoft.com/en-us/library/370hs6k4.aspx
class PDBSymbol {
protected:
PDBSymbol(std::unique_ptr<IPDBRawSymbol> Symbol);
public:
static std::unique_ptr<PDBSymbol>
create(std::unique_ptr<IPDBRawSymbol> Symbol);
virtual ~PDBSymbol();
/// Dumps the contents of a symbol a raw_ostream. By default this will just
/// call dump() on the underlying RawSymbol, which allows us to discover
/// unknown properties, but individual implementations of PDBSymbol may
/// override the behavior to only dump known fields.
virtual void dump(llvm::raw_ostream &OS) const;
PDB_SymType getSymTag() const;
std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const;
std::unique_ptr<IPDBEnumSymbols> findChildrenByRVA(PDB_SymType Type,
StringRef Name,
PDB_NameSearchFlags Flags,
uint32_t RVA) const;
std::unique_ptr<IPDBEnumSymbols> findInlineFramesByRVA(uint32_t RVA) const;
protected:
const std::unique_ptr<IPDBRawSymbol> RawSymbol;
};
} // namespace llvm
#endif

37
include/llvm/DebugInfo/PDB/PDBSymbolAnnotation.h
View File

@ -1,37 +0,0 @@
//===- PDBSymbolAnnotation.h - Accessors for querying PDB annotations ---*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolAnnotation : public PDBSymbol {
public:
PDBSymbolAnnotation(std::unique_ptr<IPDBRawSymbol> AnnotationSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getDataKind)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
// FORWARD_SYMBOL_METHOD(getValue)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Annotation;
}
};
}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLANNOTATION_H

39
include/llvm/DebugInfo/PDB/PDBSymbolBlock.h
View File

@ -1,39 +0,0 @@
//===- PDBSymbolBlock.h - Accessors for querying PDB blocks -------------*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolBlock : public PDBSymbol {
public:
PDBSymbolBlock(std::unique_ptr<IPDBRawSymbol> BlockSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Block;
}
};
}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLBLOCK_H

36
include/llvm/DebugInfo/PDB/PDBSymbolCompiland.h
View File

@ -1,36 +0,0 @@
//===- PDBSymbolCompiland.h - Accessors for querying PDB compilands -----*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolCompiland : public PDBSymbol {
public:
PDBSymbolCompiland(std::unique_ptr<IPDBRawSymbol> CompilandSymbol);
FORWARD_SYMBOL_METHOD(isEditAndContinueEnabled)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLibraryName)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSourceFileName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Compiland;
}
};
}
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILAND_H

50
include/llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h
View File

@ -1,50 +0,0 @@
//===- PDBSymbolCompilandDetails.h - PDB compiland details ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDDETAILS_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDDETAILS_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolCompilandDetails : public PDBSymbol {
public:
PDBSymbolCompilandDetails(std::unique_ptr<IPDBRawSymbol> DetailsSymbol);
FORWARD_SYMBOL_METHOD(getBackEndBuild)
FORWARD_SYMBOL_METHOD(getBackEndMajor)
FORWARD_SYMBOL_METHOD(getBackEndMinor)
FORWARD_SYMBOL_METHOD(getCompilerName)
FORWARD_SYMBOL_METHOD(isEditAndContinueEnabled)
FORWARD_SYMBOL_METHOD(getFrontEndBuild)
FORWARD_SYMBOL_METHOD(getFrontEndMajor)
FORWARD_SYMBOL_METHOD(getFrontEndMinor)
FORWARD_SYMBOL_METHOD(hasDebugInfo)
FORWARD_SYMBOL_METHOD(hasManagedCode)
FORWARD_SYMBOL_METHOD(hasSecurityChecks)
FORWARD_SYMBOL_METHOD(isCVTCIL)
FORWARD_SYMBOL_METHOD(isDataAligned)
FORWARD_SYMBOL_METHOD(isHotpatchable)
FORWARD_SYMBOL_METHOD(isLTCG)
FORWARD_SYMBOL_METHOD(isMSILNetmodule)
FORWARD_SYMBOL_METHOD(getLanguage)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getPlatform)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::CompilandDetails;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBFUNCTION_H

34
include/llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h
View File

@ -1,34 +0,0 @@
//===- PDBSymbolCompilandEnv.h - compiland environment variables *- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolCompilandEnv : public PDBSymbol {
public:
PDBSymbolCompilandEnv(std::unique_ptr<IPDBRawSymbol> CompilandEnvSymbol);
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
std::string getValue() const;
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::CompilandEnv;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCOMPILANDENV_H

38
include/llvm/DebugInfo/PDB/PDBSymbolCustom.h
View File

@ -1,38 +0,0 @@
//===- PDBSymbolCustom.h - compiler-specific types --------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H
#include "llvm/ADT/SmallVector.h"
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
/// PDBSymbolCustom represents symbols that are compiler-specific and do not
/// fit anywhere else in the lexical hierarchy.
/// https://msdn.microsoft.com/en-us/library/d88sf09h.aspx
class PDBSymbolCustom : public PDBSymbol {
public:
PDBSymbolCustom(std::unique_ptr<IPDBRawSymbol> CustomSymbol);
void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes);
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Custom;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLCUSTOM_H

56
include/llvm/DebugInfo/PDB/PDBSymbolData.h
View File

@ -1,56 +0,0 @@
//===- PDBSymbolData.h - PDB data (e.g. variable) accessors -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolData : public PDBSymbol {
public:
PDBSymbolData(std::unique_ptr<IPDBRawSymbol> DataSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getAddressTaken)
FORWARD_SYMBOL_METHOD(getBitPosition)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isCompilerGenerated)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getDataKind)
FORWARD_SYMBOL_METHOD(isAggregated)
FORWARD_SYMBOL_METHOD(isSplitted)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(getRegisterId)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSlot)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getToken)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
// FORWARD_SYMBOL_METHOD(getValue)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Data;
}
};
}; // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLDATA_H

41
include/llvm/DebugInfo/PDB/PDBSymbolExe.h
View File

@ -1,41 +0,0 @@
//===- PDBSymbolExe.h - Accessors for querying executables in a PDB ----*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H
#include <string>
#include "llvm/Support/COFF.h"
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolExe : public PDBSymbol {
public:
PDBSymbolExe(std::unique_ptr<IPDBRawSymbol> ExeSymbol);
FORWARD_SYMBOL_METHOD(getAge)
FORWARD_SYMBOL_METHOD(getGuid)
FORWARD_SYMBOL_METHOD(hasCTypes)
FORWARD_SYMBOL_METHOD(hasPrivateSymbols)
FORWARD_SYMBOL_METHOD(getMachineType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSignature)
FORWARD_SYMBOL_METHOD(getSymbolsFileName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Exe;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLEXE_H

70
include/llvm/DebugInfo/PDB/PDBSymbolFunc.h
View File

@ -1,70 +0,0 @@
//===- PDBSymbolFunc.h - class representing a function instance -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolFunc : public PDBSymbol {
public:
PDBSymbolFunc(std::unique_ptr<IPDBRawSymbol> FuncSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasAlloca)
FORWARD_SYMBOL_METHOD(hasEH)
FORWARD_SYMBOL_METHOD(hasEHa)
FORWARD_SYMBOL_METHOD(hasInlAsm)
FORWARD_SYMBOL_METHOD(hasLongJump)
FORWARD_SYMBOL_METHOD(hasSEH)
FORWARD_SYMBOL_METHOD(hasSecurityChecks)
FORWARD_SYMBOL_METHOD(hasSetJump)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(isIntroVirtualFunction)
FORWARD_SYMBOL_METHOD(hasInlineAttribute)
FORWARD_SYMBOL_METHOD(isNaked)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getNoStackOrdering)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(isPureVirtual)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getToken)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(getUndecoratedName)
FORWARD_SYMBOL_METHOD(isVirtual)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Function;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNC_H

46
include/llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h
View File

@ -1,46 +0,0 @@
//===- PDBSymbolFuncDebugEnd.h - function end bounds info -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolFuncDebugEnd : public PDBSymbol {
public:
PDBSymbolFuncDebugEnd(std::unique_ptr<IPDBRawSymbol> FuncDebugEndSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FuncDebugEnd;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGEND_H

46
include/llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h
View File

@ -1,46 +0,0 @@
//===- PDBSymbolFuncDebugStart.h - function start bounds info ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolFuncDebugStart : public PDBSymbol {
public:
PDBSymbolFuncDebugStart(std::unique_ptr<IPDBRawSymbol> FuncDebugStartSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FuncDebugStart;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLFUNCDEBUGSTART_H

46
include/llvm/DebugInfo/PDB/PDBSymbolLabel.h
View File

@ -1,46 +0,0 @@
//===- PDBSymbolLabel.h - label info ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolLabel : public PDBSymbol {
public:
PDBSymbolLabel(std::unique_ptr<IPDBRawSymbol> LabelSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(hasCustomCallingConvention)
FORWARD_SYMBOL_METHOD(hasFarReturn)
FORWARD_SYMBOL_METHOD(hasInterruptReturn)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(hasNoInlineAttribute)
FORWARD_SYMBOL_METHOD(hasNoReturnAttribute)
FORWARD_SYMBOL_METHOD(isUnreached)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOptimizedCodeDebugInfo)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Label;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLLABEL_H

44
include/llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h
View File

@ -1,44 +0,0 @@
//===- PDBSymbolPublicSymbol.h - public symbol info -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolPublicSymbol : public PDBSymbol {
public:
PDBSymbolPublicSymbol(std::unique_ptr<IPDBRawSymbol> PublicSymbol);
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(isCode)
FORWARD_SYMBOL_METHOD(isFunction)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getLocationType)
FORWARD_SYMBOL_METHOD(isManagedCode)
FORWARD_SYMBOL_METHOD(isMSILCode)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(getUndecoratedName)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::PublicSymbol;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLPUBLICSYMBOL_H

54
include/llvm/DebugInfo/PDB/PDBSymbolThunk.h
View File

@ -1,54 +0,0 @@
//===- PDBSymbolThunk.h - Support for querying PDB thunks ---------------*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H
#include <string>
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolThunk : public PDBSymbol {
public:
PDBSymbolThunk(std::unique_ptr<IPDBRawSymbol> ThunkSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getAddressOffset)
FORWARD_SYMBOL_METHOD(getAddressSection)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(isIntroVirtualFunction)
FORWARD_SYMBOL_METHOD(isStatic)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isPureVirtual)
FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTargetOffset)
FORWARD_SYMBOL_METHOD(getTargetRelativeVirtualAddress)
FORWARD_SYMBOL_METHOD(getTargetVirtualAddress)
FORWARD_SYMBOL_METHOD(getTargetSection)
FORWARD_SYMBOL_METHOD(getThunkOrdinal)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVirtual)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Thunk;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTHUNK_H

40
include/llvm/DebugInfo/PDB/PDBSymbolTypeArray.h
View File

@ -1,40 +0,0 @@
//===- PDBSymbolTypeArray.h - array type information ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeArray : public PDBSymbol {
public:
PDBSymbolTypeArray(std::unique_ptr<IPDBRawSymbol> ArrayTypeSymbol);
FORWARD_SYMBOL_METHOD(getArrayIndexTypeId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getCount)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getRank)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::ArrayType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEARRAY_H

57
include/llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h
View File

@ -1,57 +0,0 @@
//===- PDBSymbolTypeBaseClass.h - base class type information ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeBaseClass : public PDBSymbol {
public:
PDBSymbolTypeBaseClass(std::unique_ptr<IPDBRawSymbol> BaseClassTypeSymbol);
FORWARD_SYMBOL_METHOD(getAccess)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(isIndirectVirtualBaseClass)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(getOffset)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(getUdtKind)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVirtualBaseClass)
FORWARD_SYMBOL_METHOD(getVirtualBaseDispIndex)
FORWARD_SYMBOL_METHOD(getVirtualBasePointerOffset)
// FORWARD_SYMBOL_METHOD(getVirtualBaseTableType)
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::BaseClass;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBASECLASS_H

37
include/llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h
View File

@ -1,37 +0,0 @@
//===- PDBSymbolTypeBuiltin.h - builtin type information --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeBuiltin : public PDBSymbol {
public:
PDBSymbolTypeBuiltin(std::unique_ptr<IPDBRawSymbol> BuiltinTypeSymbol);
FORWARD_SYMBOL_METHOD(getBuiltinType)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::BuiltinType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEBUILTIN_H

33
include/llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h
View File

@ -1,33 +0,0 @@
//===- PDBSymbolTypeCustom.h - custom compiler type information -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeCustom : public PDBSymbol {
public:
PDBSymbolTypeCustom(std::unique_ptr<IPDBRawSymbol> CustomTypeSymbol);
FORWARD_SYMBOL_METHOD(getOemId)
FORWARD_SYMBOL_METHOD(getOemSymbolId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::CustomType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPECUSTOM_H

33
include/llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h
View File

@ -1,33 +0,0 @@
//===- PDBSymbolTypeDimension.h - array dimension type info -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeDimension : public PDBSymbol {
public:
PDBSymbolTypeDimension(std::unique_ptr<IPDBRawSymbol> DimensionTypeSymbol);
FORWARD_SYMBOL_METHOD(getLowerBoundId)
FORWARD_SYMBOL_METHOD(getUpperBoundId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Dimension;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEDIMENSION_H

48
include/llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h
View File

@ -1,48 +0,0 @@
//===- PDBSymbolTypeEnum.h - enum type info ---------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeEnum : public PDBSymbol {
public:
PDBSymbolTypeEnum(std::unique_ptr<IPDBRawSymbol> EnumTypeSymbol);
FORWARD_SYMBOL_METHOD(getBuiltinType)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Enum;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEENUM_H

34
include/llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h
View File

@ -1,34 +0,0 @@
//===- PDBSymbolTypeFriend.h - friend type info -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeFriend : public PDBSymbol {
public:
PDBSymbolTypeFriend(std::unique_ptr<IPDBRawSymbol> FriendTypeSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Friend;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFRIEND_H

34
include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h
View File

@ -1,34 +0,0 @@
//===- PDBSymbolTypeFunctionArg.h - function arg type info ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeFunctionArg : public PDBSymbol {
public:
PDBSymbolTypeFunctionArg(std::unique_ptr<IPDBRawSymbol> FuncArgTypeSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FunctionArg;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONARG_H

41
include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h
View File

@ -1,41 +0,0 @@
//===- PDBSymbolTypeFunctionSig.h - function signature type info *- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeFunctionSig : public PDBSymbol {
public:
PDBSymbolTypeFunctionSig(std::unique_ptr<IPDBRawSymbol> FuncSigTypeSymbol);
FORWARD_SYMBOL_METHOD(getCallingConvention)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getCount)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
// FORWARD_SYMBOL_METHOD(getObjectPointerType)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getThisAdjust)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::FunctionSig;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEFUNCTIONSIG_H

32
include/llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h
View File

@ -1,32 +0,0 @@
//===- PDBSymbolTypeManaged.h - managed type info ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeManaged : public PDBSymbol {
public:
PDBSymbolTypeManaged(std::unique_ptr<IPDBRawSymbol> ManagedTypeSymbol);
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::ManagedType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEMANAGED_H

38
include/llvm/DebugInfo/PDB/PDBSymbolTypePointer.h
View File

@ -1,38 +0,0 @@
//===- PDBSymbolTypePointer.h - pointer type info ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypePointer : public PDBSymbol {
public:
PDBSymbolTypePointer(std::unique_ptr<IPDBRawSymbol> PointerTypeSymbol);
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(isReference)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::PointerType;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEPOINTER_H

51
include/llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h
View File

@ -1,51 +0,0 @@
//===- PDBSymbolTypeTypedef.h - typedef type info ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeTypedef : public PDBSymbol {
public:
PDBSymbolTypeTypedef(std::unique_ptr<IPDBRawSymbol> TypedefSymbol);
FORWARD_SYMBOL_METHOD(getBuiltinType)
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isReference)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(getUdtKind)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::Typedef;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPETYPEDEF_H

48
include/llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h
View File

@ -1,48 +0,0 @@
//===- PDBSymbolTypeUDT.h - UDT type info -----------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeUDT : public PDBSymbol {
public:
PDBSymbolTypeUDT(std::unique_ptr<IPDBRawSymbol> UDTSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(hasConstructor)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(hasAssignmentOperator)
FORWARD_SYMBOL_METHOD(hasCastOperator)
FORWARD_SYMBOL_METHOD(hasNestedTypes)
FORWARD_SYMBOL_METHOD(getLength)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(isNested)
FORWARD_SYMBOL_METHOD(hasOverloadedOperator)
FORWARD_SYMBOL_METHOD(isPacked)
FORWARD_SYMBOL_METHOD(isScoped)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getUdtKind)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::UDT;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEUDT_H

37
include/llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h
View File

@ -1,37 +0,0 @@
//===- PDBSymbolTypeVTable.h - VTable type info -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeVTable : public PDBSymbol {
public:
PDBSymbolTypeVTable(std::unique_ptr<IPDBRawSymbol> VtblSymbol);
FORWARD_SYMBOL_METHOD(getClassParentId)
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::VTable;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLE_H

36
include/llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h
View File

@ -1,36 +0,0 @@
//===- PDBSymbolTypeVTableShape.h - VTable shape info -----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolTypeVTableShape : public PDBSymbol {
public:
PDBSymbolTypeVTableShape(std::unique_ptr<IPDBRawSymbol> VtblShapeSymbol);
FORWARD_SYMBOL_METHOD(isConstType)
FORWARD_SYMBOL_METHOD(getCount)
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getSymIndexId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
FORWARD_SYMBOL_METHOD(isVolatileType)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::VTableShape;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLTYPEVTABLESHAPE_H

30
include/llvm/DebugInfo/PDB/PDBSymbolUnknown.h
View File

@ -1,30 +0,0 @@
//===- PDBSymbolUnknown.h - unknown symbol type -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolUnknown : public PDBSymbol {
public:
PDBSymbolUnknown(std::unique_ptr<IPDBRawSymbol> UnknownSymbol);
static bool classof(const PDBSymbol *S) {
return (S->getSymTag() == PDB_SymType::None ||
S->getSymTag() >= PDB_SymType::Max);
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLUNKNOWN_H

33
include/llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h
View File

@ -1,33 +0,0 @@
//===- PDBSymbolUsingNamespace.h - using namespace info ---------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H
#define LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H
#include "PDBSymbol.h"
#include "PDBTypes.h"
namespace llvm {
class PDBSymbolUsingNamespace : public PDBSymbol {
public:
PDBSymbolUsingNamespace(std::unique_ptr<IPDBRawSymbol> UsingSymbol);
FORWARD_SYMBOL_METHOD(getLexicalParentId)
FORWARD_SYMBOL_METHOD(getName)
FORWARD_SYMBOL_METHOD(getSymIndexId)
static bool classof(const PDBSymbol *S) {
return S->getSymTag() == PDB_SymType::UsingNamespace;
}
};
} // namespace llvm
#endif // LLVM_DEBUGINFO_PDB_PDBSYMBOLUSINGNAMESPACE_H

350
include/llvm/DebugInfo/PDB/PDBTypes.h
View File

@ -1,350 +0,0 @@
//===- PDBTypes.h - Defines enums for various fields contained in PDB ---*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_PDB_PDBTYPES_H
#define LLVM_DEBUGINFO_PDB_PDBTYPES_H
#include <stdint.h>
namespace llvm {
class PDBSymbol;
class PDBSymbolCompiland;
class PDBSymbolFunc;
class PDBSymbolExe;
class IPDBDataStream;
template <class T> class IPDBEnumChildren;
class IPDBRawSymbol;
class IPDBSession;
class IPDBSourceFile;
typedef IPDBEnumChildren<IPDBRawSymbol> IPDBEnumSymbols;
typedef IPDBEnumChildren<IPDBSourceFile> IPDBEnumSourceFiles;
typedef IPDBEnumChildren<IPDBDataStream> IPDBEnumDataStreams;
typedef IPDBEnumChildren<PDBSymbolCompiland> IPDBEnumCompilands;
class PDBSymbolExe;
class PDBSymbolCompiland;
class PDBSymbolCompilandDetails;
class PDBSymbolCompilandEnv;
class PDBSymbolFunc;
class PDBSymbolBlock;
class PDBSymbolData;
class PDBSymbolAnnotation;
class PDBSymbolLabel;
class PDBSymbolPublicSymbol;
class PDBSymbolTypeUDT;
class PDBSymbolTypeEnum;
class PDBSymbolTypeFunctionSig;
class PDBSymbolTypePointer;
class PDBSymbolTypeArray;
class PDBSymbolTypeBuiltin;
class PDBSymbolTypeTypedef;
class PDBSymbolTypeBaseClass;
class PDBSymbolTypeFriend;
class PDBSymbolTypeFunctionArg;
class PDBSymbolFuncDebugStart;
class PDBSymbolFuncDebugEnd;
class PDBSymbolUsingNamespace;
class PDBSymbolTypeVTableShape;
class PDBSymbolTypeVTable;
class PDBSymbolCustom;
class PDBSymbolThunk;
class PDBSymbolTypeCustom;
class PDBSymbolTypeManaged;
class PDBSymbolTypeDimension;
class PDBSymbolUnknown;
/// Specifies which PDB reader implementation is to be used. Only a value
/// of PDB_ReaderType::DIA is supported.
enum class PDB_ReaderType {
SystemDefault = 0,
#if defined(_MSC_VER)
DIA = 1,
#endif
};
/// Defines a 128-bit unique identifier. This maps to a GUID on Windows, but
/// is abstracted here for the purposes of non-Windows platforms that don't have
/// the GUID structure defined.
struct PDB_UniqueId {
uint64_t HighPart;
uint64_t LowPart;
};
/// An enumeration indicating the type of data contained in this table.
enum class PDB_TableType {
Symbols,
SourceFiles,
LineNumbers,
SectionContribs,
Segments,
InjectedSources,
FrameData
};
/// Defines flags used for enumerating child symbols. This corresponds to the
/// NameSearchOptions enumeration which is documented here:
/// https://msdn.microsoft.com/en-us/library/yat28ads.aspx
enum PDB_NameSearchFlags {
NS_Default = 0x0,
NS_CaseSensitive = 0x1,
NS_CaseInsensitive = 0x2,
NS_FileNameExtMatch = 0x4,
NS_Regex = 0x8,
NS_UndecoratedName = 0x10
};
/// Specifies the hash algorithm that a source file from a PDB was hashed with.
/// This corresponds to the CV_SourceChksum_t enumeration and are documented
/// here: https://msdn.microsoft.com/en-us/library/e96az21x.aspx
enum class PDB_Checksum { None = 0, MD5 = 1, SHA1 = 2 };
/// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
enum class PDB_Cpu {
Intel8080 = 0x0,
Intel8086 = 0x1,
Intel80286 = 0x2,
Intel80386 = 0x3,
Intel80486 = 0x4,
Pentium = 0x5,
PentiumPro = 0x6,
Pentium3 = 0x7,
MIPS = 0x10,
MIPS16 = 0x11,
MIPS32 = 0x12,
MIPS64 = 0x13,
MIPSI = 0x14,
MIPSII = 0x15,
MIPSIII = 0x16,
MIPSIV = 0x17,
MIPSV = 0x18,
M68000 = 0x20,
M68010 = 0x21,
M68020 = 0x22,
M68030 = 0x23,
M68040 = 0x24,
Alpha = 0x30,
Alpha21164 = 0x31,
Alpha21164A = 0x32,
Alpha21264 = 0x33,
Alpha21364 = 0x34,
PPC601 = 0x40,
PPC603 = 0x41,
PPC604 = 0x42,
PPC620 = 0x43,
PPCFP = 0x44,
PPCBE = 0x45,
SH3 = 0x50,
SH3E = 0x51,
SH3DSP = 0x52,
SH4 = 0x53,
SHMedia = 0x54,
ARM3 = 0x60,
ARM4 = 0x61,
ARM4T = 0x62,
ARM5 = 0x63,
ARM5T = 0x64,
ARM6 = 0x65,
ARM_XMAC = 0x66,
ARM_WMMX = 0x67,
ARM7 = 0x68,
Omni = 0x70,
Ia64 = 0x80,
Ia64_2 = 0x81,
CEE = 0x90,
AM33 = 0xa0,
M32R = 0xb0,
TriCore = 0xc0,
X64 = 0xd0,
EBC = 0xe0,
Thumb = 0xf0,
ARMNT = 0xf4,
D3D11_Shader = 0x100,
};
/// These values correspond to the CV_call_e enumeration, and are documented
/// at the following locations:
/// https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
/// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
///
enum class PDB_CallingConv {
NearCdecl = 0x00,
FarCdecl = 0x01,
NearPascal = 0x02,
FarPascal = 0x03,
NearFastcall = 0x04,
FarFastcall = 0x05,
Skipped = 0x06,
NearStdcall = 0x07,
FarStdcall = 0x08,
NearSyscall = 0x09,
FarSyscall = 0x0a,
Thiscall = 0x0b,
MipsCall = 0x0c,
Generic = 0x0d,
Alphacall = 0x0e,
Ppccall = 0x0f,
SuperHCall = 0x10,
Armcall = 0x11,
AM33call = 0x12,
Tricall = 0x13,
Sh5call = 0x14,
M32R = 0x15,
Clrcall = 0x16,
Inline = 0x17,
NearVectorcall = 0x18,
Reserved = 0x19,
};
/// These values correspond to the CV_CFL_LANG enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
enum class PDB_Lang {
C = 0x00,
Cpp = 0x01,
Fortran = 0x02,
Masm = 0x03,
Pascal = 0x04,
Basic = 0x05,
Cobol = 0x06,
Link = 0x07,
Cvtres = 0x08,
Cvtpgd = 0x09,
CSharp = 0x0a,
VB = 0x0b,
ILAsm = 0x0c,
Java = 0x0d,
JScript = 0x0e,
MSIL = 0x0f,
HLSL = 0x10
};
/// These values correspond to the DataKind enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/b2x2t313.aspx
enum class PDB_DataKind {
Unknown,
Local,
StaticLocal,
Param,
ObjectPtr,
FileStatic,
Global,
Member,
StaticMember,
Constant
};
/// These values correspond to the SymTagEnum enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/bkedss5f.aspx
enum class PDB_SymType {
None,
Exe,
Compiland,
CompilandDetails,
CompilandEnv,
Function,
Block,
Data,
Annotation,
Label,
PublicSymbol,
UDT,
Enum,
FunctionSig,
PointerType,
ArrayType,
BuiltinType,
Typedef,
BaseClass,
Friend,
FunctionArg,
FuncDebugStart,
FuncDebugEnd,
UsingNamespace,
VTableShape,
VTable,
Custom,
Thunk,
CustomType,
ManagedType,
Dimension,
Max
};
/// These values correspond to the LocationType enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/f57kaez3.aspx
enum class PDB_LocType {
Null,
Static,
TLS,
RegRel,
ThisRel,
Enregistered,
BitField,
Slot,
IlRel,
MetaData,
Constant,
Max
};
/// These values correspond to the THUNK_ORDINAL enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/dh0k8hft.aspx
enum class PDB_ThunkOrdinal {
Standard,
ThisAdjustor,
Vcall,
Pcode,
UnknownLoad,
TrampIncremental,
BranchIsland
};
/// These values correspond to the UdtKind enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/wcstk66t.aspx
enum class PDB_UdtType { Struct, Class, Union, Interface };
/// These values correspond to the StackFrameTypeEnum enumeration, and are
/// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
enum class PDB_StackFrameType { FPO, KernelTrap, KernelTSS, EBP, FrameData };
/// These values correspond to the StackFrameTypeEnum enumeration, and are
/// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
enum class PDB_MemoryType { Code, Data, Stack, HeapCode };
/// These values correspond to the Basictype enumeration, and are documented
/// here: https://msdn.microsoft.com/en-us/library/4szdtzc3.aspx
enum class PDB_BuiltinType {
None = 0,
Void = 1,
Char = 2,
WCharT = 3,
Int = 6,
UInt = 7,
Float = 8,
BCD = 9,
Bool = 10,
Long = 13,
ULong = 14,
Currency = 25,
Date = 26,
Variant = 27,
Complex = 28,
Bitfield = 29,
BSTR = 30,
HResult = 31
};
enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 };
} // namespace llvm
#endif

5
lib/DebugInfo/CMakeLists.txt
View File

@ -1,5 +1,2 @@
add_subdirectory(DWARF)
if (MSVC)
add_subdirectory(PDB)
endif()
add_subdirectory(DWARF)

2
lib/DebugInfo/LLVMBuild.txt
View File

@ -16,7 +16,7 @@
;===------------------------------------------------------------------------===;
[common]
subdirectories = DWARF PDB
subdirectories = DWARF
[component_0]
type = Group

7
lib/DebugInfo/PDB/CMakeLists.txt
View File

@ -1,7 +0,0 @@
add_llvm_library(LLVMDebugInfoPDB
PDB.cpp
PDBInterfaceAnchors.cpp
PDBSymbol.cpp
PDBSymbolCompilandEnv.cpp
PDBSymbolCustom.cpp
)

23
lib/DebugInfo/PDB/LLVMBuild.txt
View File

@ -1,23 +0,0 @@
;===- ./lib/DebugInfo/PDB/LLVMBuild.txt ------------------------*- Conf -*--===;
;
; The LLVM Compiler Infrastructure
;
; This file is distributed under the University of Illinois Open Source
; License. See LICENSE.TXT for details.
;
;===------------------------------------------------------------------------===;
;
; This is an LLVMBuild description file for the components in this subdirectory.
;
; For more information on the LLVMBuild system, please see:
;
; http://llvm.org/docs/LLVMBuild.html
;
;===------------------------------------------------------------------------===;
[component_0]
type = Library
name = DebugInfoPDB
parent = DebugInfo
required_libraries = Support

21
lib/DebugInfo/PDB/PDB.cpp
View File

@ -1,21 +0,0 @@
//===- PDB.cpp - base header file for creating a PDB reader -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringRef.h"
#include "llvm/DebugInfo/PDB/PDB.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
using namespace llvm;
std::unique_ptr<IPDBSession> llvm::createPDBReader(PDB_ReaderType Type,
StringRef Path) {
// Create the correct concrete instance type based on the value of Type.
return nullptr;
}

101
lib/DebugInfo/PDB/PDBInterfaceAnchors.cpp
View File

@ -1,101 +0,0 @@
//===- PDBInterfaceAnchors.h - defines class anchor funcions ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Class anchors are necessary per the LLVM Coding style guide, to ensure that
// the vtable is only generated in this object file, and not in every object
// file that incldues the corresponding header.
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/IPDBDataStream.h"
#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.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"
using namespace llvm;
IPDBSession::~IPDBSession() {}
IPDBDataStream::~IPDBDataStream() {}
IPDBRawSymbol::~IPDBRawSymbol() {}
IPDBSourceFile::~IPDBSourceFile() {}
IPDBLineNumber::~IPDBLineNumber() {}
// All of the concrete symbol types have their methods declared inline through
// the use of a forwarding macro, so the constructor should be declared out of
// line to get the vtable in this file.
#define FORWARD_SYMBOL_CONSTRUCTOR(ClassName) \
ClassName::ClassName(std::unique_ptr<IPDBRawSymbol> Symbol) \
: PDBSymbol(std::move(Symbol)) {}
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolAnnotation)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolBlock)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCompiland)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCompilandDetails)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCompilandEnv)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolCustom)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolData)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolExe)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolFunc)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolFuncDebugEnd)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolFuncDebugStart)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolLabel)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolPublicSymbol)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolThunk)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeArray)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeBaseClass)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeBuiltin)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeCustom)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeDimension)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeEnum)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeFriend)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeFunctionArg)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeFunctionSig)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeManaged)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypePointer)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeTypedef)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeUDT)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeVTable)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolTypeVTableShape)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolUnknown)
FORWARD_SYMBOL_CONSTRUCTOR(PDBSymbolUsingNamespace)

117
lib/DebugInfo/PDB/PDBSymbol.cpp
View File

@ -1,117 +0,0 @@
//===- PDBSymbol.cpp - base class for user-facing symbol types --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <memory>
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.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"
using namespace llvm;
PDBSymbol::PDBSymbol(std::unique_ptr<IPDBRawSymbol> Symbol)
: RawSymbol(std::move(Symbol)) {}
PDBSymbol::~PDBSymbol() {}
#define FACTORY_SYMTAG_CASE(Tag, Type) \
case PDB_SymType::Tag: \
return std::unique_ptr<PDBSymbol>(new Type(std::move(Symbol)));
std::unique_ptr<PDBSymbol>
PDBSymbol::create(std::unique_ptr<IPDBRawSymbol> Symbol) {
switch (Symbol->getSymTag()) {
FACTORY_SYMTAG_CASE(Exe, PDBSymbolExe)
FACTORY_SYMTAG_CASE(Compiland, PDBSymbolCompiland)
FACTORY_SYMTAG_CASE(CompilandDetails, PDBSymbolCompilandDetails)
FACTORY_SYMTAG_CASE(CompilandEnv, PDBSymbolCompilandEnv)
FACTORY_SYMTAG_CASE(Function, PDBSymbolFunc)
FACTORY_SYMTAG_CASE(Block, PDBSymbolBlock)
FACTORY_SYMTAG_CASE(Data, PDBSymbolData)
FACTORY_SYMTAG_CASE(Annotation, PDBSymbolAnnotation)
FACTORY_SYMTAG_CASE(Label, PDBSymbolLabel)
FACTORY_SYMTAG_CASE(PublicSymbol, PDBSymbolPublicSymbol)
FACTORY_SYMTAG_CASE(UDT, PDBSymbolTypeUDT)
FACTORY_SYMTAG_CASE(Enum, PDBSymbolTypeEnum)
FACTORY_SYMTAG_CASE(FunctionSig, PDBSymbolTypeFunctionSig)
FACTORY_SYMTAG_CASE(PointerType, PDBSymbolTypePointer)
FACTORY_SYMTAG_CASE(ArrayType, PDBSymbolTypeArray)
FACTORY_SYMTAG_CASE(BuiltinType, PDBSymbolTypeBuiltin)
FACTORY_SYMTAG_CASE(Typedef, PDBSymbolTypeTypedef)
FACTORY_SYMTAG_CASE(BaseClass, PDBSymbolTypeBaseClass)
FACTORY_SYMTAG_CASE(Friend, PDBSymbolTypeFriend)
FACTORY_SYMTAG_CASE(FunctionArg, PDBSymbolTypeFunctionArg)
FACTORY_SYMTAG_CASE(FuncDebugStart, PDBSymbolFuncDebugStart)
FACTORY_SYMTAG_CASE(FuncDebugEnd, PDBSymbolFuncDebugEnd)
FACTORY_SYMTAG_CASE(UsingNamespace, PDBSymbolUsingNamespace)
FACTORY_SYMTAG_CASE(VTableShape, PDBSymbolTypeVTableShape)
FACTORY_SYMTAG_CASE(VTable, PDBSymbolTypeVTable)
FACTORY_SYMTAG_CASE(Custom, PDBSymbolCustom)
FACTORY_SYMTAG_CASE(Thunk, PDBSymbolThunk)
FACTORY_SYMTAG_CASE(CustomType, PDBSymbolTypeCustom)
FACTORY_SYMTAG_CASE(ManagedType, PDBSymbolTypeManaged)
FACTORY_SYMTAG_CASE(Dimension, PDBSymbolTypeDimension)
default:
return std::unique_ptr<PDBSymbol>(new PDBSymbolUnknown(std::move(Symbol)));
}
}
void PDBSymbol::dump(llvm::raw_ostream &OS) const { RawSymbol->dump(OS); }
PDB_SymType PDBSymbol::getSymTag() const { return RawSymbol->getSymTag(); }
std::unique_ptr<IPDBEnumSymbols>
PDBSymbol::findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const {
return RawSymbol->findChildren(Type, Name, Flags);
}
std::unique_ptr<IPDBEnumSymbols>
PDBSymbol::findChildrenByRVA(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags, uint32_t RVA) const {
return RawSymbol->findChildrenByRVA(Type, Name, Flags, RVA);
}
std::unique_ptr<IPDBEnumSymbols>
PDBSymbol::findInlineFramesByRVA(uint32_t RVA) const {
return RawSymbol->findInlineFramesByRVA(RVA);
}

21
lib/DebugInfo/PDB/PDBSymbolCompilandEnv.cpp
View File

@ -1,21 +0,0 @@
//===- PDBSymbolCompilandEnv.cpp - compiland env variables ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h"
using namespace llvm;
std::string PDBSymbolCompilandEnv::getValue() const {
// call RawSymbol->getValue() and convert the result to an std::string.
return std::string();
}

20
lib/DebugInfo/PDB/PDBSymbolCustom.cpp
View File

@ -1,20 +0,0 @@
//===- PDBSymbolCustom.cpp - compiler-specific types ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCustom.h"
using namespace llvm;
void PDBSymbolCustom::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) {
RawSymbol->getDataBytes(bytes);
}

2
unittests/DebugInfo/CMakeLists.txt
View File

@ -9,5 +9,3 @@ set(DebugInfoSources
add_llvm_unittest(DebugInfoTests
${DebugInfoSources}
)
add_subdirectory(PDB)

11
unittests/DebugInfo/PDB/CMakeLists.txt
View File

@ -1,11 +0,0 @@
set(LLVM_LINK_COMPONENTS
DebugInfoPDB
)
set(DebugInfoPDBSources
PDBApiTest.cpp
)
add_llvm_unittest(DebugInfoPDBTests
${DebugInfoPDBSources}
)

16
unittests/DebugInfo/PDB/Makefile
View File

@ -1,16 +0,0 @@
##===- unittests/DebugInfo/PDB/Makefile -------------------*- Makefile -*-===##
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
LEVEL = ../..
TESTNAME = DebugInfoPDB
LINK_COMPONENTS := DebugInfoPDB object support
include $(LEVEL)/Makefile.config
include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest

349
unittests/DebugInfo/PDB/PDBApiTest.cpp
View File

@ -1,349 +0,0 @@
//===- llvm/unittest/DebugInfo/PDB/PDBApiTest.cpp -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <hash_map>
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBRawSymbol.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;
namespace {
#define MOCK_SYMBOL_ACCESSOR(Func) \
auto Func() const->decltype(((IPDBRawSymbol *)nullptr)->Func()) override { \
typedef decltype(IPDBRawSymbol::Func()) ReturnType; \
return ReturnType(); \
}
class MockRawSymbol : public IPDBRawSymbol {
public:
MockRawSymbol(PDB_SymType SymType) : Type(SymType) {}
virtual void dump(llvm::raw_ostream &OS) const {}
virtual std::unique_ptr<IPDBEnumSymbols>
findChildren(PDB_SymType Type, StringRef Name,
PDB_NameSearchFlags Flags) const {
return nullptr;
}
virtual std::unique_ptr<IPDBEnumSymbols>
findChildrenByRVA(PDB_SymType Type, StringRef Name, PDB_NameSearchFlags Flags,
uint32_t RVA) const {
return nullptr;
}
virtual std::unique_ptr<IPDBEnumSymbols>
findInlineFramesByRVA(uint32_t RVA) const {
return nullptr;
}
virtual void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const {}
PDB_SymType getSymTag() const override { return Type; }
MOCK_SYMBOL_ACCESSOR(getAccess)
MOCK_SYMBOL_ACCESSOR(getAddressOffset)
MOCK_SYMBOL_ACCESSOR(getAddressSection)
MOCK_SYMBOL_ACCESSOR(getAge)
MOCK_SYMBOL_ACCESSOR(getArrayIndexTypeId)
MOCK_SYMBOL_ACCESSOR(getBackEndBuild)
MOCK_SYMBOL_ACCESSOR(getBackEndMajor)
MOCK_SYMBOL_ACCESSOR(getBackEndMinor)
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(getFrontEndBuild)
MOCK_SYMBOL_ACCESSOR(getFrontEndMajor)
MOCK_SYMBOL_ACCESSOR(getFrontEndMinor)
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(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(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)
private:
PDB_SymType Type;
};
class PDBApiTest : public testing::Test {
public:
std::hash_map<PDB_SymType, std::unique_ptr<PDBSymbol>> SymbolMap;
void SetUp() override {
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);
}
private:
void InsertItemWithTag(PDB_SymType Tag) {
auto RawSymbol = std::unique_ptr<IPDBRawSymbol>(new MockRawSymbol(Tag));
auto Symbol = PDBSymbol::create(std::move(RawSymbol));
SymbolMap.insert(std::make_pair(Tag, std::move(Symbol)));
}
public:
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));
}
}
};
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