6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-10-31 08:16:47 +00:00
Code Issues Projects Releases Wiki Activity

IR: DwarfNode => DebugNode, NFC

Browse Source 
These things are potentially used for non-DWARF data (see the discussion
in PR22235), so take the `Dwarf` out of the name.  Since the new name
gives fewer clues, update the doxygen to properly describe what they
are.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226874 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan P. N. Exon Smith
2015-01-22 22:47:44 +00:00
parent 316b43f7df
commit cee1699e9f
7 changed files with 62 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/IR/Metadata.def
View File

@@ -49,8 +49,8 @@ HANDLE_METADATA_LEAF(LocalAsMetadata)
HANDLE_MDNODE_BRANCH(MDNode) HANDLE_MDNODE_BRANCH(MDNode)
HANDLE_MDNODE_LEAF(MDTuple) HANDLE_MDNODE_LEAF(MDTuple)
HANDLE_MDNODE_LEAF(MDLocation) HANDLE_MDNODE_LEAF(MDLocation)
HANDLE_MDNODE_BRANCH(DwarfNode) HANDLE_MDNODE_BRANCH(DebugNode)
HANDLE_MDNODE_LEAF(GenericDwarfNode) HANDLE_MDNODE_LEAF(GenericDebugNode)
#undef HANDLE_METADATA #undef HANDLE_METADATA
#undef HANDLE_METADATA_LEAF #undef HANDLE_METADATA_LEAF

52
include/llvm/IR/Metadata.h
View File

