IR: Add specialized debug info metadata nodes

Add specialized debug info metadata nodes that match the `DIDescriptor`
wrappers (used by `DIBuilder`) closely.  Assembly and bitcode support to
follow soon (it'll mostly just be obvious), but this sketches in today's
schema.  This is the first big commit (well, the only *big* one aside
from the testcase changes that'll come when I move this into place) for
PR22464.

I've marked a bunch of obvious changes as `TODO`s in the source; I plan
to make those changes promptly after this hierarchy is moved underneath
`DIDescriptor`, but for now I'm aiming mostly to match the status quo.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@228640 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan P. N. Exon Smith 2015-02-10 00:52:32 +00:00
parent cd641756c3
commit 14fcfef23b
8 changed files with 3261 additions and 4 deletions

File diff suppressed because it is too large Load Diff

View File

@ -51,6 +51,32 @@ HANDLE_MDNODE_LEAF(MDTuple)
HANDLE_MDNODE_LEAF(MDLocation)
HANDLE_MDNODE_BRANCH(DebugNode)
HANDLE_MDNODE_LEAF(GenericDebugNode)
HANDLE_MDNODE_LEAF(MDSubrange)
HANDLE_MDNODE_LEAF(MDEnumerator)
HANDLE_MDNODE_BRANCH(MDScope)
HANDLE_MDNODE_BRANCH(MDType)
HANDLE_MDNODE_LEAF(MDBasicType)
HANDLE_MDNODE_BRANCH(MDDerivedTypeBase)
HANDLE_MDNODE_LEAF(MDDerivedType)
HANDLE_MDNODE_BRANCH(MDCompositeTypeBase)
HANDLE_MDNODE_LEAF(MDCompositeType)
HANDLE_MDNODE_LEAF(MDSubroutineType)
HANDLE_MDNODE_LEAF(MDFile)
HANDLE_MDNODE_LEAF(MDCompileUnit)
HANDLE_MDNODE_LEAF(MDSubprogram)
HANDLE_MDNODE_BRANCH(MDLexicalBlockBase)
HANDLE_MDNODE_LEAF(MDLexicalBlock)
HANDLE_MDNODE_LEAF(MDLexicalBlockFile)
HANDLE_MDNODE_LEAF(MDNamespace)
HANDLE_MDNODE_BRANCH(MDTemplateParameter)
HANDLE_MDNODE_LEAF(MDTemplateTypeParameter)
HANDLE_MDNODE_LEAF(MDTemplateValueParameter)
HANDLE_MDNODE_BRANCH(MDVariable)
HANDLE_MDNODE_LEAF(MDGlobalVariable)
HANDLE_MDNODE_LEAF(MDLocalVariable)
HANDLE_MDNODE_LEAF(MDExpression)
HANDLE_MDNODE_LEAF(MDObjCProperty)
HANDLE_MDNODE_LEAF(MDImportedEntity)
#undef HANDLE_METADATA
#undef HANDLE_METADATA_LEAF

View File

@ -62,6 +62,25 @@ public:
MDTupleKind,
MDLocationKind,
GenericDebugNodeKind,
MDSubrangeKind,
MDEnumeratorKind,
MDBasicTypeKind,
MDDerivedTypeKind,
MDCompositeTypeKind,
MDSubroutineTypeKind,
MDFileKind,
MDCompileUnitKind,
MDSubprogramKind,
MDLexicalBlockKind,
MDLexicalBlockFileKind,
MDNamespaceKind,
MDTemplateTypeParameterKind,
MDTemplateValueParameterKind,
MDGlobalVariableKind,
MDLocalVariableKind,
MDExpressionKind,
MDObjCPropertyKind,
MDImportedEntityKind,
ConstantAsMetadataKind,
LocalAsMetadataKind,
MDStringKind
@ -865,9 +884,14 @@ public:
/// \brief Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Metadata *MD) {
return MD->getMetadataID() == MDTupleKind ||
MD->getMetadataID() == MDLocationKind ||
MD->getMetadataID() == GenericDebugNodeKind;
switch (MD->getMetadataID()) {
default:
return false;
#define HANDLE_MDNODE_LEAF(CLASS) \
case CLASS##Kind: \
return true;
#include "llvm/IR/Metadata.def"
}
}
/// \brief Check whether MDNode is a vtable access.

View File

@ -809,6 +809,106 @@ static void WriteGenericDebugNode(const GenericDebugNode *N,
Record.clear();
}
static void WriteMDSubrange(const MDSubrange *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDEnumerator(const MDEnumerator *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDBasicType(const MDBasicType *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDDerivedType(const MDDerivedType *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDCompositeType(const MDCompositeType *,
const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDSubroutineType(const MDSubroutineType *,
const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDFile(const MDFile *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDCompileUnit(const MDCompileUnit *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDSubprogram(const MDSubprogram *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDLexicalBlock(const MDLexicalBlock *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDLexicalBlockFile(const MDLexicalBlockFile *,
const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDNamespace(const MDNamespace *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDTemplateTypeParameter(const MDTemplateTypeParameter *,
const ValueEnumerator &,
BitstreamWriter &,
SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDTemplateValueParameter(const MDTemplateValueParameter *,
const ValueEnumerator &,
BitstreamWriter &,
SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDGlobalVariable(const MDGlobalVariable *,
const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDLocalVariable(const MDLocalVariable *,
const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDExpression(const MDExpression *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDObjCProperty(const MDObjCProperty *, const ValueEnumerator &,
BitstreamWriter &, SmallVectorImpl<uint64_t> &,
unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteMDImportedEntity(const MDImportedEntity *,
const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("write not implemented");
}
static void WriteModuleMetadata(const Module *M,
const ValueEnumerator &VE,
BitstreamWriter &Stream) {

View File

@ -1347,6 +1347,93 @@ static void writeMDLocation(raw_ostream &Out, const MDLocation *DL,
Out << ")";
}
static void writeMDSubrange(raw_ostream &, const MDSubrange *, TypePrinting *,
SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDEnumerator(raw_ostream &, const MDEnumerator *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDBasicType(raw_ostream &, const MDBasicType *, TypePrinting *,
SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDDerivedType(raw_ostream &, const MDDerivedType *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDCompositeType(raw_ostream &, const MDCompositeType *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDSubroutineType(raw_ostream &, const MDSubroutineType *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDFile(raw_ostream &, const MDFile *, TypePrinting *,
SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDCompileUnit(raw_ostream &, const MDCompileUnit *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDSubprogram(raw_ostream &, const MDSubprogram *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDLexicalBlock(raw_ostream &, const MDLexicalBlock *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDLexicalBlockFile(raw_ostream &, const MDLexicalBlockFile *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDNamespace(raw_ostream &, const MDNamespace *, TypePrinting *,
SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDTemplateTypeParameter(raw_ostream &,
const MDTemplateTypeParameter *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDTemplateValueParameter(raw_ostream &,
const MDTemplateValueParameter *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDGlobalVariable(raw_ostream &, const MDGlobalVariable *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDLocalVariable(raw_ostream &, const MDLocalVariable *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDExpression(raw_ostream &, const MDExpression *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDObjCProperty(raw_ostream &, const MDObjCProperty *,
TypePrinting *, SlotTracker *, const Module *) {
llvm_unreachable("write not implemented");
}
static void writeMDImportedEntity(raw_ostream &, const MDImportedEntity *,
TypePrinting *, SlotTracker *,
const Module *) {
llvm_unreachable("write not implemented");
}
static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
TypePrinting *TypePrinter,
SlotTracker *Machine,

View File

@ -103,3 +103,274 @@ GenericDebugNode *GenericDebugNode::getImpl(LLVMContext &Context, unsigned Tag,
void GenericDebugNode::recalculateHash() {
setHash(GenericDebugNodeInfo::KeyTy::calculateHash(this));
}
#define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
#define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
do { \
if (Storage == Uniqued) { \
if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
return N; \
if (!ShouldCreate) \
return nullptr; \
} else { \
assert(ShouldCreate && \
"Expected non-uniqued nodes to always be created"); \
} \
} while (false)
#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
return storeImpl(new (ArrayRef<Metadata *>(OPS).size()) \
CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
Storage, Context.pImpl->CLASS##s)
#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
Storage, Context.pImpl->CLASS##s)
MDSubrange *MDSubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
StorageType Storage, bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(MDSubrange, (Count, Lo));
DEFINE_GETIMPL_STORE_NO_OPS(MDSubrange, (Count, Lo));
}
MDEnumerator *MDEnumerator::getImpl(LLVMContext &Context, int64_t Value,
MDString *Name, StorageType Storage,
bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDEnumerator, (Value, getString(Name)));
Metadata *Ops[] = {Name};
DEFINE_GETIMPL_STORE(MDEnumerator, (Value), Ops);
}
MDBasicType *MDBasicType::getImpl(LLVMContext &Context, unsigned Tag,
MDString *Name, unsigned SizeInBits,
unsigned AlignInBits, unsigned Encoding,
StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(
MDBasicType, (Tag, getString(Name), SizeInBits, AlignInBits, Encoding));
Metadata *Ops[] = {nullptr, nullptr, Name};
DEFINE_GETIMPL_STORE(MDBasicType, (Tag, SizeInBits, AlignInBits, Encoding),
Ops);
}
MDDerivedType *MDDerivedType::getImpl(
LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
unsigned Line, Metadata *Scope, Metadata *BaseType, unsigned SizeInBits,
unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
Metadata *ExtraData, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDDerivedType, (Tag, getString(Name), File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, ExtraData));
Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData};
DEFINE_GETIMPL_STORE(
MDDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags),
Ops);
}
MDCompositeType *MDCompositeType::getImpl(
LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
unsigned Line, Metadata *Scope, Metadata *BaseType, unsigned SizeInBits,
unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
Metadata *TemplateParams, MDString *Identifier, StorageType Storage,
bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDCompositeType,
(Tag, getString(Name), File, Line, Scope, BaseType,
SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,
RuntimeLang, VTableHolder, TemplateParams,
getString(Identifier)));
Metadata *Ops[] = {File, Scope, Name, BaseType,
Elements, VTableHolder, TemplateParams, Identifier};
DEFINE_GETIMPL_STORE(MDCompositeType, (Tag, Line, RuntimeLang, SizeInBits,
AlignInBits, OffsetInBits, Flags),
Ops);
}
MDSubroutineType *MDSubroutineType::getImpl(LLVMContext &Context,
unsigned Flags, Metadata *TypeArray,
StorageType Storage,
bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(MDSubroutineType, (Flags, TypeArray));
Metadata *Ops[] = {nullptr, nullptr, nullptr, nullptr,
TypeArray, nullptr, nullptr};
DEFINE_GETIMPL_STORE(MDSubroutineType, (Flags), Ops);
}
MDFile *MDFile::getImpl(LLVMContext &Context, MDString *Filename,
MDString *Directory, StorageType Storage,
bool ShouldCreate) {
assert(isCanonical(Filename) && "Expected canonical MDString");
assert(isCanonical(Directory) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDFile, (getString(Filename), getString(Directory)));
Metadata *NodeOps[] = {Filename, Directory};
Metadata *Ops[] = {MDTuple::get(Context, NodeOps)};
return storeImpl(new (ArrayRef<Metadata *>(Ops).size())
MDFile(Context, Storage, Ops),
Storage, Context.pImpl->MDFiles);
}
MDCompileUnit *MDCompileUnit::getImpl(
LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
MDString *Producer, bool IsOptimized, MDString *Flags,
unsigned RuntimeVersion, MDString *SplitDebugFilename,
unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
Metadata *Subprograms, Metadata *GlobalVariables,
Metadata *ImportedEntities, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Producer) && "Expected canonical MDString");
assert(isCanonical(Flags) && "Expected canonical MDString");
assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(
MDCompileUnit,
(SourceLanguage, File, getString(Producer), IsOptimized, getString(Flags),
RuntimeVersion, getString(SplitDebugFilename), EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables, ImportedEntities));
Metadata *Ops[] = {File, Producer, Flags, SplitDebugFilename, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities};
DEFINE_GETIMPL_STORE(
MDCompileUnit,
(SourceLanguage, IsOptimized, RuntimeVersion, EmissionKind), Ops);
}
MDSubprogram *MDSubprogram::getImpl(
LLVMContext &Context, Metadata *Scope, MDString *Name,
MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
unsigned Flags, bool IsOptimized, Metadata *Function,
Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
assert(isCanonical(LinkageName) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDSubprogram,
(Scope, getString(Name), getString(LinkageName), File,
Line, Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex, Flags,
IsOptimized, Function, TemplateParams, Declaration,
Variables));
Metadata *Ops[] = {File, Scope, Name, Name,
LinkageName, Type, ContainingType, Function,
TemplateParams, Declaration, Variables};
DEFINE_GETIMPL_STORE(MDSubprogram,
(Line, ScopeLine, Virtuality, VirtualIndex, Flags,
IsLocalToUnit, IsDefinition, IsOptimized),
Ops);
}
MDLexicalBlock *MDLexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
Metadata *File, unsigned Line,
unsigned Column, StorageType Storage,
bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(MDLexicalBlock, (Scope, File, Line, Column));
Metadata *Ops[] = {File, Scope};
DEFINE_GETIMPL_STORE(MDLexicalBlock, (Line, Column), Ops);
}
MDLexicalBlockFile *MDLexicalBlockFile::getImpl(LLVMContext &Context,
Metadata *Scope, Metadata *File,
unsigned Discriminator,
StorageType Storage,
bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(MDLexicalBlockFile, (Scope, File, Discriminator));
Metadata *Ops[] = {File, Scope};
DEFINE_GETIMPL_STORE(MDLexicalBlockFile, (Discriminator), Ops);
}
MDNamespace *MDNamespace::getImpl(LLVMContext &Context, Metadata *Scope,
Metadata *File, MDString *Name, unsigned Line,
StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDNamespace, (Scope, File, getString(Name), Line));
Metadata *Ops[] = {File, Scope, Name};
DEFINE_GETIMPL_STORE(MDNamespace, (Line), Ops);
}
MDTemplateTypeParameter *
MDTemplateTypeParameter::getImpl(LLVMContext &Context, Metadata *Scope,
MDString *Name, Metadata *Type, Metadata *File,
unsigned Line, unsigned Column,
StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDTemplateTypeParameter,
(Scope, getString(Name), Type, File, Line, Column));
Metadata *Ops[] = {File, Scope, Name, Type};
DEFINE_GETIMPL_STORE(MDTemplateTypeParameter, (Line, Column), Ops);
}
MDTemplateValueParameter *MDTemplateValueParameter::getImpl(
LLVMContext &Context, unsigned Tag, Metadata *Scope, MDString *Name,
Metadata *Type, Metadata *Value, Metadata *File, unsigned Line,
unsigned Column, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(
MDTemplateValueParameter,
(Tag, Scope, getString(Name), Type, Value, File, Line, Column));
Metadata *Ops[] = {File, Scope, Name, Type, Value};
DEFINE_GETIMPL_STORE(MDTemplateValueParameter, (Tag, Line, Column), Ops);
}
MDGlobalVariable *
MDGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
MDString *LinkageName, Metadata *File, unsigned Line,
Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
Metadata *Variable,
Metadata *StaticDataMemberDeclaration,
StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
assert(isCanonical(LinkageName) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDGlobalVariable,
(Scope, getString(Name), getString(LinkageName), File,
Line, Type, IsLocalToUnit, IsDefinition, Variable,
StaticDataMemberDeclaration));
Metadata *Ops[] = {Scope, Name, File, Type,
Name, LinkageName, Variable, StaticDataMemberDeclaration};
DEFINE_GETIMPL_STORE(MDGlobalVariable, (Line, IsLocalToUnit, IsDefinition),
Ops);
}
MDLocalVariable *MDLocalVariable::getImpl(
LLVMContext &Context, unsigned Tag, Metadata *Scope, MDString *Name,
Metadata *File, unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags,
Metadata *InlinedAt, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDLocalVariable, (Tag, Scope, getString(Name), File,
Line, Type, Arg, Flags, InlinedAt));
Metadata *Ops[] = {Scope, Name, File, Type, InlinedAt};
DEFINE_GETIMPL_STORE(MDLocalVariable, (Tag, Line, Arg, Flags), Ops);
}
MDExpression *MDExpression::getImpl(LLVMContext &Context,
ArrayRef<uint64_t> Elements,
StorageType Storage, bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(MDExpression, (Elements));
DEFINE_GETIMPL_STORE_NO_OPS(MDExpression, (Elements));
}
MDObjCProperty *MDObjCProperty::getImpl(
LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
MDString *GetterName, MDString *SetterName, unsigned Attributes,
Metadata *Type, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
assert(isCanonical(GetterName) && "Expected canonical MDString");
assert(isCanonical(SetterName) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDObjCProperty,
(getString(Name), File, Line, getString(GetterName),
getString(SetterName), Attributes, Type));
Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
DEFINE_GETIMPL_STORE(MDObjCProperty, (Line, Attributes), Ops);
}
MDImportedEntity *MDImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
Metadata *Scope, Metadata *Entity,
unsigned Line, MDString *Name,
StorageType Storage,
bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
DEFINE_GETIMPL_LOOKUP(MDImportedEntity,
(Tag, Scope, Entity, Line, getString(Name)));
Metadata *Ops[] = {Scope, Entity, Name};
DEFINE_GETIMPL_STORE(MDImportedEntity, (Tag, Line), Ops);
}

View File

@ -273,6 +273,581 @@ template <> struct MDNodeKeyImpl<GenericDebugNode> : MDNodeOpsKey {
}
};
template <> struct MDNodeKeyImpl<MDSubrange> {
int64_t Count;
int64_t Lo;
MDNodeKeyImpl(int64_t Count, int64_t Lo) : Count(Count), Lo(Lo) {}
MDNodeKeyImpl(const MDSubrange *N) : Count(N->getCount()), Lo(N->getLo()) {}
bool isKeyOf(const MDSubrange *RHS) const {
return Count == RHS->getCount() && Lo == RHS->getLo();
}
unsigned getHashValue() const { return hash_combine(Count, Lo); }
};
template <> struct MDNodeKeyImpl<MDEnumerator> {
int64_t Value;
StringRef Name;
MDNodeKeyImpl(int64_t Value, StringRef Name) : Value(Value), Name(Name) {}
MDNodeKeyImpl(const MDEnumerator *N)
: Value(N->getValue()), Name(N->getName()) {}
bool isKeyOf(const MDEnumerator *RHS) const {
return Value == RHS->getValue() && Name == RHS->getName();
}
unsigned getHashValue() const { return hash_combine(Value, Name); }
};
template <> struct MDNodeKeyImpl<MDBasicType> {
unsigned Tag;
StringRef Name;
unsigned SizeInBits;
unsigned AlignInBits;
unsigned Encoding;
MDNodeKeyImpl(unsigned Tag, StringRef Name, unsigned SizeInBits,
unsigned AlignInBits, unsigned Encoding)
: Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
Encoding(Encoding) {}
MDNodeKeyImpl(const MDBasicType *N)
: Tag(N->getTag()), Name(N->getName()), SizeInBits(N->getSizeInBits()),
AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
bool isKeyOf(const MDBasicType *RHS) const {
return Tag == RHS->getTag() && Name == RHS->getName() &&
SizeInBits == RHS->getSizeInBits() &&
AlignInBits == RHS->getAlignInBits() &&
Encoding == RHS->getEncoding();
}
unsigned getHashValue() const {
return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
}
};
template <> struct MDNodeKeyImpl<MDDerivedType> {
unsigned Tag;
StringRef Name;
Metadata *File;
unsigned Line;
Metadata *Scope;
Metadata *BaseType;
unsigned SizeInBits;
unsigned AlignInBits;
unsigned OffsetInBits;
unsigned Flags;
Metadata *ExtraData;
MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
Metadata *Scope, Metadata *BaseType, unsigned SizeInBits,
unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
Metadata *ExtraData)
: Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
OffsetInBits(OffsetInBits), Flags(Flags), ExtraData(ExtraData) {}
MDNodeKeyImpl(const MDDerivedType *N)
: Tag(N->getTag()), Name(N->getName()), File(N->getFile()),
Line(N->getLine()), Scope(N->getScope()), BaseType(N->getBaseType()),
SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()),
OffsetInBits(N->getOffsetInBits()), Flags(N->getFlags()),
ExtraData(N->getExtraData()) {}
bool isKeyOf(const MDDerivedType *RHS) const {
return Tag == RHS->getTag() && Name == RHS->getName() &&
File == RHS->getFile() && Line == RHS->getLine() &&
Scope == RHS->getScope() && BaseType == RHS->getBaseType() &&
SizeInBits == RHS->getSizeInBits() &&
AlignInBits == RHS->getAlignInBits() &&
OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
ExtraData == RHS->getExtraData();
}
unsigned getHashValue() const {
return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits, Flags, ExtraData);
}
};
template <> struct MDNodeKeyImpl<MDCompositeType> {
unsigned Tag;
StringRef Name;
Metadata *File;
unsigned Line;
Metadata *Scope;
Metadata *BaseType;
unsigned SizeInBits;
unsigned AlignInBits;
unsigned OffsetInBits;
unsigned Flags;
Metadata *Elements;
unsigned RuntimeLang;
Metadata *VTableHolder;
Metadata *TemplateParams;
StringRef Identifier;
MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
Metadata *Scope, Metadata *BaseType, unsigned SizeInBits,
unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
Metadata *Elements, unsigned RuntimeLang,
Metadata *VTableHolder, Metadata *TemplateParams,
StringRef Identifier)
: Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
OffsetInBits(OffsetInBits), Flags(Flags), Elements(Elements),
RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
TemplateParams(TemplateParams), Identifier(Identifier) {}
MDNodeKeyImpl(const MDCompositeType *N)
: Tag(N->getTag()), Name(N->getName()), File(N->getFile()),
Line(N->getLine()), Scope(N->getScope()), BaseType(N->getBaseType()),
SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()),
OffsetInBits(N->getOffsetInBits()), Flags(N->getFlags()),
Elements(N->getElements()), RuntimeLang(N->getRuntimeLang()),
VTableHolder(N->getVTableHolder()),
TemplateParams(N->getTemplateParams()), Identifier(N->getIdentifier()) {
}
bool isKeyOf(const MDCompositeType *RHS) const {
return Tag == RHS->getTag() && Name == RHS->getName() &&
File == RHS->getFile() && Line == RHS->getLine() &&
Scope == RHS->getScope() && BaseType == RHS->getBaseType() &&
SizeInBits == RHS->getSizeInBits() &&
AlignInBits == RHS->getAlignInBits() &&
OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
Elements == RHS->getElements() &&
RuntimeLang == RHS->getRuntimeLang() &&
VTableHolder == RHS->getVTableHolder() &&
TemplateParams == RHS->getTemplateParams() &&
Identifier == RHS->getIdentifier();
}
unsigned getHashValue() const {
return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier);
}
};
template <> struct MDNodeKeyImpl<MDSubroutineType> {
unsigned Flags;
Metadata *TypeArray;
MDNodeKeyImpl(int64_t Flags, Metadata *TypeArray)
: Flags(Flags), TypeArray(TypeArray) {}
MDNodeKeyImpl(const MDSubroutineType *N)
: Flags(N->getFlags()), TypeArray(N->getTypeArray()) {}
bool isKeyOf(const MDSubroutineType *RHS) const {
return Flags == RHS->getFlags() && TypeArray == RHS->getTypeArray();
}
unsigned getHashValue() const { return hash_combine(Flags, TypeArray); }
};
template <> struct MDNodeKeyImpl<MDFile> {
StringRef Filename;
StringRef Directory;
MDNodeKeyImpl(StringRef Filename, StringRef Directory)
: Filename(Filename), Directory(Directory) {}
MDNodeKeyImpl(const MDFile *N)
: Filename(N->getFilename()), Directory(N->getDirectory()) {}
bool isKeyOf(const MDFile *RHS) const {
return Filename == RHS->getFilename() && Directory == RHS->getDirectory();
}
unsigned getHashValue() const { return hash_combine(Filename, Directory); }
};
template <> struct MDNodeKeyImpl<MDCompileUnit> {
unsigned SourceLanguage;
Metadata *File;
StringRef Producer;
bool IsOptimized;
StringRef Flags;
unsigned RuntimeVersion;
StringRef SplitDebugFilename;
unsigned EmissionKind;
Metadata *EnumTypes;
Metadata *RetainedTypes;
Metadata *Subprograms;
Metadata *GlobalVariables;
Metadata *ImportedEntities;
MDNodeKeyImpl(unsigned SourceLanguage, Metadata *File, StringRef Producer,
bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
StringRef SplitDebugFilename, unsigned EmissionKind,
Metadata *EnumTypes, Metadata *RetainedTypes,
Metadata *Subprograms, Metadata *GlobalVariables,
Metadata *ImportedEntities)
: SourceLanguage(SourceLanguage), File(File), Producer(Producer),
IsOptimized(IsOptimized), Flags(Flags), RuntimeVersion(RuntimeVersion),
SplitDebugFilename(SplitDebugFilename), EmissionKind(EmissionKind),
EnumTypes(EnumTypes), RetainedTypes(RetainedTypes),
Subprograms(Subprograms), GlobalVariables(GlobalVariables),
ImportedEntities(ImportedEntities) {}
MDNodeKeyImpl(const MDCompileUnit *N)
: SourceLanguage(N->getSourceLanguage()), File(N->getFile()),
Producer(N->getProducer()), IsOptimized(N->isOptimized()),
Flags(N->getFlags()), RuntimeVersion(N->getRuntimeVersion()),
SplitDebugFilename(N->getSplitDebugFilename()),
EmissionKind(N->getEmissionKind()), EnumTypes(N->getEnumTypes()),
RetainedTypes(N->getRetainedTypes()), Subprograms(N->getSubprograms()),
GlobalVariables(N->getGlobalVariables()),
ImportedEntities(N->getImportedEntities()) {}
bool isKeyOf(const MDCompileUnit *RHS) const {
return SourceLanguage == RHS->getSourceLanguage() &&
File == RHS->getFile() && Producer == RHS->getProducer() &&
IsOptimized == RHS->isOptimized() && Flags == RHS->getFlags() &&
RuntimeVersion == RHS->getRuntimeVersion() &&
SplitDebugFilename == RHS->getSplitDebugFilename() &&
EmissionKind == RHS->getEmissionKind() &&
EnumTypes == RHS->getEnumTypes() &&
RetainedTypes == RHS->getRetainedTypes() &&
Subprograms == RHS->getSubprograms() &&
GlobalVariables == RHS->getGlobalVariables() &&
ImportedEntities == RHS->getImportedEntities();
}
unsigned getHashValue() const {
return hash_combine(SourceLanguage, File, Producer, IsOptimized, Flags,
RuntimeVersion, SplitDebugFilename, EmissionKind,
EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities);
}
};
template <> struct MDNodeKeyImpl<MDSubprogram> {
Metadata *Scope;
StringRef Name;
StringRef LinkageName;
Metadata *File;
unsigned Line;
Metadata *Type;
bool IsLocalToUnit;
bool IsDefinition;
unsigned ScopeLine;
Metadata *ContainingType;
unsigned Virtuality;
unsigned VirtualIndex;
unsigned Flags;
bool IsOptimized;
Metadata *Function;
Metadata *TemplateParams;
Metadata *Declaration;
Metadata *Variables;
MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName,
Metadata *File, unsigned Line, Metadata *Type,
bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
Metadata *ContainingType, unsigned Virtuality,
unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
Metadata *Function, Metadata *TemplateParams,
Metadata *Declaration, Metadata *Variables)
: Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
IsDefinition(IsDefinition), ScopeLine(ScopeLine),
ContainingType(ContainingType), Virtuality(Virtuality),
VirtualIndex(VirtualIndex), Flags(Flags), IsOptimized(IsOptimized),
Function(Function), TemplateParams(TemplateParams),
Declaration(Declaration), Variables(Variables) {}
MDNodeKeyImpl(const MDSubprogram *N)
: Scope(N->getScope()), Name(N->getName()),
LinkageName(N->getLinkageName()), File(N->getFile()),
Line(N->getLine()), Type(N->getType()),
IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
ScopeLine(N->getScopeLine()), ContainingType(N->getContainingType()),
Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
Flags(N->getFlags()), IsOptimized(N->isOptimized()),
Function(N->getFunction()), TemplateParams(N->getTemplateParams()),
Declaration(N->getDeclaration()), Variables(N->getVariables()) {}
bool isKeyOf(const MDSubprogram *RHS) const {
return Scope == RHS->getScope() && Name == RHS->getName() &&
LinkageName == RHS->getLinkageName() && File == RHS->getFile() &&
Line == RHS->getLine() && Type == RHS->getType() &&
IsLocalToUnit == RHS->isLocalToUnit() &&
IsDefinition == RHS->isDefinition() &&
ScopeLine == RHS->getScopeLine() &&
ContainingType == RHS->getContainingType() &&
Virtuality == RHS->getVirtuality() &&
VirtualIndex == RHS->getVirtualIndex() && Flags == RHS->getFlags() &&
IsOptimized == RHS->isOptimized() &&
Function == RHS->getFunction() &&
TemplateParams == RHS->getTemplateParams() &&
Declaration == RHS->getDeclaration() &&
Variables == RHS->getVariables();
}
unsigned getHashValue() const {
return hash_combine(Scope, Name, LinkageName, File, Line, Type,
IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
Virtuality, VirtualIndex, Flags, IsOptimized, Function,
TemplateParams, Declaration, Variables);
}
};
template <> struct MDNodeKeyImpl<MDLexicalBlock> {
Metadata *Scope;
Metadata *File;
unsigned Line;
unsigned Column;
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
: Scope(Scope), File(File), Line(Line), Column(Column) {}
MDNodeKeyImpl(const MDLexicalBlock *N)
: Scope(N->getScope()), File(N->getFile()), Line(N->getLine()),
Column(N->getColumn()) {}
bool isKeyOf(const MDLexicalBlock *RHS) const {
return Scope == RHS->getScope() && File == RHS->getFile() &&
Line == RHS->getLine() && Column == RHS->getColumn();
}
unsigned getHashValue() const {
return hash_combine(Scope, File, Line, Column);
}
};
template <> struct MDNodeKeyImpl<MDLexicalBlockFile> {
Metadata *Scope;
Metadata *File;
unsigned Discriminator;
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
: Scope(Scope), File(File), Discriminator(Discriminator) {}
MDNodeKeyImpl(const MDLexicalBlockFile *N)
: Scope(N->getScope()), File(N->getFile()),
Discriminator(N->getDiscriminator()) {}
bool isKeyOf(const MDLexicalBlockFile *RHS) const {
return Scope == RHS->getScope() && File == RHS->getFile() &&
Discriminator == RHS->getDiscriminator();
}
unsigned getHashValue() const {
return hash_combine(Scope, File, Discriminator);
}
};
template <> struct MDNodeKeyImpl<MDNamespace> {
Metadata *Scope;
Metadata *File;
StringRef Name;
unsigned Line;
MDNodeKeyImpl(Metadata *Scope, Metadata *File, StringRef Name, unsigned Line)
: Scope(Scope), File(File), Name(Name), Line(Line) {}
MDNodeKeyImpl(const MDNamespace *N)
: Scope(N->getScope()), File(N->getFile()), Name(N->getName()),
Line(N->getLine()) {}
bool isKeyOf(const MDNamespace *RHS) const {
return Scope == RHS->getScope() && File == RHS->getFile() &&
Name == RHS->getName() && Line == RHS->getLine();
}
unsigned getHashValue() const {
return hash_combine(Scope, File, Name, Line);
}
};
template <> struct MDNodeKeyImpl<MDTemplateTypeParameter> {
Metadata *Scope;
StringRef Name;
Metadata *Type;
Metadata *File;
unsigned Line;
unsigned Column;
MDNodeKeyImpl(Metadata *Scope, StringRef Name, Metadata *Type, Metadata *File,
unsigned Line, unsigned Column)
: Scope(Scope), Name(Name), Type(Type), File(File), Line(Line),
Column(Column) {}
MDNodeKeyImpl(const MDTemplateTypeParameter *N)
: Scope(N->getScope()), Name(N->getName()), Type(N->getType()),
File(N->getFile()), Line(N->getLine()), Column(N->getColumn()) {}
bool isKeyOf(const MDTemplateTypeParameter *RHS) const {
return Scope == RHS->getScope() && Name == RHS->getName() &&
Type == RHS->getType() && File == RHS->getFile() &&
Line == RHS->getLine() && Column == RHS->getColumn();
}
unsigned getHashValue() const {
return hash_combine(Scope, Name, Type, File, Line, Column);
}
};
template <> struct MDNodeKeyImpl<MDTemplateValueParameter> {
unsigned Tag;
Metadata *Scope;
StringRef Name;
Metadata *Type;
Metadata *Value;
Metadata *File;
unsigned Line;
unsigned Column;
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, StringRef Name, Metadata *Type,
Metadata *Value, Metadata *File, unsigned Line, unsigned Column)
: Tag(Tag), Scope(Scope), Name(Name), Type(Type), Value(Value),
File(File), Line(Line), Column(Column) {}
MDNodeKeyImpl(const MDTemplateValueParameter *N)
: Tag(N->getTag()), Scope(N->getScope()), Name(N->getName()),
Type(N->getType()), Value(N->getValue()), File(N->getFile()),
Line(N->getLine()), Column(N->getColumn()) {}
bool isKeyOf(const MDTemplateValueParameter *RHS) const {
return Tag == RHS->getTag() && Scope == RHS->getScope() &&
Name == RHS->getName() && Type == RHS->getType() &&
Value == RHS->getValue() && File == RHS->getFile() &&
Line == RHS->getLine() && Column == RHS->getColumn();
}
unsigned getHashValue() const {
return hash_combine(Tag, Scope, Name, Type, Value, File, Line, Column);
}
};
template <> struct MDNodeKeyImpl<MDGlobalVariable> {
Metadata *Scope;
StringRef Name;
StringRef LinkageName;
Metadata *File;
unsigned Line;
Metadata *Type;
bool IsLocalToUnit;
bool IsDefinition;
Metadata *Variable;
Metadata *StaticDataMemberDeclaration;
MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName,
Metadata *File, unsigned Line, Metadata *Type,
bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
Metadata *StaticDataMemberDeclaration)
: Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
IsDefinition(IsDefinition), Variable(Variable),
StaticDataMemberDeclaration(StaticDataMemberDeclaration) {}
MDNodeKeyImpl(const MDGlobalVariable *N)
: Scope(N->getScope()), Name(N->getName()),
LinkageName(N->getLinkageName()), File(N->getFile()),
Line(N->getLine()), Type(N->getType()),
IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
Variable(N->getVariable()),
StaticDataMemberDeclaration(N->getStaticDataMemberDeclaration()) {}
bool isKeyOf(const MDGlobalVariable *RHS) const {
return Scope == RHS->getScope() && Name == RHS->getName() &&
LinkageName == RHS->getLinkageName() && File == RHS->getFile() &&
Line == RHS->getLine() && Type == RHS->getType() &&
IsLocalToUnit == RHS->isLocalToUnit() &&
IsDefinition == RHS->isDefinition() &&
Variable == RHS->getVariable() &&
StaticDataMemberDeclaration == RHS->getStaticDataMemberDeclaration();
}
unsigned getHashValue() const {
return hash_combine(Scope, Name, LinkageName, File, Line, Type,
IsLocalToUnit, IsDefinition, Variable,
StaticDataMemberDeclaration);
}
};
template <> struct MDNodeKeyImpl<MDLocalVariable> {
unsigned Tag;
Metadata *Scope;
StringRef Name;
Metadata *File;
unsigned Line;
Metadata *Type;
unsigned Arg;
unsigned Flags;
Metadata *InlinedAt;
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, StringRef Name, Metadata *File,
unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags,
Metadata *InlinedAt)
: Tag(Tag), Scope(Scope), Name(Name), File(File), Line(Line), Type(Type),
Arg(Arg), Flags(Flags), InlinedAt(InlinedAt) {}
MDNodeKeyImpl(const MDLocalVariable *N)
: Tag(N->getTag()), Scope(N->getScope()), Name(N->getName()),
File(N->getFile()), Line(N->getLine()), Type(N->getType()),
Arg(N->getArg()), Flags(N->getFlags()), InlinedAt(N->getInlinedAt()) {}
bool isKeyOf(const MDLocalVariable *RHS) const {
return Tag == RHS->getTag() && Scope == RHS->getScope() &&
Name == RHS->getName() && File == RHS->getFile() &&
Line == RHS->getLine() && Type == RHS->getType() &&
Arg == RHS->getArg() && Flags == RHS->getFlags() &&
InlinedAt == RHS->getInlinedAt();
}
unsigned getHashValue() const {
return hash_combine(Tag, Scope, Name, File, Line, Type, Arg, Flags,
InlinedAt);
}
};
template <> struct MDNodeKeyImpl<MDExpression> {
ArrayRef<uint64_t> Elements;
MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
MDNodeKeyImpl(const MDExpression *N) : Elements(N->getElements()) {}
bool isKeyOf(const MDExpression *RHS) const {
return Elements == RHS->getElements();
}
unsigned getHashValue() const {
return hash_combine_range(Elements.begin(), Elements.end());
}
};
template <> struct MDNodeKeyImpl<MDObjCProperty> {
StringRef Name;
Metadata *File;
unsigned Line;
StringRef GetterName;
StringRef SetterName;
unsigned Attributes;
Metadata *Type;
MDNodeKeyImpl(StringRef Name, Metadata *File, unsigned Line,
StringRef GetterName, StringRef SetterName, unsigned Attributes,
Metadata *Type)
: Name(Name), File(File), Line(Line), GetterName(GetterName),
SetterName(SetterName), Attributes(Attributes), Type(Type) {}
MDNodeKeyImpl(const MDObjCProperty *N)
: Name(N->getName()), File(N->getFile()), Line(N->getLine()),
GetterName(N->getGetterName()), SetterName(N->getSetterName()),
Attributes(N->getAttributes()), Type(N->getType()) {}
bool isKeyOf(const MDObjCProperty *RHS) const {
return Name == RHS->getName() && File == RHS->getFile() &&
Line == RHS->getLine() && GetterName == RHS->getGetterName() &&
SetterName == RHS->getSetterName() &&
Attributes == RHS->getAttributes() && Type == RHS->getType();
}
unsigned getHashValue() const {
return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
Type);
}
};
template <> struct MDNodeKeyImpl<MDImportedEntity> {
unsigned Tag;
Metadata *Scope;
Metadata *Entity;
unsigned Line;
StringRef Name;
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line,
StringRef Name)
: Tag(Tag), Scope(Scope), Entity(Entity), Line(Line), Name(Name) {}
MDNodeKeyImpl(const MDImportedEntity *N)
: Tag(N->getTag()), Scope(N->getScope()), Entity(N->getEntity()),
Line(N->getLine()), Name(N->getName()) {}
bool isKeyOf(const MDImportedEntity *RHS) const {
return Tag == RHS->getTag() && Scope == RHS->getScope() &&
Entity == RHS->getEntity() && Line == RHS->getLine() &&
Name == RHS->getName();
}
unsigned getHashValue() const {
return hash_combine(Tag, Scope, Entity, Line, Name);
}
};
/// \brief DenseMapInfo for MDNode subclasses.
template <class NodeTy> struct MDNodeInfo {
typedef MDNodeKeyImpl<NodeTy> KeyTy;

View File

@ -614,6 +614,853 @@ TEST_F(GenericDebugNodeTest, getEmptyHeader) {
EXPECT_EQ(nullptr, N->getOperand(0));
}
typedef MetadataTest MDSubrangeTest;
TEST_F(MDSubrangeTest, get) {
auto *N = MDSubrange::get(Context, 5, 7);
EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
EXPECT_EQ(5, N->getCount());
EXPECT_EQ(7, N->getLo());
EXPECT_EQ(N, MDSubrange::get(Context, 5, 7));
EXPECT_EQ(MDSubrange::get(Context, 5, 0), MDSubrange::get(Context, 5));
}
typedef MetadataTest MDEnumeratorTest;
TEST_F(MDEnumeratorTest, get) {
auto *N = MDEnumerator::get(Context, 7, "name");
EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
EXPECT_EQ(7, N->getValue());
EXPECT_EQ("name", N->getName());
EXPECT_EQ(N, MDEnumerator::get(Context, 7, "name"));
EXPECT_NE(N, MDEnumerator::get(Context, 8, "name"));
EXPECT_NE(N, MDEnumerator::get(Context, 7, "nam"));
}
typedef MetadataTest MDBasicTypeTest;
TEST_F(MDBasicTypeTest, get) {
auto *N =
MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7);
EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
EXPECT_EQ("special", N->getName());
EXPECT_EQ(33u, N->getSizeInBits());
EXPECT_EQ(26u, N->getAlignInBits());
EXPECT_EQ(7u, N->getEncoding());
EXPECT_EQ(0u, N->getLine());
EXPECT_EQ(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
26, 7));
EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
"special", 33, 26, 7));
EXPECT_NE(N,
MDBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7));
EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
26, 7));
EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
25, 7));
EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
26, 6));
}
typedef MetadataTest MDDerivedTypeTest;
TEST_F(MDDerivedTypeTest, get) {
Metadata *File = MDTuple::getDistinct(Context, None);
Metadata *Scope = MDTuple::getDistinct(Context, None);
Metadata *BaseType = MDTuple::getDistinct(Context, None);
Metadata *ExtraData = MDTuple::getDistinct(Context, None);
auto *N = MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
File, 1, Scope, BaseType, 2, 3, 4, 5, ExtraData);
EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());
EXPECT_EQ("something", N->getName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(1u, N->getLine());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(BaseType, N->getBaseType());
EXPECT_EQ(2u, N->getSizeInBits());
EXPECT_EQ(3u, N->getAlignInBits());
EXPECT_EQ(4u, N->getOffsetInBits());
EXPECT_EQ(5u, N->getFlags());
EXPECT_EQ(ExtraData, N->getExtraData());
EXPECT_EQ(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", File, 1, Scope, BaseType, 2, 3,
4, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_reference_type,
"something", File, 1, Scope, BaseType, 2, 3,
4, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",
File, 1, Scope, BaseType, 2, 3, 4, 5,
ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", Scope, 1, Scope, BaseType, 2, 3,
4, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", File, 2, Scope, BaseType, 2, 3,
4, 5, ExtraData));
EXPECT_NE(N,
MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
File, 1, File, BaseType, 2, 3, 4, 5, ExtraData));
EXPECT_NE(N,
MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
File, 1, Scope, File, 2, 3, 4, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", File, 1, Scope, BaseType, 3, 3,
4, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", File, 1, Scope, BaseType, 2, 2,
4, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", File, 1, Scope, BaseType, 2, 3,
5, 5, ExtraData));
EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
"something", File, 1, Scope, BaseType, 2, 3,
4, 4, ExtraData));
EXPECT_NE(N,
MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
File, 1, Scope, BaseType, 2, 3, 4, 5, File));
}
typedef MetadataTest MDCompositeTypeTest;
TEST_F(MDCompositeTypeTest, get) {
unsigned Tag = dwarf::DW_TAG_structure_type;
StringRef Name = "some name";
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 1;
Metadata *Scope = MDTuple::getDistinct(Context, None);
Metadata *BaseType = MDTuple::getDistinct(Context, None);
unsigned SizeInBits = 2;
unsigned AlignInBits = 3;
unsigned OffsetInBits = 4;
unsigned Flags = 5;
Metadata *Elements = MDTuple::getDistinct(Context, None);
unsigned RuntimeLang = 6;
Metadata *VTableHolder = MDTuple::getDistinct(Context, None);
Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
StringRef Identifier = "some id";
auto *N = MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier);
EXPECT_EQ(Tag, N->getTag());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(BaseType, N->getBaseType());
EXPECT_EQ(SizeInBits, N->getSizeInBits());
EXPECT_EQ(AlignInBits, N->getAlignInBits());
EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
EXPECT_EQ(Flags, N->getFlags());
EXPECT_EQ(Elements, N->getElements());
EXPECT_EQ(RuntimeLang, N->getRuntimeLang());
EXPECT_EQ(VTableHolder, N->getVTableHolder());
EXPECT_EQ(TemplateParams, N->getTemplateParams());
EXPECT_EQ(Identifier, N->getIdentifier());
EXPECT_EQ(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag + 1, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, "abc", File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, Scope, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line + 1, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, File,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope, File,
SizeInBits, AlignInBits, OffsetInBits,
Flags, Elements, RuntimeLang, VTableHolder,
TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits + 1, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits + 1,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits + 1, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits, Flags + 1, Elements, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, File, RuntimeLang,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang + 1,
VTableHolder, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
File, TemplateParams, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, File, Identifier));
EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
BaseType, SizeInBits, AlignInBits,
OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, "other"));
// Be sure that missing identifiers get null pointers.
EXPECT_FALSE(MDCompositeType::get(
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams, "")->getRawIdentifier());
EXPECT_FALSE(MDCompositeType::get(
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
VTableHolder, TemplateParams)->getRawIdentifier());
}
typedef MetadataTest MDSubroutineTypeTest;
TEST_F(MDSubroutineTypeTest, get) {
unsigned Flags = 1;
Metadata *TypeArray = MDTuple::getDistinct(Context, None);
auto *N = MDSubroutineType::get(Context, Flags, TypeArray);
EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());
EXPECT_EQ(Flags, N->getFlags());
EXPECT_EQ(TypeArray, N->getTypeArray());
EXPECT_EQ(N, MDSubroutineType::get(Context, Flags, TypeArray));
EXPECT_NE(N, MDSubroutineType::get(Context, Flags + 1, TypeArray));
EXPECT_NE(N, MDSubroutineType::get(Context, Flags,
MDTuple::getDistinct(Context, None)));
}
typedef MetadataTest MDFileTest;
TEST_F(MDFileTest, get) {
StringRef Filename = "file";
StringRef Directory = "dir";
auto *N = MDFile::get(Context, Filename, Directory);
EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
EXPECT_EQ(Filename, N->getFilename());
EXPECT_EQ(Directory, N->getDirectory());
EXPECT_EQ(N, MDFile::get(Context, Filename, Directory));
EXPECT_NE(N, MDFile::get(Context, "other", Directory));
EXPECT_NE(N, MDFile::get(Context, Filename, "other"));
}
typedef MetadataTest MDCompileUnitTest;
TEST_F(MDCompileUnitTest, get) {
unsigned SourceLanguage = 1;
Metadata *File = MDTuple::getDistinct(Context, None);
StringRef Producer = "some producer";
bool IsOptimized = false;
StringRef Flags = "flag after flag";
unsigned RuntimeVersion = 2;
StringRef SplitDebugFilename = "another/file";
unsigned EmissionKind = 3;
Metadata *EnumTypes = MDTuple::getDistinct(Context, None);
Metadata *RetainedTypes = MDTuple::getDistinct(Context, None);
Metadata *Subprograms = MDTuple::getDistinct(Context, None);
Metadata *GlobalVariables = MDTuple::getDistinct(Context, None);
Metadata *ImportedEntities = MDTuple::getDistinct(Context, None);
auto *N = MDCompileUnit::get(
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables, ImportedEntities);
EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Producer, N->getProducer());
EXPECT_EQ(IsOptimized, N->isOptimized());
EXPECT_EQ(Flags, N->getFlags());
EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
EXPECT_EQ(EmissionKind, N->getEmissionKind());
EXPECT_EQ(EnumTypes, N->getEnumTypes());
EXPECT_EQ(RetainedTypes, N->getRetainedTypes());
EXPECT_EQ(Subprograms, N->getSubprograms());
EXPECT_EQ(GlobalVariables, N->getGlobalVariables());
EXPECT_EQ(ImportedEntities, N->getImportedEntities());
EXPECT_EQ(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage + 1, File, Producer,
IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, EnumTypes, Producer,
IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, "other",
IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
!IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
IsOptimized, "other", RuntimeVersion,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
IsOptimized, Flags, RuntimeVersion + 1,
SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N,
MDCompileUnit::get(Context, SourceLanguage, File, Producer,
IsOptimized, Flags, RuntimeVersion, "other",
EmissionKind, EnumTypes, RetainedTypes,
Subprograms, GlobalVariables, ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind + 1,
EnumTypes, RetainedTypes, Subprograms,
GlobalVariables, ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
IsOptimized, Flags, RuntimeVersion,
SplitDebugFilename, EmissionKind, File,
RetainedTypes, Subprograms, GlobalVariables,
ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
File, Subprograms, GlobalVariables, ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, File, GlobalVariables, ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, File, ImportedEntities));
EXPECT_NE(N, MDCompileUnit::get(
Context, SourceLanguage, File, Producer, IsOptimized, Flags,
RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
RetainedTypes, Subprograms, GlobalVariables, File));
}
typedef MetadataTest MDSubprogramTest;
TEST_F(MDSubprogramTest, get) {
Metadata *Scope = MDTuple::getDistinct(Context, None);
StringRef Name = "name";
StringRef LinkageName = "linkage";
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 2;
Metadata *Type = MDTuple::getDistinct(Context, None);
bool IsLocalToUnit = false;
bool IsDefinition = true;
unsigned ScopeLine = 3;
Metadata *ContainingType = MDTuple::getDistinct(Context, None);
unsigned Virtuality = 4;
unsigned VirtualIndex = 5;
unsigned Flags = 6;
bool IsOptimized = false;
Metadata *Function = MDTuple::getDistinct(Context, None);
Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
Metadata *Declaration = MDTuple::getDistinct(Context, None);
Metadata *Variables = MDTuple::getDistinct(Context, None);
auto *N = MDSubprogram::get(
Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
IsOptimized, Function, TemplateParams, Declaration, Variables);
EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(LinkageName, N->getLinkageName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Type, N->getType());
EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
EXPECT_EQ(IsDefinition, N->isDefinition());
EXPECT_EQ(ScopeLine, N->getScopeLine());
EXPECT_EQ(ContainingType, N->getContainingType());
EXPECT_EQ(Virtuality, N->getVirtuality());
EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
EXPECT_EQ(Flags, N->getFlags());
EXPECT_EQ(IsOptimized, N->isOptimized());
EXPECT_EQ(Function, N->getFunction());
EXPECT_EQ(TemplateParams, N->getTemplateParams());
EXPECT_EQ(Declaration, N->getDeclaration());
EXPECT_EQ(Variables, N->getVariables());
EXPECT_EQ(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, File, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, "other", LinkageName, File,
Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality,
VirtualIndex, Flags, IsOptimized, Function,
TemplateParams, Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, "other", File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, Scope, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File,
Line + 1, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality,
VirtualIndex, Flags, IsOptimized, Function,
TemplateParams, Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Scope, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, !IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, !IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition,
ScopeLine + 1, ContainingType, Virtuality,
VirtualIndex, Flags, IsOptimized, Function,
TemplateParams, Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
Type, Virtuality, VirtualIndex, Flags,
IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality + 1, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex + 1,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
~Flags, IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, !IsOptimized, Function, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Type, TemplateParams,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, Type,
Declaration, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Type, Variables));
EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, ScopeLine,
ContainingType, Virtuality, VirtualIndex,
Flags, IsOptimized, Function, TemplateParams,
Declaration, Type));
}
typedef MetadataTest MDLexicalBlockTest;
TEST_F(MDLexicalBlockTest, get) {
Metadata *Scope = MDTuple::getDistinct(Context, None);
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
unsigned Column = 8;
auto *N = MDLexicalBlock::get(Context, Scope, File, Line, Column);
EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Column, N->getColumn());
EXPECT_EQ(N, MDLexicalBlock::get(Context, Scope, File, Line, Column));
EXPECT_NE(N, MDLexicalBlock::get(Context, File, File, Line, Column));
EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, Scope, Line, Column));
EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, File, Line + 1, Column));
EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, File, Line, Column + 1));
}
typedef MetadataTest MDLexicalBlockFileTest;
TEST_F(MDLexicalBlockFileTest, get) {
Metadata *Scope = MDTuple::getDistinct(Context, None);
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Discriminator = 5;
auto *N = MDLexicalBlockFile::get(Context, Scope, File, Discriminator);
EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Discriminator, N->getDiscriminator());
EXPECT_EQ(N, MDLexicalBlockFile::get(Context, Scope, File, Discriminator));
EXPECT_NE(N, MDLexicalBlockFile::get(Context, File, File, Discriminator));
EXPECT_NE(N, MDLexicalBlockFile::get(Context, Scope, Scope, Discriminator));
EXPECT_NE(N,
MDLexicalBlockFile::get(Context, Scope, File, Discriminator + 1));
}
typedef MetadataTest MDNamespaceTest;
TEST_F(MDNamespaceTest, get) {
Metadata *Scope = MDTuple::getDistinct(Context, None);
Metadata *File = MDTuple::getDistinct(Context, None);
StringRef Name = "namespace";
unsigned Line = 5;
auto *N = MDNamespace::get(Context, Scope, File, Name, Line);
EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(N, MDNamespace::get(Context, Scope, File, Name, Line));
EXPECT_NE(N, MDNamespace::get(Context, File, File, Name, Line));
EXPECT_NE(N, MDNamespace::get(Context, Scope, Scope, Name, Line));
EXPECT_NE(N, MDNamespace::get(Context, Scope, File, "other", Line));
EXPECT_NE(N, MDNamespace::get(Context, Scope, File, Name, Line + 1));
}
typedef MetadataTest MDTemplateTypeParameterTest;
TEST_F(MDTemplateTypeParameterTest, get) {
Metadata *Scope = MDTuple::getDistinct(Context, None);
StringRef Name = "template";
Metadata *Type = MDTuple::getDistinct(Context, None);
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
unsigned Column = 7;
auto *N = MDTemplateTypeParameter::get(Context, Scope, Name, Type, File, Line,
Column);
EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(Type, N->getType());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Column, N->getColumn());
EXPECT_EQ(N, MDTemplateTypeParameter::get(Context, Scope, Name, Type, File,
Line, Column));
EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Type, Name, Type, File,
Line, Column));
EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, "other", Type, File,
Line, Column));
EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, Name, Scope, File,
Line, Column));
EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, Name, Type, Scope,
Line, Column));
EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, Name, Type, File,
Line + 1, Column));
EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, Name, Type, File,
Line, Column + 1));
}
typedef MetadataTest MDTemplateValueParameterTest;
TEST_F(MDTemplateValueParameterTest, get) {
unsigned Tag = dwarf::DW_TAG_template_value_parameter;
Metadata *Scope = MDTuple::getDistinct(Context, None);
StringRef Name = "template";
Metadata *Type = MDTuple::getDistinct(Context, None);
Metadata *Value = MDTuple::getDistinct(Context, None);
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
unsigned Column = 7;
auto *N = MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type,
Value, File, Line, Column);
EXPECT_EQ(Tag, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(Type, N->getType());
EXPECT_EQ(Value, N->getValue());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Column, N->getColumn());
EXPECT_EQ(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type,
Value, File, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(
Context, dwarf::DW_TAG_GNU_template_template_param, Scope,
Name, Type, Value, File, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Type, Name, Type,
Value, File, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, "other", Type,
Value, File, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Scope,
Value, File, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type,
Scope, File, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type,
Value, Scope, Line, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type,
Value, File, Line + 1, Column));
EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type,
Value, File, Line, Column + 1));
}
typedef MetadataTest MDGlobalVariableTest;
TEST_F(MDGlobalVariableTest, get) {
Metadata *Scope = MDTuple::getDistinct(Context, None);
StringRef Name = "name";
StringRef LinkageName = "linkage";
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
Metadata *Type = MDTuple::getDistinct(Context, None);
bool IsLocalToUnit = false;
bool IsDefinition = true;
Metadata *Variable = MDTuple::getDistinct(Context, None);
Metadata *StaticDataMemberDeclaration = MDTuple::getDistinct(Context, None);
auto *N = MDGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
Type, IsLocalToUnit, IsDefinition, Variable,
StaticDataMemberDeclaration);
EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(LinkageName, N->getLinkageName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Type, N->getType());
EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
EXPECT_EQ(IsDefinition, N->isDefinition());
EXPECT_EQ(Variable, N->getVariable());
EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
EXPECT_EQ(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line, Type, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, File, Name, LinkageName, File,
Line, Type, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, "other", LinkageName, File,
Line, Type, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, "other", File, Line,
Type, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, Scope,
Line, Type, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N,
MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line + 1, Type, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line, Scope, IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line, Type, !IsLocalToUnit, IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line, Type, IsLocalToUnit, !IsDefinition,
Variable, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line, Type, IsLocalToUnit, IsDefinition,
Type, StaticDataMemberDeclaration));
EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
Line, Type, IsLocalToUnit, IsDefinition,
Variable, Type));
}
typedef MetadataTest MDLocalVariableTest;
TEST_F(MDLocalVariableTest, get) {
unsigned Tag = dwarf::DW_TAG_arg_variable;
Metadata *Scope = MDTuple::getDistinct(Context, None);
StringRef Name = "name";
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
Metadata *Type = MDTuple::getDistinct(Context, None);
unsigned Arg = 6;
unsigned Flags = 7;
Metadata *InlinedAt = MDTuple::getDistinct(Context, None);
auto *N = MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
Arg, Flags, InlinedAt);
EXPECT_EQ(Tag, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Type, N->getType());
EXPECT_EQ(Arg, N->getArg());
EXPECT_EQ(Flags, N->getFlags());
EXPECT_EQ(InlinedAt, N->getInlinedAt());
EXPECT_EQ(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
Arg, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, dwarf::DW_TAG_auto_variable, Scope,
Name, File, Line, Type, Arg, Flags,
InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, File, Name, File, Line,
Type, Arg, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, "other", File, Line,
Type, Arg, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, Scope, Line,
Type, Arg, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line + 1,
Type, Arg, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line,
Scope, Arg, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
Arg + 1, Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
Arg, ~Flags, InlinedAt));
EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
Arg, Flags, Scope));
}
typedef MetadataTest MDExpressionTest;
TEST_F(MDExpressionTest, get) {
uint64_t Elements[] = {2, 6, 9, 78, 0};
auto *N = MDExpression::get(Context, Elements);
EXPECT_EQ(makeArrayRef(Elements), N->getElements());
EXPECT_EQ(N, MDExpression::get(Context, Elements));
}
typedef MetadataTest MDObjCPropertyTest;
TEST_F(MDObjCPropertyTest, get) {
StringRef Name = "name";
Metadata *File = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
StringRef GetterName = "getter";
StringRef SetterName = "setter";
unsigned Attributes = 7;
Metadata *Type = MDTuple::getDistinct(Context, None);
auto *N = MDObjCProperty::get(Context, Name, File, Line, GetterName,
SetterName, Attributes, Type);
EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(File, N->getFile());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(GetterName, N->getGetterName());
EXPECT_EQ(SetterName, N->getSetterName());
EXPECT_EQ(Attributes, N->getAttributes());
EXPECT_EQ(Type, N->getType());
EXPECT_EQ(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
SetterName, Attributes, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, "other", File, Line, GetterName,
SetterName, Attributes, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, Name, Type, Line, GetterName,
SetterName, Attributes, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line + 1, GetterName,
SetterName, Attributes, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, "other",
SetterName, Attributes, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
"other", Attributes, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
SetterName, Attributes + 1, Type));
EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
SetterName, Attributes, File));
}
typedef MetadataTest MDImportedEntityTest;
TEST_F(MDImportedEntityTest, get) {
unsigned Tag = dwarf::DW_TAG_imported_module;
Metadata *Scope = MDTuple::getDistinct(Context, None);
Metadata *Entity = MDTuple::getDistinct(Context, None);
unsigned Line = 5;
StringRef Name = "name";
auto *N = MDImportedEntity::get(Context, Tag, Scope, Entity, Line, Name);
EXPECT_EQ(Tag, N->getTag());
EXPECT_EQ(Scope, N->getScope());
EXPECT_EQ(Entity, N->getEntity());
EXPECT_EQ(Line, N->getLine());
EXPECT_EQ(Name, N->getName());
EXPECT_EQ(N, MDImportedEntity::get(Context, Tag, Scope, Entity, Line, Name));
EXPECT_NE(N,
MDImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,
Scope, Entity, Line, Name));
EXPECT_NE(N, MDImportedEntity::get(Context, Tag, Entity, Entity, Line, Name));
EXPECT_NE(N, MDImportedEntity::get(Context, Tag, Scope, Scope, Line, Name));
EXPECT_NE(N,
MDImportedEntity::get(Context, Tag, Scope, Entity, Line + 1, Name));
EXPECT_NE(N,
MDImportedEntity::get(Context, Tag, Scope, Entity, Line, "other"));
}
typedef MetadataTest MetadataAsValueTest;
TEST_F(MetadataAsValueTest, MDNode) {