[llvm] r225682 - IR: Split GenericMDNode into MDTuple and UniquableMDNode
David Blaikie
dblaikie at gmail.com
Mon Jan 12 13:02:46 PST 2015
On Mon, Jan 12, 2015 at 12:09 PM, Duncan P. N. Exon Smith <
dexonsmith at apple.com> wrote:
> Author: dexonsmith
> Date: Mon Jan 12 14:09:34 2015
> New Revision: 225682
>
> URL: http://llvm.org/viewvc/llvm-project?rev=225682&view=rev
> Log:
> IR: Split GenericMDNode into MDTuple and UniquableMDNode
>
> Split `GenericMDNode` into two classes (with more descriptive names).
>
> - `UniquableMDNode` will be a common subclass for `MDNode`s that are
> sometimes uniqued like constants, and sometimes 'distinct'.
>
> This class gets the (short-lived) RAUW support and related API.
>
> - `MDTuple` is the basic tuple that has always been returned by
> `MDNode::get()`. This is as opposed to more specific nodes to be
> added soon, which have additional fields, custom assembly syntax,
> and extra semantics.
>
I don't mean to hinder progress, etc - but now that we've made the
MDNode/Value split, is the "make debug info special" argument still
(sufficiently) valid? Can we not make MDNodes sufficiently cheap while
being general?
(Answer may well be 'no', but I'm just curious/wrapping my head around
everything)
>
> This class gets the hash-related logic, since other sublcasses of
> `UniquableMDNode` may need to hash based on other fields.
>
> To keep this diff from getting too big, I've added casts to `MDTuple`
> that won't really scale as new subclasses of `UniquableMDNode` are
> added, but I'll clean those up incrementally.
>
> (No functionality change intended.)
>
> Modified:
> llvm/trunk/include/llvm/IR/Metadata.def
> llvm/trunk/include/llvm/IR/Metadata.h
> llvm/trunk/lib/AsmParser/LLParser.cpp
> llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
> llvm/trunk/lib/IR/DIBuilder.cpp
> llvm/trunk/lib/IR/LLVMContextImpl.cpp
> llvm/trunk/lib/IR/LLVMContextImpl.h
> llvm/trunk/lib/IR/Metadata.cpp
> llvm/trunk/lib/IR/MetadataTracking.cpp
> llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp
>
> Modified: llvm/trunk/include/llvm/IR/Metadata.def
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/Metadata.def?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/IR/Metadata.def (original)
> +++ llvm/trunk/include/llvm/IR/Metadata.def Mon Jan 12 14:09:34 2015
> @@ -37,7 +37,8 @@ HANDLE_METADATA_LEAF(ConstantAsMetadata)
> HANDLE_METADATA_LEAF(LocalAsMetadata)
> HANDLE_METADATA_BRANCH(MDNode)
> HANDLE_METADATA_LEAF(MDNodeFwdDecl)
> -HANDLE_METADATA_LEAF(GenericMDNode)
> +HANDLE_METADATA_BRANCH(UniquableMDNode)
> +HANDLE_METADATA_LEAF(MDTuple)
>
> #undef HANDLE_METADATA
> #undef HANDLE_METADATA_LEAF
>
> Modified: llvm/trunk/include/llvm/IR/Metadata.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/Metadata.h?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/IR/Metadata.h (original)
> +++ llvm/trunk/include/llvm/IR/Metadata.h Mon Jan 12 14:09:34 2015
> @@ -56,7 +56,7 @@ protected:
>
> public:
> enum MetadataKind {
> - GenericMDNodeKind,
> + MDTupleKind,
> MDNodeFwdDeclKind,
> ConstantAsMetadataKind,
> LocalAsMetadataKind,
> @@ -158,7 +158,7 @@ public:
> /// \brief Resolve all uses of this.
> ///
> /// Resolve all uses of this, turning off RAUW permanently. If \c
> - /// ResolveUsers, call \a GenericMDNode::resolve() on any users whose
> last
> + /// ResolveUsers, call \a UniquableMDNode::resolve() on any users whose
> last
> /// operand is resolved.
> void resolveAllUses(bool ResolveUsers = true);
>
> @@ -682,7 +682,7 @@ public:
>
> /// \brief Methods for support type inquiry through isa, cast, and
> dyn_cast:
> static bool classof(const Metadata *MD) {
> - return MD->getMetadataID() == GenericMDNodeKind ||
> + return MD->getMetadataID() == MDTupleKind ||
> MD->getMetadataID() == MDNodeFwdDeclKind;
> }
>
> @@ -698,46 +698,46 @@ public:
> static MDNode *getMostGenericRange(MDNode *A, MDNode *B);
> };
>
> -/// \brief Generic metadata node.
> +/// \brief Uniquable metadata node.
> ///
> -/// Generic metadata nodes, with opt-out support for uniquing.
> -///
> -/// Although nodes are uniqued by default, \a GenericMDNode has no
> support for
> -/// RAUW. If an operand change (due to RAUW or otherwise) causes a
> uniquing
> -/// collision, the uniquing bit is dropped.
> -class GenericMDNode : public MDNode {
> - friend class Metadata;
> +/// A uniquable metadata node. This contains the basic functionality
> +/// for implementing sub-types of \a MDNode that can be uniqued like
> +/// constants.
> +///
> +/// There is limited support for RAUW at construction time. At
> +/// construction time, if any operands are an instance of \a
> +/// MDNodeFwdDecl (or another unresolved \a UniquableMDNode, which
> +/// indicates an \a MDNodeFwdDecl in its path), the node itself will be
> +/// unresolved. As soon as all operands become resolved, it will drop
> +/// RAUW support permanently.
> +///
> +/// If an unresolved node is part of a cycle, \a resolveCycles() needs
> +/// to be called on some member of the cycle when each \a MDNodeFwdDecl
> +/// has been removed.
> +class UniquableMDNode : public MDNode {
> + friend class ReplaceableMetadataImpl;
> friend class MDNode;
> friend class LLVMContextImpl;
> - friend class ReplaceableMetadataImpl;
>
> /// \brief Support RAUW as long as one of its arguments is replaceable.
> ///
> - /// If an operand is an \a MDNodeFwdDecl (or a replaceable \a
> GenericMDNode),
> - /// support RAUW to support uniquing as forward declarations are
> resolved.
> - /// As soon as operands have been resolved, drop support.
> - ///
> /// FIXME: Save memory by storing this in a pointer union with the
> /// LLVMContext, and adding an LLVMContext reference to RMI.
> std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses;
>
> +protected:
> /// \brief Create a new node.
> ///
> /// If \c AllowRAUW, then if any operands are unresolved support RAUW.
> RAUW
> /// will be dropped once all operands have been resolved (or if \a
> /// resolveCycles() is called).
> - GenericMDNode(LLVMContext &C, ArrayRef<Metadata *> Vals, bool
> AllowRAUW);
> - ~GenericMDNode();
> -
> - void setHash(unsigned Hash) { MDNodeSubclassData = Hash; }
> - void recalculateHash();
> + UniquableMDNode(LLVMContext &C, unsigned ID, ArrayRef<Metadata *> Vals,
> + bool AllowRAUW);
> + ~UniquableMDNode();
>
> public:
> - /// \brief Get the hash, if any.
> - unsigned getHash() const { return MDNodeSubclassData; }
> -
> static bool classof(const Metadata *MD) {
> - return MD->getMetadataID() == GenericMDNodeKind;
> + return MD->getMetadataID() == MDTupleKind;
> }
>
> /// \brief Check whether any operands are forward declarations.
> @@ -766,11 +766,36 @@ private:
> void decrementUnresolvedOperandCount();
> };
>
> +/// \brief Tuple of metadata.
> +///
> +/// This is the simple \a MDNode arbitrary tuple. Nodes are uniqued by
> +/// default based on their operands.
> +class MDTuple : public UniquableMDNode {
> + friend class LLVMContextImpl;
> + friend class UniquableMDNode;
> + friend class MDNode;
> +
> + MDTuple(LLVMContext &C, ArrayRef<Metadata *> Vals, bool AllowRAUW)
> + : UniquableMDNode(C, MDTupleKind, Vals, AllowRAUW) {}
> + ~MDTuple();
> +
> + void setHash(unsigned Hash) { MDNodeSubclassData = Hash; }
> + void recalculateHash();
> +
> +public:
> + /// \brief Get the hash, if any.
> + unsigned getHash() const { return MDNodeSubclassData; }
> +
> + static bool classof(const Metadata *MD) {
> + return MD->getMetadataID() == MDTupleKind;
> + }
> +};
> +
> /// \brief Forward declaration of metadata.
> ///
> -/// Forward declaration of metadata, in the form of a metadata node.
> Unlike \a
> -/// GenericMDNode, this class has support for RAUW and is suitable for
> forward
> -/// references.
> +/// Forward declaration of metadata, in the form of a basic tuple.
> Unlike \a
> +/// MDTuple, this class has full support for RAUW, is not owned, is not
> +/// uniqued, and is suitable for forward references.
> class MDNodeFwdDecl : public MDNode, ReplaceableMetadataImpl {
> friend class Metadata;
> friend class MDNode;
>
> Modified: llvm/trunk/lib/AsmParser/LLParser.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLParser.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/AsmParser/LLParser.cpp (original)
> +++ llvm/trunk/lib/AsmParser/LLParser.cpp Mon Jan 12 14:09:34 2015
> @@ -169,8 +169,8 @@ bool LLParser::ValidateEndOfModule() {
>
> // Resolve metadata cycles.
> for (auto &N : NumberedMetadata)
> - if (auto *G = cast_or_null<GenericMDNode>(N))
> - G->resolveCycles();
> + if (auto *U = cast_or_null<UniquableMDNode>(N))
> + U->resolveCycles();
>
> // Look for intrinsic functions and CallInst that need to be upgraded
> for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
>
> Modified: llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp (original)
> +++ llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp Mon Jan 12 14:09:34
> 2015
> @@ -558,8 +558,8 @@ void BitcodeReaderMDValueList::tryToReso
> // Resolve any cycles.
> for (auto &MD : MDValuePtrs) {
> assert(!(MD && isa<MDNodeFwdDecl>(MD)) && "Unexpected forward
> reference");
> - if (auto *G = dyn_cast_or_null<GenericMDNode>(MD))
> - G->resolveCycles();
> + if (auto *N = dyn_cast_or_null<UniquableMDNode>(MD))
> + N->resolveCycles();
> }
> }
>
>
> Modified: llvm/trunk/lib/IR/DIBuilder.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/DIBuilder.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/IR/DIBuilder.cpp (original)
> +++ llvm/trunk/lib/IR/DIBuilder.cpp Mon Jan 12 14:09:34 2015
> @@ -55,7 +55,8 @@ DIBuilder::DIBuilder(Module &m, bool All
> AllowUnresolvedNodes(AllowUnresolvedNodes) {}
>
> static bool isUnresolved(MDNode *N) {
> - return N && (isa<MDNodeFwdDecl>(N) ||
> !cast<GenericMDNode>(N)->isResolved());
> + return N &&
> + (isa<MDNodeFwdDecl>(N) ||
> !cast<UniquableMDNode>(N)->isResolved());
> }
>
> void DIBuilder::trackIfUnresolved(MDNode *N) {
> @@ -110,7 +111,7 @@ void DIBuilder::finalize() {
> // cycles.
> for (const auto &N : UnresolvedNodes)
> if (N)
> - cast<GenericMDNode>(N)->resolveCycles();
> + cast<UniquableMDNode>(N)->resolveCycles();
> UnresolvedNodes.clear();
>
> // Can't handle unresolved nodes anymore.
>
> Modified: llvm/trunk/lib/IR/LLVMContextImpl.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/LLVMContextImpl.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/IR/LLVMContextImpl.cpp (original)
> +++ llvm/trunk/lib/IR/LLVMContextImpl.cpp Mon Jan 12 14:09:34 2015
> @@ -135,17 +135,17 @@ LLVMContextImpl::~LLVMContextImpl() {
> for (auto &Pair : ValuesAsMetadata)
> delete Pair.second;
>
> - // Destroy MDNodes. ~MDNode can move and remove nodes between the
> MDNodeSet
> - // and the NonUniquedMDNodes sets, so copy the values out first.
> - SmallVector<GenericMDNode *, 8> MDNodes;
> - MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size());
> - MDNodes.append(MDNodeSet.begin(), MDNodeSet.end());
> - MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end());
> - for (GenericMDNode *I : MDNodes)
> + // Destroy MDNodes. ~MDNode can move and remove nodes between the
> MDTuples
> + // and the DistinctMDNodes sets, so copy the values out first.
> + SmallVector<UniquableMDNode *, 8> Uniquables;
> + Uniquables.reserve(MDTuples.size() + DistinctMDNodes.size());
> + Uniquables.append(MDTuples.begin(), MDTuples.end());
> + Uniquables.append(DistinctMDNodes.begin(), DistinctMDNodes.end());
> + for (UniquableMDNode *I : Uniquables)
> I->dropAllReferences();
> - for (GenericMDNode *I : MDNodes)
> - delete I;
> - assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() &&
> + for (UniquableMDNode *I : Uniquables)
> + delete cast<MDTuple>(I);
> + assert(MDTuples.empty() && DistinctMDNodes.empty() &&
> "Destroying all MDNodes didn't empty the Context's sets.");
>
> // Destroy MDStrings.
>
> Modified: llvm/trunk/lib/IR/LLVMContextImpl.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/LLVMContextImpl.h?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/IR/LLVMContextImpl.h (original)
> +++ llvm/trunk/lib/IR/LLVMContextImpl.h Mon Jan 12 14:09:34 2015
> @@ -166,11 +166,11 @@ struct FunctionTypeKeyInfo {
> }
> };
>
> -/// \brief DenseMapInfo for GenericMDNode.
> +/// \brief DenseMapInfo for MDTuple.
> ///
> /// Note that we don't need the is-function-local bit, since that's
> implicit in
> /// the operands.
> -struct GenericMDNodeInfo {
> +struct MDTupleInfo {
> struct KeyTy {
> ArrayRef<Metadata *> RawOps;
> ArrayRef<MDOperand> Ops;
> @@ -179,10 +179,10 @@ struct GenericMDNodeInfo {
> KeyTy(ArrayRef<Metadata *> Ops)
> : RawOps(Ops), Hash(hash_combine_range(Ops.begin(), Ops.end())) {}
>
> - KeyTy(GenericMDNode *N)
> + KeyTy(MDTuple *N)
> : Ops(N->op_begin(), N->op_end()), Hash(N->getHash()) {}
>
> - bool operator==(const GenericMDNode *RHS) const {
> + bool operator==(const MDTuple *RHS) const {
> if (RHS == getEmptyKey() || RHS == getTombstoneKey())
> return false;
> if (Hash != RHS->getHash())
> @@ -191,26 +191,26 @@ struct GenericMDNodeInfo {
> return RawOps.empty() ? compareOps(Ops, RHS) : compareOps(RawOps,
> RHS);
> }
> template <class T>
> - static bool compareOps(ArrayRef<T> Ops, const GenericMDNode *RHS) {
> + static bool compareOps(ArrayRef<T> Ops, const MDTuple *RHS) {
> if (Ops.size() != RHS->getNumOperands())
> return false;
> return std::equal(Ops.begin(), Ops.end(), RHS->op_begin());
> }
> };
> - static inline GenericMDNode *getEmptyKey() {
> - return DenseMapInfo<GenericMDNode *>::getEmptyKey();
> + static inline MDTuple *getEmptyKey() {
> + return DenseMapInfo<MDTuple *>::getEmptyKey();
> }
> - static inline GenericMDNode *getTombstoneKey() {
> - return DenseMapInfo<GenericMDNode *>::getTombstoneKey();
> + static inline MDTuple *getTombstoneKey() {
> + return DenseMapInfo<MDTuple *>::getTombstoneKey();
> }
> static unsigned getHashValue(const KeyTy &Key) { return Key.Hash; }
> - static unsigned getHashValue(const GenericMDNode *U) {
> + static unsigned getHashValue(const MDTuple *U) {
> return U->getHash();
> }
> - static bool isEqual(const KeyTy &LHS, const GenericMDNode *RHS) {
> + static bool isEqual(const KeyTy &LHS, const MDTuple *RHS) {
> return LHS == RHS;
> }
> - static bool isEqual(const GenericMDNode *LHS, const GenericMDNode *RHS)
> {
> + static bool isEqual(const MDTuple *LHS, const MDTuple *RHS) {
> return LHS == RHS;
> }
> };
> @@ -245,13 +245,13 @@ public:
> DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
> DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
>
> - DenseSet<GenericMDNode *, GenericMDNodeInfo> MDNodeSet;
> + DenseSet<MDTuple *, MDTupleInfo> MDTuples;
>
> // 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
> // one object can destroy them. This set allows us to at least destroy
> them
> // on Context destruction.
> - SmallPtrSet<GenericMDNode *, 1> NonUniquedMDNodes;
> + SmallPtrSet<UniquableMDNode *, 1> DistinctMDNodes;
>
> DenseMap<Type*, ConstantAggregateZero*> CAZConstants;
>
>
> Modified: llvm/trunk/lib/IR/Metadata.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Metadata.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/IR/Metadata.cpp (original)
> +++ llvm/trunk/lib/IR/Metadata.cpp Mon Jan 12 14:09:34 2015
> @@ -222,8 +222,8 @@ void ReplaceableMetadataImpl::resolveAll
> if (Owner.is<MetadataAsValue *>())
> continue;
>
> - // Resolve GenericMDNodes that point at this.
> - auto *OwnerMD = dyn_cast<GenericMDNode>(Owner.get<Metadata *>());
> + // Resolve UniquableMDNodes that point at this.
> + auto *OwnerMD = dyn_cast<UniquableMDNode>(Owner.get<Metadata *>());
> if (!OwnerMD)
> continue;
> if (OwnerMD->isResolved())
> @@ -400,7 +400,7 @@ MDNode::MDNode(LLVMContext &Context, uns
> bool MDNode::isResolved() const {
> if (isa<MDNodeFwdDecl>(this))
> return false;
> - return cast<GenericMDNode>(this)->isResolved();
> + return cast<UniquableMDNode>(this)->isResolved();
> }
>
> static bool isOperandUnresolved(Metadata *Op) {
> @@ -409,9 +409,9 @@ static bool isOperandUnresolved(Metadata
> return false;
> }
>
> -GenericMDNode::GenericMDNode(LLVMContext &C, ArrayRef<Metadata *> Vals,
> - bool AllowRAUW)
> - : MDNode(C, GenericMDNodeKind, Vals) {
> +UniquableMDNode::UniquableMDNode(LLVMContext &C, unsigned ID,
> + ArrayRef<Metadata *> Vals, bool
> AllowRAUW)
> + : MDNode(C, ID, Vals) {
> if (!AllowRAUW)
> return;
>
> @@ -427,16 +427,14 @@ GenericMDNode::GenericMDNode(LLVMContext
> SubclassData32 = NumUnresolved;
> }
>
> -GenericMDNode::~GenericMDNode() {
> - LLVMContextImpl *pImpl = getContext().pImpl;
> +UniquableMDNode::~UniquableMDNode() {
> if (isStoredDistinctInContext())
> - pImpl->NonUniquedMDNodes.erase(this);
> - else
> - pImpl->MDNodeSet.erase(this);
> + getContext().pImpl->DistinctMDNodes.erase(this);
> +
> dropAllReferences();
> }
>
> -void GenericMDNode::resolve() {
> +void UniquableMDNode::resolve() {
> assert(!isResolved() && "Expected this to be unresolved");
>
> // Move the map, so that this immediately looks resolved.
> @@ -448,7 +446,7 @@ void GenericMDNode::resolve() {
> Uses->resolveAllUses();
> }
>
> -void GenericMDNode::resolveAfterOperandChange(Metadata *Old, Metadata
> *New) {
> +void UniquableMDNode::resolveAfterOperandChange(Metadata *Old, Metadata
> *New) {
> assert(SubclassData32 != 0 && "Expected unresolved operands");
>
> // Check if an operand was resolved.
> @@ -458,13 +456,13 @@ void GenericMDNode::resolveAfterOperandC
> decrementUnresolvedOperandCount();
> }
>
> -void GenericMDNode::decrementUnresolvedOperandCount() {
> +void UniquableMDNode::decrementUnresolvedOperandCount() {
> if (!--SubclassData32)
> // Last unresolved operand has just been resolved.
> resolve();
> }
>
> -void GenericMDNode::resolveCycles() {
> +void UniquableMDNode::resolveCycles() {
> if (isResolved())
> return;
>
> @@ -477,13 +475,18 @@ void GenericMDNode::resolveCycles() {
> continue;
> assert(!isa<MDNodeFwdDecl>(Op) &&
> "Expected all forward declarations to be resolved");
> - if (auto *N = dyn_cast<GenericMDNode>(Op))
> + if (auto *N = dyn_cast<UniquableMDNode>(Op))
> if (!N->isResolved())
> N->resolveCycles();
> }
> }
>
> -void GenericMDNode::recalculateHash() {
> +MDTuple::~MDTuple() {
> + if (!isStoredDistinctInContext())
> + getContext().pImpl->MDTuples.erase(this);
> +}
> +
> +void MDTuple::recalculateHash() {
> setHash(hash_combine_range(op_begin(), op_end()));
> #ifndef NDEBUG
> {
> @@ -498,10 +501,10 @@ void GenericMDNode::recalculateHash() {
> void MDNode::dropAllReferences() {
> for (unsigned I = 0, E = NumOperands; I != E; ++I)
> setOperand(I, nullptr);
> - if (auto *G = dyn_cast<GenericMDNode>(this))
> - if (!G->isResolved()) {
> - G->ReplaceableUses->resolveAllUses(/* ResolveUsers */ false);
> - G->ReplaceableUses.reset();
> + if (auto *N = dyn_cast<UniquableMDNode>(this))
> + if (!N->isResolved()) {
> + N->ReplaceableUses->resolveAllUses(/* ResolveUsers */ false);
> + N->ReplaceableUses.reset();
> }
> }
>
> @@ -522,7 +525,7 @@ namespace llvm {
> static const Metadata *get_hashable_data(const MDOperand &X) { return
> X.get(); }
> }
>
> -void GenericMDNode::handleChangedOperand(void *Ref, Metadata *New) {
> +void UniquableMDNode::handleChangedOperand(void *Ref, Metadata *New) {
> unsigned Op = static_cast<MDOperand *>(Ref) - op_begin();
> assert(Op < getNumOperands() && "Expected valid operand");
>
> @@ -534,8 +537,8 @@ void GenericMDNode::handleChangedOperand
> return;
> }
>
> - auto &Store = getContext().pImpl->MDNodeSet;
> - Store.erase(this);
> + auto &Store = getContext().pImpl->MDTuples;
> + Store.erase(cast<MDTuple>(this));
>
> Metadata *Old = getOperand(Op);
> setOperand(Op, New);
> @@ -549,11 +552,11 @@ void GenericMDNode::handleChangedOperand
> }
>
> // Re-unique the node.
> - recalculateHash();
> - GenericMDNodeInfo::KeyTy Key(this);
> + cast<MDTuple>(this)->recalculateHash();
> + MDTupleInfo::KeyTy Key(cast<MDTuple>(this));
> auto I = Store.find_as(Key);
> if (I == Store.end()) {
> - Store.insert(this);
> + Store.insert(cast<MDTuple>(this));
>
> if (!isResolved())
> resolveAfterOperandChange(Old, New);
> @@ -570,7 +573,7 @@ void GenericMDNode::handleChangedOperand
> for (unsigned O = 0, E = getNumOperands(); O != E; ++O)
> setOperand(O, nullptr);
> ReplaceableUses->replaceAllUsesWith(*I);
> - delete this;
> + delete cast<MDTuple>(this);
> return;
> }
>
> @@ -580,9 +583,9 @@ void GenericMDNode::handleChangedOperand
>
> MDNode *MDNode::getMDNode(LLVMContext &Context, ArrayRef<Metadata *> MDs,
> bool Insert) {
> - auto &Store = Context.pImpl->MDNodeSet;
> + auto &Store = Context.pImpl->MDTuples;
>
> - GenericMDNodeInfo::KeyTy Key(MDs);
> + MDTupleInfo::KeyTy Key(MDs);
> auto I = Store.find_as(Key);
> if (I != Store.end())
> return *I;
> @@ -590,14 +593,14 @@ MDNode *MDNode::getMDNode(LLVMContext &C
> return nullptr;
>
> // Coallocate space for the node and Operands together, then placement
> new.
> - auto *N = new (MDs.size()) GenericMDNode(Context, MDs, /* AllowRAUW */
> true);
> + auto *N = new (MDs.size()) MDTuple(Context, MDs, /* AllowRAUW */ true);
> N->setHash(Key.Hash);
> Store.insert(N);
> return N;
> }
>
> MDNode *MDNode::getDistinct(LLVMContext &Context, ArrayRef<Metadata *>
> MDs) {
> - auto *N = new (MDs.size()) GenericMDNode(Context, MDs, /* AllowRAUW */
> false);
> + auto *N = new (MDs.size()) MDTuple(Context, MDs, /* AllowRAUW */ false);
> N->storeDistinctInContext();
> return N;
> }
> @@ -616,9 +619,9 @@ void MDNode::deleteTemporary(MDNode *N)
> void MDNode::storeDistinctInContext() {
> assert(!IsDistinctInContext && "Expected newly distinct metadata");
> IsDistinctInContext = true;
> - auto *G = cast<GenericMDNode>(this);
> - G->setHash(0);
> - getContext().pImpl->NonUniquedMDNodes.insert(G);
> + auto *T = cast<MDTuple>(this);
> + T->setHash(0);
> + getContext().pImpl->DistinctMDNodes.insert(T);
> }
>
> void MDNode::replaceOperandWith(unsigned I, Metadata *New) {
> @@ -630,7 +633,7 @@ void MDNode::replaceOperandWith(unsigned
> return;
> }
>
> - cast<GenericMDNode>(this)->handleChangedOperand(mutable_begin() + I,
> New);
> + cast<UniquableMDNode>(this)->handleChangedOperand(mutable_begin() + I,
> New);
> }
>
> void MDNode::setOperand(unsigned I, Metadata *New) {
>
> Modified: llvm/trunk/lib/IR/MetadataTracking.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/MetadataTracking.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/IR/MetadataTracking.cpp (original)
> +++ llvm/trunk/lib/IR/MetadataTracking.cpp Mon Jan 12 14:09:34 2015
> @@ -18,8 +18,8 @@ using namespace llvm;
>
> ReplaceableMetadataImpl *ReplaceableMetadataImpl::get(Metadata &MD) {
> if (auto *N = dyn_cast<MDNode>(&MD)) {
> - if (auto *G = dyn_cast<GenericMDNode>(N))
> - return G->ReplaceableUses.get();
> + if (auto *U = dyn_cast<UniquableMDNode>(N))
> + return U->ReplaceableUses.get();
> return cast<MDNodeFwdDecl>(N);
> }
> return dyn_cast<ValueAsMetadata>(&MD);
>
> Modified: llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp?rev=225682&r1=225681&r2=225682&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp Mon Jan 12 14:09:34
> 2015
> @@ -260,8 +260,8 @@ Metadata *llvm::MapMetadata(const Metada
> ValueMaterializer *Materializer) {
> Metadata *NewMD = MapMetadataImpl(MD, VM, Flags, TypeMapper,
> Materializer);
> if (NewMD && NewMD != MD)
> - if (auto *G = dyn_cast<GenericMDNode>(NewMD))
> - G->resolveCycles();
> + if (auto *N = dyn_cast<UniquableMDNode>(NewMD))
> + N->resolveCycles();
> return NewMD;
> }
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150112/70a0edd3/attachment.html>
More information about the llvm-commits
mailing list