@@ -61,7 +61,7 @@ public:
enum MetadataKind { enum MetadataKind {
MDTupleKind, MDTupleKind,
MDLocationKind, MDLocationKind,
GenericDwarfNodeKind, GenericDebugNodeKind,
ConstantAsMetadataKind, ConstantAsMetadataKind,
LocalAsMetadataKind, LocalAsMetadataKind,
MDStringKind MDStringKind
@@ -867,7 +867,7 @@ public:
static bool classof(const Metadata *MD) { static bool classof(const Metadata *MD) {
return MD->getMetadataID() == MDTupleKind || return MD->getMetadataID() == MDTupleKind ||
MD->getMetadataID() == MDLocationKind || MD->getMetadataID() == MDLocationKind ||
MD->getMetadataID() == GenericDwarfNodeKind; MD->getMetadataID() == GenericDebugNodeKind;
} }
/// \brief Check whether MDNode is a vtable access. /// \brief Check whether MDNode is a vtable access.
@@ -1025,56 +1025,60 @@ public:
} }
}; };
/// \brief Tagged dwarf node. /// \brief Tagged DWARF-like metadata node.
/// ///
/// A metadata node with a DWARF tag. /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
class DwarfNode : public MDNode { /// defined in llvm/Support/Dwarf.h). Called \a DebugNode because it's
/// potentially used for non-DWARF output.
class DebugNode : public MDNode {
friend class LLVMContextImpl; friend class LLVMContextImpl;
friend class MDNode; friend class MDNode;
protected: protected:
DwarfNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, DebugNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None) ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
: MDNode(C, ID, Storage, Ops1, Ops2) { : MDNode(C, ID, Storage, Ops1, Ops2) {
assert(Tag < 1u << 16); assert(Tag < 1u << 16);
SubclassData16 = Tag; SubclassData16 = Tag;
} }
~DwarfNode() {} ~DebugNode() {}
public: public:
unsigned getTag() const { return SubclassData16; } unsigned getTag() const { return SubclassData16; }
static bool classof(const Metadata *MD) { static bool classof(const Metadata *MD) {
return MD->getMetadataID() == GenericDwarfNodeKind; return MD->getMetadataID() == GenericDebugNodeKind;
} }
}; };
/// \brief Generic tagged dwarf node. /// \brief Generic tagged DWARF-like metadata node.
/// ///
/// A generic metadata node with a DWARF tag that doesn't have special /// An un-specialized DWARF-like metadata node. The first operand is a
/// handling. /// (possibly empty) null-separated \a MDString header that contains arbitrary
class GenericDwarfNode : public DwarfNode { /// fields. The remaining operands are \a dwarf_operands(), and are pointers
/// to other metadata.
class GenericDebugNode : public DebugNode {
friend class LLVMContextImpl; friend class LLVMContextImpl;
friend class MDNode; friend class MDNode;
GenericDwarfNode(LLVMContext &C, StorageType Storage, unsigned Hash, GenericDebugNode(LLVMContext &C, StorageType Storage, unsigned Hash,
unsigned Tag, ArrayRef<Metadata *> Ops1, unsigned Tag, ArrayRef<Metadata *> Ops1,
ArrayRef<Metadata *> Ops2) ArrayRef<Metadata *> Ops2)
: DwarfNode(C, GenericDwarfNodeKind, Storage, Tag, Ops1, Ops2) { : DebugNode(C, GenericDebugNodeKind, Storage, Tag, Ops1, Ops2) {
setHash(Hash); setHash(Hash);
} }
~GenericDwarfNode() { dropAllReferences(); } ~GenericDebugNode() { dropAllReferences(); }
void setHash(unsigned Hash) { SubclassData32 = Hash; } void setHash(unsigned Hash) { SubclassData32 = Hash; }
void recalculateHash(); void recalculateHash();
static GenericDwarfNode *getImpl(LLVMContext &Context, unsigned Tag, static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
MDString *Header, MDString *Header,
ArrayRef<Metadata *> DwarfOps, ArrayRef<Metadata *> DwarfOps,
StorageType Storage, StorageType Storage,
bool ShouldCreate = true); bool ShouldCreate = true);
TempGenericDwarfNode cloneImpl() const { TempGenericDebugNode cloneImpl() const {
return getTemporary( return getTemporary(
getContext(), getTag(), getHeader(), getContext(), getTag(), getHeader(),
SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end())); SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
@@ -1083,32 +1087,32 @@ class GenericDwarfNode : public DwarfNode {
public: public:
unsigned getHash() const { return SubclassData32; } unsigned getHash() const { return SubclassData32; }
static GenericDwarfNode *get(LLVMContext &Context, static GenericDebugNode *get(LLVMContext &Context,
unsigned Tag, unsigned Tag,
MDString *Header, MDString *Header,
ArrayRef<Metadata *> DwarfOps) { ArrayRef<Metadata *> DwarfOps) {
return getImpl(Context, Tag, Header, DwarfOps, Uniqued); return getImpl(Context, Tag, Header, DwarfOps, Uniqued);
} }
static GenericDwarfNode *getIfExists(LLVMContext &Context, unsigned Tag, static GenericDebugNode *getIfExists(LLVMContext &Context, unsigned Tag,
MDString *Header, MDString *Header,
ArrayRef<Metadata *> DwarfOps) { ArrayRef<Metadata *> DwarfOps) {
return getImpl(Context, Tag, Header, DwarfOps, Uniqued, return getImpl(Context, Tag, Header, DwarfOps, Uniqued,
/* ShouldCreate */ false); /* ShouldCreate */ false);
} }
static GenericDwarfNode *getDistinct(LLVMContext &Context, unsigned Tag, static GenericDebugNode *getDistinct(LLVMContext &Context, unsigned Tag,
MDString *Header, MDString *Header,
ArrayRef<Metadata *> DwarfOps) { ArrayRef<Metadata *> DwarfOps) {
return getImpl(Context, Tag, Header, DwarfOps, Distinct); return getImpl(Context, Tag, Header, DwarfOps, Distinct);
} }
static TempGenericDwarfNode getTemporary(LLVMContext &Context, unsigned Tag, static TempGenericDebugNode getTemporary(LLVMContext &Context, unsigned Tag,
MDString *Header, MDString *Header,
ArrayRef<Metadata *> DwarfOps) { ArrayRef<Metadata *> DwarfOps) {
return TempGenericDwarfNode( return TempGenericDebugNode(
getImpl(Context, Tag, Header, DwarfOps, Temporary)); getImpl(Context, Tag, Header, DwarfOps, Temporary));
} }
/// \brief Return a (temporary) clone of this. /// \brief Return a (temporary) clone of this.
TempGenericDwarfNode clone() const { return cloneImpl(); } TempGenericDebugNode clone() const { return cloneImpl(); }
unsigned getTag() const { return SubclassData16; } unsigned getTag() const { return SubclassData16; }
MDString *getHeader() const { return cast_or_null<MDString>(getOperand(0)); } MDString *getHeader() const { return cast_or_null<MDString>(getOperand(0)); }
@@ -1128,7 +1132,7 @@ public:
} }
static bool classof(const Metadata *MD) { static bool classof(const Metadata *MD) {
return MD->getMetadataID() == GenericDwarfNodeKind; return MD->getMetadataID() == GenericDebugNodeKind;
} }
}; };

