Devang Patel | 0a9f7b9 | 2009-07-28 21:49:47 +0000 | [diff] [blame] | 1 | //===-- Metadata.cpp - Implement Metadata classes -------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the Metadata classes. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "llvm/Metadata.h" |
Chris Lattner | 37da0ad | 2009-12-28 08:24:16 +0000 | [diff] [blame] | 15 | #include "LLVMContextImpl.h" |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 16 | #include "llvm/LLVMContext.h" |
Devang Patel | f457d13 | 2009-07-29 00:33:07 +0000 | [diff] [blame] | 17 | #include "llvm/Module.h" |
Devang Patel | 937b1e9 | 2009-09-16 18:09:00 +0000 | [diff] [blame] | 18 | #include "llvm/Instruction.h" |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/DenseMap.h" |
| 20 | #include "llvm/ADT/StringMap.h" |
Devang Patel | 28bc9d8 | 2009-07-29 17:16:17 +0000 | [diff] [blame] | 21 | #include "SymbolTableListTraitsImpl.h" |
Chris Lattner | 37da0ad | 2009-12-28 08:24:16 +0000 | [diff] [blame] | 22 | #include "llvm/Support/ValueHandle.h" |
Devang Patel | 0a9f7b9 | 2009-07-28 21:49:47 +0000 | [diff] [blame] | 23 | using namespace llvm; |
| 24 | |
| 25 | //===----------------------------------------------------------------------===// |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 26 | // MDString implementation. |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 27 | // |
Chris Lattner | 5e9cd43 | 2009-12-28 08:30:43 +0000 | [diff] [blame] | 28 | |
| 29 | MDString::MDString(LLVMContext &C, StringRef S) |
| 30 | : MetadataBase(Type::getMetadataTy(C), Value::MDStringVal), Str(S) {} |
| 31 | |
Devang Patel | 49b63a1 | 2009-10-22 00:10:15 +0000 | [diff] [blame] | 32 | MDString *MDString::get(LLVMContext &Context, StringRef Str) { |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 33 | LLVMContextImpl *pImpl = Context.pImpl; |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 34 | StringMapEntry<MDString *> &Entry = |
| 35 | pImpl->MDStringCache.GetOrCreateValue(Str); |
| 36 | MDString *&S = Entry.getValue(); |
Nick Lewycky | 2353122 | 2009-11-26 22:54:26 +0000 | [diff] [blame] | 37 | if (!S) S = new MDString(Context, Entry.getKey()); |
| 38 | return S; |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 39 | } |
| 40 | |
Devang Patel | afa5a34 | 2009-11-12 00:50:58 +0000 | [diff] [blame] | 41 | MDString *MDString::get(LLVMContext &Context, const char *Str) { |
| 42 | LLVMContextImpl *pImpl = Context.pImpl; |
| 43 | StringMapEntry<MDString *> &Entry = |
| 44 | pImpl->MDStringCache.GetOrCreateValue(Str ? StringRef(Str) : StringRef()); |
| 45 | MDString *&S = Entry.getValue(); |
Nick Lewycky | 807d2fa | 2009-11-27 19:57:53 +0000 | [diff] [blame] | 46 | if (!S) S = new MDString(Context, Entry.getKey()); |
Nick Lewycky | 2353122 | 2009-11-26 22:54:26 +0000 | [diff] [blame] | 47 | return S; |
Devang Patel | afa5a34 | 2009-11-12 00:50:58 +0000 | [diff] [blame] | 48 | } |
| 49 | |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 50 | //===----------------------------------------------------------------------===// |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 51 | // MDNodeElement implementation. |
| 52 | // |
| 53 | |
| 54 | // Use CallbackVH to hold MDNode elements. |
| 55 | namespace llvm { |
| 56 | class MDNodeElement : public CallbackVH { |
| 57 | MDNode *Parent; |
| 58 | public: |
| 59 | MDNodeElement() {} |
| 60 | MDNodeElement(Value *V, MDNode *P) : CallbackVH(V), Parent(P) {} |
| 61 | ~MDNodeElement() {} |
| 62 | |
Chris Lattner | 1d880e5 | 2009-12-28 09:10:16 +0000 | [diff] [blame] | 63 | void set(Value *V, MDNode *P) { |
| 64 | setValPtr(V); |
| 65 | Parent = P; |
| 66 | } |
| 67 | |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 68 | virtual void deleted(); |
| 69 | virtual void allUsesReplacedWith(Value *NV); |
| 70 | }; |
| 71 | } // end namespace llvm. |
| 72 | |
| 73 | |
| 74 | void MDNodeElement::deleted() { |
Chris Lattner | df58389 | 2009-12-28 09:32:10 +0000 | [diff] [blame] | 75 | Parent->replaceElement(this, 0); |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | void MDNodeElement::allUsesReplacedWith(Value *NV) { |
Chris Lattner | df58389 | 2009-12-28 09:32:10 +0000 | [diff] [blame] | 79 | Parent->replaceElement(this, NV); |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 80 | } |
| 81 | |
| 82 | |
| 83 | |
| 84 | //===----------------------------------------------------------------------===// |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 85 | // MDNode implementation. |
Devang Patel | 0a9f7b9 | 2009-07-28 21:49:47 +0000 | [diff] [blame] | 86 | // |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 87 | |
Chris Lattner | f241018 | 2009-12-28 09:12:35 +0000 | [diff] [blame] | 88 | /// ~MDNode - Destroy MDNode. |
| 89 | MDNode::~MDNode() { |
| 90 | LLVMContextImpl *pImpl = getType()->getContext().pImpl; |
| 91 | pImpl->MDNodeSet.RemoveNode(this); |
| 92 | delete [] Operands; |
| 93 | Operands = NULL; |
| 94 | } |
| 95 | |
Victor Hernandez | 57c0f20 | 2009-12-16 02:52:09 +0000 | [diff] [blame] | 96 | MDNode::MDNode(LLVMContext &C, Value *const *Vals, unsigned NumVals, |
Victor Hernandez | 5d30162 | 2009-12-18 20:09:14 +0000 | [diff] [blame] | 97 | bool isFunctionLocal) |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 98 | : MetadataBase(Type::getMetadataTy(C), Value::MDNodeVal) { |
Chris Lattner | dfdb5dc | 2009-12-28 08:48:12 +0000 | [diff] [blame] | 99 | NumOperands = NumVals; |
| 100 | Operands = new MDNodeElement[NumOperands]; |
Chris Lattner | f241018 | 2009-12-28 09:12:35 +0000 | [diff] [blame] | 101 | |
Devang Patel | 49708ad | 2009-10-21 23:57:35 +0000 | [diff] [blame] | 102 | for (unsigned i = 0; i != NumVals; ++i) |
Chris Lattner | f241018 | 2009-12-28 09:12:35 +0000 | [diff] [blame] | 103 | Operands[i].set(Vals[i], this); |
Chris Lattner | dfdb5dc | 2009-12-28 08:48:12 +0000 | [diff] [blame] | 104 | |
Victor Hernandez | 5d30162 | 2009-12-18 20:09:14 +0000 | [diff] [blame] | 105 | if (isFunctionLocal) |
Chris Lattner | cafe9bb | 2009-12-29 02:14:09 +0000 | [diff] [blame] | 106 | setValueSubclassData(getSubclassDataFromValue() | FunctionLocalBit); |
Devang Patel | 0a9f7b9 | 2009-07-28 21:49:47 +0000 | [diff] [blame] | 107 | } |
| 108 | |
Victor Hernandez | 57c0f20 | 2009-12-16 02:52:09 +0000 | [diff] [blame] | 109 | MDNode *MDNode::get(LLVMContext &Context, Value*const* Vals, unsigned NumVals, |
Victor Hernandez | 5d30162 | 2009-12-18 20:09:14 +0000 | [diff] [blame] | 110 | bool isFunctionLocal) { |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 111 | LLVMContextImpl *pImpl = Context.pImpl; |
| 112 | FoldingSetNodeID ID; |
| 113 | for (unsigned i = 0; i != NumVals; ++i) |
| 114 | ID.AddPointer(Vals[i]); |
| 115 | |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 116 | void *InsertPoint; |
Nick Lewycky | 2353122 | 2009-11-26 22:54:26 +0000 | [diff] [blame] | 117 | MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint); |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 118 | if (!N) { |
| 119 | // InsertPoint will have been set by the FindNodeOrInsertPos call. |
Victor Hernandez | 5d30162 | 2009-12-18 20:09:14 +0000 | [diff] [blame] | 120 | N = new MDNode(Context, Vals, NumVals, isFunctionLocal); |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 121 | pImpl->MDNodeSet.InsertNode(N, InsertPoint); |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 122 | } |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 123 | return N; |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 124 | } |
| 125 | |
Chris Lattner | f241018 | 2009-12-28 09:12:35 +0000 | [diff] [blame] | 126 | void MDNode::Profile(FoldingSetNodeID &ID) const { |
| 127 | for (unsigned i = 0, e = getNumElements(); i != e; ++i) |
| 128 | ID.AddPointer(getElement(i)); |
Chris Lattner | 06ac32c | 2009-12-28 19:49:00 +0000 | [diff] [blame] | 129 | // HASH TABLE COLLISIONS? |
| 130 | // DO NOT REINSERT AFTER AN OPERAND DROPS TO NULL! |
Devang Patel | 4771e16 | 2009-08-03 22:51:10 +0000 | [diff] [blame] | 131 | } |
Devang Patel | ab67e70 | 2009-08-11 18:01:24 +0000 | [diff] [blame] | 132 | |
Chris Lattner | f241018 | 2009-12-28 09:12:35 +0000 | [diff] [blame] | 133 | |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 134 | /// getElement - Return specified element. |
| 135 | Value *MDNode::getElement(unsigned i) const { |
| 136 | assert(i < getNumElements() && "Invalid element number!"); |
Chris Lattner | dfdb5dc | 2009-12-28 08:48:12 +0000 | [diff] [blame] | 137 | return Operands[i]; |
Chris Lattner | c5e08a9 | 2009-12-28 07:41:54 +0000 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | |
| 141 | |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 142 | // Replace value from this node's element list. |
Chris Lattner | df58389 | 2009-12-28 09:32:10 +0000 | [diff] [blame] | 143 | void MDNode::replaceElement(MDNodeElement *Op, Value *To) { |
| 144 | Value *From = *Op; |
| 145 | |
| 146 | if (From == To) |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 147 | return; |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 148 | |
Chris Lattner | 4964257 | 2009-12-28 09:24:53 +0000 | [diff] [blame] | 149 | LLVMContextImpl *pImpl = getType()->getContext().pImpl; |
| 150 | |
| 151 | // Remove "this" from the context map. FoldingSet doesn't have to reprofile |
| 152 | // this node to remove it, so we don't care what state the operands are in. |
| 153 | pImpl->MDNodeSet.RemoveNode(this); |
Chris Lattner | df58389 | 2009-12-28 09:32:10 +0000 | [diff] [blame] | 154 | |
| 155 | // Update the operand. |
| 156 | Op->set(To, this); |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 157 | |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 158 | // Insert updated "this" into the context's folding node set. |
| 159 | // If a node with same element list already exist then before inserting |
| 160 | // updated "this" into the folding node set, replace all uses of existing |
| 161 | // node with updated "this" node. |
| 162 | FoldingSetNodeID ID; |
| 163 | Profile(ID); |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 164 | void *InsertPoint; |
| 165 | MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint); |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 166 | |
| 167 | if (N) { |
| 168 | N->replaceAllUsesWith(this); |
| 169 | delete N; |
Chris Lattner | 4964257 | 2009-12-28 09:24:53 +0000 | [diff] [blame] | 170 | N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint); |
| 171 | assert(N == 0 && "shouldn't be in the map now!"); (void)N; |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 172 | } |
| 173 | |
Chris Lattner | 4964257 | 2009-12-28 09:24:53 +0000 | [diff] [blame] | 174 | // InsertPoint will have been set by the FindNodeOrInsertPos call. |
| 175 | pImpl->MDNodeSet.InsertNode(this, InsertPoint); |
Devang Patel | 5f4ac84 | 2009-09-03 01:39:20 +0000 | [diff] [blame] | 176 | } |
| 177 | |
Devang Patel | f457d13 | 2009-07-29 00:33:07 +0000 | [diff] [blame] | 178 | //===----------------------------------------------------------------------===// |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 179 | // NamedMDNode implementation. |
Devang Patel | f457d13 | 2009-07-29 00:33:07 +0000 | [diff] [blame] | 180 | // |
Chris Lattner | 5710969 | 2009-12-28 08:07:14 +0000 | [diff] [blame] | 181 | static SmallVector<TrackingVH<MetadataBase>, 4> &getNMDOps(void *Operands) { |
| 182 | return *(SmallVector<TrackingVH<MetadataBase>, 4>*)Operands; |
| 183 | } |
| 184 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 185 | NamedMDNode::NamedMDNode(LLVMContext &C, const Twine &N, |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 186 | MetadataBase *const *MDs, |
Devang Patel | 5316bf0 | 2009-07-29 21:58:56 +0000 | [diff] [blame] | 187 | unsigned NumMDs, Module *ParentModule) |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 188 | : MetadataBase(Type::getMetadataTy(C), Value::NamedMDNodeVal), Parent(0) { |
Devang Patel | 28bc9d8 | 2009-07-29 17:16:17 +0000 | [diff] [blame] | 189 | setName(N); |
Chris Lattner | 5710969 | 2009-12-28 08:07:14 +0000 | [diff] [blame] | 190 | |
| 191 | Operands = new SmallVector<TrackingVH<MetadataBase>, 4>(); |
| 192 | |
| 193 | SmallVector<TrackingVH<MetadataBase>, 4> &Node = getNMDOps(Operands); |
Devang Patel | 49708ad | 2009-10-21 23:57:35 +0000 | [diff] [blame] | 194 | for (unsigned i = 0; i != NumMDs; ++i) |
Devang Patel | b5681b2 | 2009-10-22 18:25:28 +0000 | [diff] [blame] | 195 | Node.push_back(TrackingVH<MetadataBase>(MDs[i])); |
Devang Patel | 49708ad | 2009-10-21 23:57:35 +0000 | [diff] [blame] | 196 | |
Devang Patel | 5316bf0 | 2009-07-29 21:58:56 +0000 | [diff] [blame] | 197 | if (ParentModule) |
| 198 | ParentModule->getNamedMDList().push_back(this); |
Devang Patel | f457d13 | 2009-07-29 00:33:07 +0000 | [diff] [blame] | 199 | } |
Devang Patel | a82f883 | 2009-08-03 06:19:01 +0000 | [diff] [blame] | 200 | |
Devang Patel | ab67e70 | 2009-08-11 18:01:24 +0000 | [diff] [blame] | 201 | NamedMDNode *NamedMDNode::Create(const NamedMDNode *NMD, Module *M) { |
Chris Lattner | b2a33b46 | 2009-10-19 07:10:59 +0000 | [diff] [blame] | 202 | assert(NMD && "Invalid source NamedMDNode!"); |
Devang Patel | ab67e70 | 2009-08-11 18:01:24 +0000 | [diff] [blame] | 203 | SmallVector<MetadataBase *, 4> Elems; |
Chris Lattner | 5710969 | 2009-12-28 08:07:14 +0000 | [diff] [blame] | 204 | Elems.reserve(NMD->getNumElements()); |
| 205 | |
Devang Patel | ab67e70 | 2009-08-11 18:01:24 +0000 | [diff] [blame] | 206 | for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) |
| 207 | Elems.push_back(NMD->getElement(i)); |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 208 | return new NamedMDNode(NMD->getContext(), NMD->getName().data(), |
| 209 | Elems.data(), Elems.size(), M); |
Devang Patel | ab67e70 | 2009-08-11 18:01:24 +0000 | [diff] [blame] | 210 | } |
| 211 | |
Chris Lattner | 5710969 | 2009-12-28 08:07:14 +0000 | [diff] [blame] | 212 | NamedMDNode::~NamedMDNode() { |
| 213 | dropAllReferences(); |
| 214 | delete &getNMDOps(Operands); |
| 215 | } |
| 216 | |
| 217 | /// getNumElements - Return number of NamedMDNode elements. |
| 218 | unsigned NamedMDNode::getNumElements() const { |
| 219 | return (unsigned)getNMDOps(Operands).size(); |
| 220 | } |
| 221 | |
| 222 | /// getElement - Return specified element. |
| 223 | MetadataBase *NamedMDNode::getElement(unsigned i) const { |
| 224 | assert(i < getNumElements() && "Invalid element number!"); |
| 225 | return getNMDOps(Operands)[i]; |
| 226 | } |
| 227 | |
| 228 | /// addElement - Add metadata element. |
| 229 | void NamedMDNode::addElement(MetadataBase *M) { |
| 230 | getNMDOps(Operands).push_back(TrackingVH<MetadataBase>(M)); |
| 231 | } |
| 232 | |
Devang Patel | a82f883 | 2009-08-03 06:19:01 +0000 | [diff] [blame] | 233 | /// eraseFromParent - Drop all references and remove the node from parent |
| 234 | /// module. |
| 235 | void NamedMDNode::eraseFromParent() { |
Devang Patel | a82f883 | 2009-08-03 06:19:01 +0000 | [diff] [blame] | 236 | getParent()->getNamedMDList().erase(this); |
| 237 | } |
| 238 | |
| 239 | /// dropAllReferences - Remove all uses and clear node vector. |
| 240 | void NamedMDNode::dropAllReferences() { |
Chris Lattner | 5710969 | 2009-12-28 08:07:14 +0000 | [diff] [blame] | 241 | getNMDOps(Operands).clear(); |
Devang Patel | a82f883 | 2009-08-03 06:19:01 +0000 | [diff] [blame] | 242 | } |
| 243 | |
Devang Patel | 937b1e9 | 2009-09-16 18:09:00 +0000 | [diff] [blame] | 244 | |
| 245 | //===----------------------------------------------------------------------===// |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 246 | // MetadataContextImpl implementation. |
Devang Patel | 937b1e9 | 2009-09-16 18:09:00 +0000 | [diff] [blame] | 247 | // |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 248 | namespace llvm { |
| 249 | class MetadataContextImpl { |
| 250 | public: |
| 251 | typedef std::pair<unsigned, TrackingVH<MDNode> > MDPairTy; |
| 252 | typedef SmallVector<MDPairTy, 2> MDMapTy; |
| 253 | typedef DenseMap<const Instruction *, MDMapTy> MDStoreTy; |
| 254 | friend class BitcodeReader; |
| 255 | private: |
| 256 | |
| 257 | /// MetadataStore - Collection of metadata used in this context. |
| 258 | MDStoreTy MetadataStore; |
| 259 | |
| 260 | /// MDHandlerNames - Map to hold metadata handler names. |
| 261 | StringMap<unsigned> MDHandlerNames; |
| 262 | |
| 263 | public: |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 264 | // Name <-> ID mapping methods. |
Chris Lattner | 0eb4198 | 2009-12-28 20:45:51 +0000 | [diff] [blame] | 265 | unsigned getMDKindID(StringRef Name); |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 266 | void getMDKindNames(SmallVectorImpl<StringRef> &) const; |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 267 | |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 268 | |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 269 | // Instruction metadata methods. |
| 270 | MDNode *getMetadata(const Instruction *Inst, unsigned Kind); |
| 271 | void getAllMetadata(const Instruction *Inst, |
| 272 | SmallVectorImpl<std::pair<unsigned, MDNode*> > &MDs)const; |
| 273 | |
| 274 | void setMetadata(Instruction *Inst, unsigned Kind, MDNode *Node); |
| 275 | |
Chris Lattner | 508b19a | 2009-12-29 07:44:16 +0000 | [diff] [blame^] | 276 | /// removeAllMetadata - Remove all metadata attached to an instruction. |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 277 | void removeAllMetadata(Instruction *Inst); |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 278 | |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 279 | /// copyMD - If metadata is attached with Instruction In1 then attach |
| 280 | /// the same metadata to In2. |
| 281 | void copyMD(Instruction *In1, Instruction *In2); |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 282 | }; |
| 283 | } |
Devang Patel | 937b1e9 | 2009-09-16 18:09:00 +0000 | [diff] [blame] | 284 | |
Chris Lattner | 0eb4198 | 2009-12-28 20:45:51 +0000 | [diff] [blame] | 285 | /// getMDKindID - Return a unique non-zero ID for the specified metadata kind. |
| 286 | unsigned MetadataContextImpl::getMDKindID(StringRef Name) { |
| 287 | unsigned &Entry = MDHandlerNames[Name]; |
Devang Patel | 937b1e9 | 2009-09-16 18:09:00 +0000 | [diff] [blame] | 288 | |
Chris Lattner | 0eb4198 | 2009-12-28 20:45:51 +0000 | [diff] [blame] | 289 | // If this is new, assign it its ID. |
| 290 | if (Entry == 0) Entry = MDHandlerNames.size(); |
Chris Lattner | 0eb4198 | 2009-12-28 20:45:51 +0000 | [diff] [blame] | 291 | return Entry; |
Devang Patel | 937b1e9 | 2009-09-16 18:09:00 +0000 | [diff] [blame] | 292 | } |
| 293 | |
Devang Patel | d41fc65 | 2009-10-22 17:40:37 +0000 | [diff] [blame] | 294 | /// getHandlerNames - Populate client supplied smallvector using custome |
| 295 | /// metadata name and ID. |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 296 | void MetadataContextImpl:: |
Chris Lattner | 7d05c46 | 2009-12-28 20:10:43 +0000 | [diff] [blame] | 297 | getMDKindNames(SmallVectorImpl<StringRef> &Names) const { |
| 298 | Names.resize(MDHandlerNames.size()+1); |
| 299 | Names[0] = ""; |
Devang Patel | ce6a1c9 | 2009-10-22 01:01:24 +0000 | [diff] [blame] | 300 | for (StringMap<unsigned>::const_iterator I = MDHandlerNames.begin(), |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 301 | E = MDHandlerNames.end(); I != E; ++I) |
Devang Patel | 5a1033a | 2009-10-26 17:09:00 +0000 | [diff] [blame] | 302 | // MD Handlers are numbered from 1. |
Chris Lattner | 7d05c46 | 2009-12-28 20:10:43 +0000 | [diff] [blame] | 303 | Names[I->second] = I->first(); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 304 | } |
| 305 | |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 306 | |
| 307 | /// getMetadata - Get the metadata of given kind attached to an Instruction. |
| 308 | /// If the metadata is not found then return 0. |
| 309 | MDNode *MetadataContextImpl:: |
| 310 | getMetadata(const Instruction *Inst, unsigned MDKind) { |
| 311 | MDMapTy &Info = MetadataStore[Inst]; |
| 312 | assert(Inst->hasMetadata() && !Info.empty() && "Shouldn't have called this"); |
| 313 | |
| 314 | for (MDMapTy::iterator I = Info.begin(), E = Info.end(); I != E; ++I) |
| 315 | if (I->first == MDKind) |
| 316 | return I->second; |
| 317 | return 0; |
| 318 | } |
| 319 | |
| 320 | /// getAllMetadata - Get all of the metadata attached to an Instruction. |
| 321 | void MetadataContextImpl:: |
| 322 | getAllMetadata(const Instruction *Inst, |
| 323 | SmallVectorImpl<std::pair<unsigned, MDNode*> > &Result) const { |
| 324 | assert(Inst->hasMetadata() && MetadataStore.find(Inst) != MetadataStore.end() |
| 325 | && "Shouldn't have called this"); |
| 326 | const MDMapTy &Info = MetadataStore.find(Inst)->second; |
| 327 | assert(!Info.empty() && "Shouldn't have called this"); |
| 328 | |
| 329 | Result.clear(); |
| 330 | Result.append(Info.begin(), Info.end()); |
| 331 | |
| 332 | // Sort the resulting array so it is stable. |
| 333 | if (Result.size() > 1) |
| 334 | array_pod_sort(Result.begin(), Result.end()); |
| 335 | } |
| 336 | |
| 337 | |
| 338 | void MetadataContextImpl::setMetadata(Instruction *Inst, unsigned Kind, |
| 339 | MDNode *Node) { |
| 340 | // Handle the case when we're adding/updating metadata on an instruction. |
| 341 | if (Node) { |
| 342 | MDMapTy &Info = MetadataStore[Inst]; |
Chris Lattner | b2406d9 | 2009-12-29 02:46:09 +0000 | [diff] [blame] | 343 | assert(!Info.empty() == Inst->hasMetadata() && "HasMetadata bit is wonked"); |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 344 | if (Info.empty()) { |
Chris Lattner | b2406d9 | 2009-12-29 02:46:09 +0000 | [diff] [blame] | 345 | Inst->setHasMetadata(true); |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 346 | } else { |
| 347 | // Handle replacement of an existing value. |
| 348 | for (unsigned i = 0, e = Info.size(); i != e; ++i) |
| 349 | if (Info[i].first == Kind) { |
| 350 | Info[i].second = Node; |
| 351 | return; |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | // No replacement, just add it to the list. |
| 356 | Info.push_back(std::make_pair(Kind, Node)); |
| 357 | return; |
| 358 | } |
| 359 | |
| 360 | // Otherwise, we're removing metadata from an instruction. |
Chris Lattner | b2406d9 | 2009-12-29 02:46:09 +0000 | [diff] [blame] | 361 | assert(Inst->hasMetadata() && MetadataStore.count(Inst) && |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 362 | "HasMetadata bit out of date!"); |
| 363 | MDMapTy &Info = MetadataStore[Inst]; |
| 364 | |
| 365 | // Common case is removing the only entry. |
| 366 | if (Info.size() == 1 && Info[0].first == Kind) { |
| 367 | MetadataStore.erase(Inst); |
Chris Lattner | b2406d9 | 2009-12-29 02:46:09 +0000 | [diff] [blame] | 368 | Inst->setHasMetadata(false); |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 369 | return; |
| 370 | } |
| 371 | |
| 372 | // Handle replacement of an existing value. |
| 373 | for (unsigned i = 0, e = Info.size(); i != e; ++i) |
| 374 | if (Info[i].first == Kind) { |
| 375 | Info[i] = Info.back(); |
| 376 | Info.pop_back(); |
| 377 | assert(!Info.empty() && "Removing last entry should be handled above"); |
| 378 | return; |
| 379 | } |
| 380 | // Otherwise, removing an entry that doesn't exist on the instruction. |
| 381 | } |
| 382 | |
| 383 | /// removeAllMetadata - Remove all metadata attached with an instruction. |
| 384 | void MetadataContextImpl::removeAllMetadata(Instruction *Inst) { |
| 385 | MetadataStore.erase(Inst); |
Chris Lattner | b2406d9 | 2009-12-29 02:46:09 +0000 | [diff] [blame] | 386 | Inst->setHasMetadata(false); |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 387 | } |
| 388 | |
| 389 | |
| 390 | /// copyMD - If metadata is attached with Instruction In1 then attach |
| 391 | /// the same metadata to In2. |
| 392 | void MetadataContextImpl::copyMD(Instruction *In1, Instruction *In2) { |
| 393 | assert(In1 && In2 && "Invalid instruction!"); |
| 394 | MDMapTy &In1Info = MetadataStore[In1]; |
| 395 | if (In1Info.empty()) |
| 396 | return; |
| 397 | |
| 398 | for (MDMapTy::iterator I = In1Info.begin(), E = In1Info.end(); I != E; ++I) |
| 399 | In2->setMetadata(I->first, I->second); |
| 400 | } |
| 401 | |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 402 | //===----------------------------------------------------------------------===// |
| 403 | // MetadataContext implementation. |
| 404 | // |
Chris Lattner | 06ac32c | 2009-12-28 19:49:00 +0000 | [diff] [blame] | 405 | MetadataContext::MetadataContext() : pImpl(new MetadataContextImpl()) { } |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 406 | MetadataContext::~MetadataContext() { delete pImpl; } |
| 407 | |
| 408 | /// isValidName - Return true if Name is a valid custom metadata handler name. |
| 409 | bool MetadataContext::isValidName(StringRef MDName) { |
| 410 | if (MDName.empty()) |
| 411 | return false; |
| 412 | |
| 413 | if (!isalpha(MDName[0])) |
| 414 | return false; |
| 415 | |
| 416 | for (StringRef::iterator I = MDName.begin() + 1, E = MDName.end(); I != E; |
| 417 | ++I) { |
| 418 | if (!isalnum(*I) && *I != '_' && *I != '-' && *I != '.') |
| 419 | return false; |
| 420 | } |
| 421 | return true; |
| 422 | } |
| 423 | |
Chris Lattner | 0eb4198 | 2009-12-28 20:45:51 +0000 | [diff] [blame] | 424 | /// getMDKindID - Return a unique non-zero ID for the specified metadata kind. |
| 425 | unsigned MetadataContext::getMDKindID(StringRef Name) const { |
| 426 | return pImpl->getMDKindID(Name); |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 427 | } |
| 428 | |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 429 | /// copyMD - If metadata is attached with Instruction In1 then attach |
| 430 | /// the same metadata to In2. |
| 431 | void MetadataContext::copyMD(Instruction *In1, Instruction *In2) { |
| 432 | pImpl->copyMD(In1, In2); |
| 433 | } |
| 434 | |
| 435 | /// getHandlerNames - Populate client supplied smallvector using custome |
| 436 | /// metadata name and ID. |
Chris Lattner | 7d05c46 | 2009-12-28 20:10:43 +0000 | [diff] [blame] | 437 | void MetadataContext::getMDKindNames(SmallVectorImpl<StringRef> &N) const { |
| 438 | pImpl->getMDKindNames(N); |
Devang Patel | 9d89df1 | 2009-10-22 19:36:54 +0000 | [diff] [blame] | 439 | } |
| 440 | |
Chris Lattner | 3990b12 | 2009-12-28 23:41:32 +0000 | [diff] [blame] | 441 | //===----------------------------------------------------------------------===// |
| 442 | // Instruction Metadata method implementations. |
| 443 | // |
| 444 | |
| 445 | void Instruction::setMetadata(const char *Kind, MDNode *Node) { |
| 446 | if (Node == 0 && !hasMetadata()) return; |
| 447 | setMetadata(getContext().getMetadata().getMDKindID(Kind), Node); |
| 448 | } |
| 449 | |
| 450 | MDNode *Instruction::getMetadataImpl(const char *Kind) const { |
| 451 | return getMetadataImpl(getContext().getMetadata().getMDKindID(Kind)); |
| 452 | } |
| 453 | |
| 454 | /// setMetadata - Set the metadata of of the specified kind to the specified |
| 455 | /// node. This updates/replaces metadata if already present, or removes it if |
| 456 | /// Node is null. |
| 457 | void Instruction::setMetadata(unsigned KindID, MDNode *Node) { |
| 458 | if (Node == 0 && !hasMetadata()) return; |
| 459 | |
| 460 | getContext().getMetadata().pImpl->setMetadata(this, KindID, Node); |
| 461 | } |
| 462 | |
| 463 | MDNode *Instruction::getMetadataImpl(unsigned KindID) const { |
| 464 | return getContext().getMetadata().pImpl->getMetadata(this, KindID); |
| 465 | } |
| 466 | |
| 467 | void Instruction::getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, |
| 468 | MDNode*> > &Result)const { |
| 469 | getContext().getMetadata().pImpl->getAllMetadata(this, Result); |
| 470 | } |
| 471 | |
Chris Lattner | 508b19a | 2009-12-29 07:44:16 +0000 | [diff] [blame^] | 472 | /// removeAllMetadata - Remove all metadata from this instruction. |
| 473 | void Instruction::removeAllMetadata() { |
| 474 | assert(hasMetadata() && "Caller should check"); |
| 475 | getContext().getMetadata().pImpl->removeAllMetadata(this); |
| 476 | } |
| 477 | |