4
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@@ -791,7 +791,7 @@ static void WriteMDLocation(const MDLocation *N, const ValueEnumerator &VE,
Record.clear(); Record.clear();
} }
static void WriteGenericDwarfNode(const GenericDwarfNode *, static void WriteGenericDebugNode(const GenericDebugNode *,
const ValueEnumerator &, BitstreamWriter &, const ValueEnumerator &, BitstreamWriter &,
SmallVectorImpl<uint64_t> &, unsigned) { SmallVectorImpl<uint64_t> &, unsigned) {
llvm_unreachable("unimplemented"); llvm_unreachable("unimplemented");
@@ -843,7 +843,7 @@ static void WriteModuleMetadata(const Module *M,
} }
unsigned MDTupleAbbrev = 0; unsigned MDTupleAbbrev = 0;
unsigned GenericDwarfNodeAbbrev = 0; unsigned GenericDebugNodeAbbrev = 0;
SmallVector<uint64_t, 64> Record; SmallVector<uint64_t, 64> Record;
for (const Metadata *MD : MDs) { for (const Metadata *MD : MDs) {
if (const MDNode *N = dyn_cast<MDNode>(MD)) { if (const MDNode *N = dyn_cast<MDNode>(MD)) {

2
lib/IR/AsmWriter.cpp
View File

@@ -1286,7 +1286,7 @@ raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
} }
} // end namespace } // end namespace
static void writeGenericDwarfNode(raw_ostream &, const GenericDwarfNode *, static void writeGenericDebugNode(raw_ostream &, const GenericDebugNode *,
TypePrinting *, SlotTracker *, TypePrinting *, SlotTracker *,
const Module *) { const Module *) {
llvm_unreachable("Unimplemented write"); llvm_unreachable("Unimplemented write");

28
lib/IR/LLVMContextImpl.h
View File

@@ -284,44 +284,44 @@ struct MDLocationInfo {
} }
}; };
/// \brief DenseMapInfo for GenericDwarfNode. /// \brief DenseMapInfo for GenericDebugNode.
struct GenericDwarfNodeInfo { struct GenericDebugNodeInfo {
struct KeyTy : MDNodeOpsKey { struct KeyTy : MDNodeOpsKey {
unsigned Tag; unsigned Tag;
MDString *Header; MDString *Header;
KeyTy(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps) KeyTy(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
: MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {} : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
KeyTy(GenericDwarfNode *N) KeyTy(GenericDebugNode *N)
: MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getHeader()) {} : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getHeader()) {}
bool operator==(const GenericDwarfNode *RHS) const { bool operator==(const GenericDebugNode *RHS) const {
if (RHS == getEmptyKey() || RHS == getTombstoneKey()) if (RHS == getEmptyKey() || RHS == getTombstoneKey())
return false; return false;
return Tag == RHS->getTag() && Header == RHS->getHeader() && return Tag == RHS->getTag() && Header == RHS->getHeader() &&
compareOps(RHS, 1); compareOps(RHS, 1);
} }
static unsigned calculateHash(GenericDwarfNode *N) { static unsigned calculateHash(GenericDebugNode *N) {
return MDNodeOpsKey::calculateHash(N, 1); return MDNodeOpsKey::calculateHash(N, 1);
} }
}; };
static inline GenericDwarfNode *getEmptyKey() { static inline GenericDebugNode *getEmptyKey() {
return DenseMapInfo<GenericDwarfNode *>::getEmptyKey(); return DenseMapInfo<GenericDebugNode *>::getEmptyKey();
} }
static inline GenericDwarfNode *getTombstoneKey() { static inline GenericDebugNode *getTombstoneKey() {
return DenseMapInfo<GenericDwarfNode *>::getTombstoneKey(); return DenseMapInfo<GenericDebugNode *>::getTombstoneKey();
} }
static unsigned getHashValue(const KeyTy &Key) { static unsigned getHashValue(const KeyTy &Key) {
return hash_combine(Key.getHash(), Key.Tag, Key.Header); return hash_combine(Key.getHash(), Key.Tag, Key.Header);
} }
static unsigned getHashValue(const GenericDwarfNode *U) { static unsigned getHashValue(const GenericDebugNode *U) {
return hash_combine(U->getHash(), U->getTag(), U->getHeader()); return hash_combine(U->getHash(), U->getTag(), U->getHeader());
} }
static bool isEqual(const KeyTy &LHS, const GenericDwarfNode *RHS) { static bool isEqual(const KeyTy &LHS, const GenericDebugNode *RHS) {
return LHS == RHS; return LHS == RHS;
} }
static bool isEqual(const GenericDwarfNode *LHS, static bool isEqual(const GenericDebugNode *LHS,
const GenericDwarfNode *RHS) { const GenericDebugNode *RHS) {
return LHS == RHS; return LHS == RHS;
} }
}; };
@@ -358,7 +358,7 @@ public:
DenseSet<MDTuple *, MDTupleInfo> MDTuples; DenseSet<MDTuple *, MDTupleInfo> MDTuples;
DenseSet<MDLocation *, MDLocationInfo> MDLocations; DenseSet<MDLocation *, MDLocationInfo> MDLocations;
DenseSet<GenericDwarfNode *, GenericDwarfNodeInfo> GenericDwarfNodes; DenseSet<GenericDebugNode *, GenericDebugNodeInfo> GenericDebugNodes;
// MDNodes may be uniqued or not uniqued. When they're not uniqued, they // MDNodes may be uniqued or not uniqued. When they're not uniqued, they
// aren't in the MDNodeSet, but they're still shared between objects, so no // aren't in the MDNodeSet, but they're still shared between objects, so no

14
lib/IR/Metadata.cpp
View File

@@ -541,8 +541,8 @@ void MDTuple::recalculateHash() {
setHash(MDTupleInfo::KeyTy::calculateHash(this)); setHash(MDTupleInfo::KeyTy::calculateHash(this));
} }
void GenericDwarfNode::recalculateHash() { void GenericDebugNode::recalculateHash() {
setHash(GenericDwarfNodeInfo::KeyTy::calculateHash(this)); setHash(GenericDebugNodeInfo::KeyTy::calculateHash(this));
} }
void MDNode::dropAllReferences() { void MDNode::dropAllReferences() {
@@ -759,7 +759,7 @@ MDLocation *MDLocation::getImpl(LLVMContext &Context, unsigned Line,
Storage, Context.pImpl->MDLocations); Storage, Context.pImpl->MDLocations);
} }
GenericDwarfNode *GenericDwarfNode::getImpl(LLVMContext &Context, unsigned Tag, GenericDebugNode *GenericDebugNode::getImpl(LLVMContext &Context, unsigned Tag,
MDString *Header, MDString *Header,
ArrayRef<Metadata *> DwarfOps, ArrayRef<Metadata *> DwarfOps,
StorageType Storage, StorageType Storage,
@@ -770,8 +770,8 @@ GenericDwarfNode *GenericDwarfNode::getImpl(LLVMContext &Context, unsigned Tag,
unsigned Hash = 0; unsigned Hash = 0;
if (Storage == Uniqued) { if (Storage == Uniqued) {
GenericDwarfNodeInfo::KeyTy Key(Tag, Header, DwarfOps); GenericDebugNodeInfo::KeyTy Key(Tag, Header, DwarfOps);
if (auto *N = getUniqued(Context.pImpl->GenericDwarfNodes, Key)) if (auto *N = getUniqued(Context.pImpl->GenericDebugNodes, Key))
return N; return N;
if (!ShouldCreate) if (!ShouldCreate)
return nullptr; return nullptr;
@@ -781,9 +781,9 @@ GenericDwarfNode *GenericDwarfNode::getImpl(LLVMContext &Context, unsigned Tag,
} }
Metadata *PreOps[] = {Header}; Metadata *PreOps[] = {Header};
return storeImpl(new (DwarfOps.size() + 1) GenericDwarfNode( return storeImpl(new (DwarfOps.size() + 1) GenericDebugNode(
Context, Storage, Hash, Tag, PreOps, DwarfOps), Context, Storage, Hash, Tag, PreOps, DwarfOps),
Storage, Context.pImpl->GenericDwarfNodes); Storage, Context.pImpl->GenericDebugNodes);
} }
void MDNode::deleteTemporary(MDNode *N) { void MDNode::deleteTemporary(MDNode *N) {

16
unittests/IR/MetadataTest.cpp
View File

@@ -572,13 +572,13 @@ TEST_F(MDLocationTest, getTemporary) {
EXPECT_FALSE(L->isResolved()); EXPECT_FALSE(L->isResolved());
} }
typedef MetadataTest GenericDwarfNodeTest; typedef MetadataTest GenericDebugNodeTest;
TEST_F(GenericDwarfNodeTest, get) { TEST_F(GenericDebugNodeTest, get) {
auto *Header = MDString::get(Context, "header"); auto *Header = MDString::get(Context, "header");
auto *Empty = MDNode::get(Context, None); auto *Empty = MDNode::get(Context, None);
Metadata *Ops1[] = {Empty}; Metadata *Ops1[] = {Empty};
auto *N = GenericDwarfNode::get(Context, 15, Header, Ops1); auto *N = GenericDebugNode::get(Context, 15, Header, Ops1);
EXPECT_EQ(15u, N->getTag()); EXPECT_EQ(15u, N->getTag());
EXPECT_EQ(2u, N->getNumOperands()); EXPECT_EQ(2u, N->getNumOperands());
EXPECT_EQ(Header, N->getHeader()); EXPECT_EQ(Header, N->getHeader());
@@ -588,7 +588,7 @@ TEST_F(GenericDwarfNodeTest, get) {
EXPECT_EQ(Empty, N->getOperand(1)); EXPECT_EQ(Empty, N->getOperand(1));
ASSERT_TRUE(N->isUniqued()); ASSERT_TRUE(N->isUniqued());
EXPECT_EQ(N, GenericDwarfNode::get(Context, 15, Header, Ops1)); EXPECT_EQ(N, GenericDebugNode::get(Context, 15, Header, Ops1));
N->replaceOperandWith(1, nullptr); N->replaceOperandWith(1, nullptr);
EXPECT_EQ(15u, N->getTag()); EXPECT_EQ(15u, N->getTag());
@@ -597,21 +597,21 @@ TEST_F(GenericDwarfNodeTest, get) {
ASSERT_TRUE(N->isUniqued()); ASSERT_TRUE(N->isUniqued());
Metadata *Ops2[] = {nullptr}; Metadata *Ops2[] = {nullptr};
EXPECT_EQ(N, GenericDwarfNode::get(Context, 15, Header, Ops2)); EXPECT_EQ(N, GenericDebugNode::get(Context, 15, Header, Ops2));
N->replaceDwarfOperandWith(0, Empty); N->replaceDwarfOperandWith(0, Empty);
EXPECT_EQ(15u, N->getTag()); EXPECT_EQ(15u, N->getTag());
EXPECT_EQ(Header, N->getHeader()); EXPECT_EQ(Header, N->getHeader());
EXPECT_EQ(Empty, N->getDwarfOperand(0)); EXPECT_EQ(Empty, N->getDwarfOperand(0));
ASSERT_TRUE(N->isUniqued()); ASSERT_TRUE(N->isUniqued());
EXPECT_EQ(N, GenericDwarfNode::get(Context, 15, Header, Ops1)); EXPECT_EQ(N, GenericDebugNode::get(Context, 15, Header, Ops1));
} }
TEST_F(GenericDwarfNodeTest, getEmptyHeader) { TEST_F(GenericDebugNodeTest, getEmptyHeader) {
// Canonicalize !"" to null. // Canonicalize !"" to null.
auto *Header = MDString::get(Context, ""); auto *Header = MDString::get(Context, "");
EXPECT_NE(nullptr, Header); EXPECT_NE(nullptr, Header);
auto *N = GenericDwarfNode::get(Context, 15, Header, None); auto *N = GenericDebugNode::get(Context, 15, Header, None);
EXPECT_EQ(nullptr, N->getHeader()); EXPECT_EQ(nullptr, N->getHeader());
} }