10a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel//===-- Metadata.cpp - Implement Metadata classes -------------------------===// 20a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// 30a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// The LLVM Compiler Infrastructure 40a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// 50a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// This file is distributed under the University of Illinois Open Source 60a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// License. See LICENSE.TXT for details. 70a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// 80a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel//===----------------------------------------------------------------------===// 90a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// 100a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// This file implements the Metadata classes. 110a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// 120a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel//===----------------------------------------------------------------------===// 130a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel 140b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Metadata.h" 1537da0ad07bfd5e3856ce5d182b27b4c499c03c9aChris Lattner#include "LLVMContextImpl.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "SymbolTableListTraitsImpl.h" 179d89df169027035bf692b3d397bb93cff7bdc860Devang Patel#include "llvm/ADT/DenseMap.h" 181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner#include "llvm/ADT/STLExtras.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallString.h" 20d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/StringMap.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instruction.h" 220b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/LLVMContext.h" 230b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 247b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel#include "llvm/Support/ConstantRange.h" 25489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman#include "llvm/Support/LeakDetector.h" 2637da0ad07bfd5e3856ce5d182b27b4c499c03c9aChris Lattner#include "llvm/Support/ValueHandle.h" 270a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patelusing namespace llvm; 280a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel 290a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel//===----------------------------------------------------------------------===// 30b2a33b46469a6d2c0e61122002079efb7d6d3f9cChris Lattner// MDString implementation. 31647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson// 325e9cd434234a36089daeee915f1dc02b96947fbaChris Lattner 332d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid MDString::anchor() { } 342d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 353ecb447f52d169dea6663b95b5b5b43e9bb5826bBill WendlingMDString::MDString(LLVMContext &C) 363ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling : Value(Type::getMetadataTy(C), Value::MDStringVal) {} 375e9cd434234a36089daeee915f1dc02b96947fbaChris Lattner 3849b63a1f2c493f6452d22cf0df4c147e0539fb2eDevang PatelMDString *MDString::get(LLVMContext &Context, StringRef Str) { 39647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson LLVMContextImpl *pImpl = Context.pImpl; 403ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling StringMapEntry<Value*> &Entry = 41647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson pImpl->MDStringCache.GetOrCreateValue(Str); 423ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling Value *&S = Entry.getValue(); 433ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling if (!S) S = new MDString(Context); 443ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling S->setValueName(&Entry); 453ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling return cast<MDString>(S); 46647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson} 47647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson 48647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson//===----------------------------------------------------------------------===// 495d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner// MDNodeOperand implementation. 50c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner// 51c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 525d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner// Use CallbackVH to hold MDNode operands. 53c5e08a963973f43c10869cd249c0718d307dd031Chris Lattnernamespace llvm { 545d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnerclass MDNodeOperand : public CallbackVH { 5569b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling MDNode *getParent() { 5669b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling MDNodeOperand *Cur = this; 5769b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling 5869b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling while (Cur->getValPtrInt() != 1) 5969b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling --Cur; 6069b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling 6169b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling assert(Cur->getValPtrInt() == 1 && 6269b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling "Couldn't find the beginning of the operand list!"); 6369b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling return reinterpret_cast<MDNode*>(Cur) - 1; 6469b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling } 6569b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling 66c5e08a963973f43c10869cd249c0718d307dd031Chris Lattnerpublic: 6769b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling MDNodeOperand(Value *V) : CallbackVH(V) {} 685d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner ~MDNodeOperand() {} 690d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 704866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling void set(Value *V) { 714866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling unsigned IsFirst = this->getValPtrInt(); 724866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling this->setValPtr(V); 734866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling this->setAsFirstOperand(IsFirst); 744866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling } 7569b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling 7669b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling /// setAsFirstOperand - Accessor method to mark the operand as the first in 7769b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling /// the list. 7869b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling void setAsFirstOperand(unsigned V) { this->setValPtrInt(V); } 790d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 80c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner virtual void deleted(); 81c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner virtual void allUsesReplacedWith(Value *NV); 82c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner}; 83c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner} // end namespace llvm. 84c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 85c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 865d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnervoid MDNodeOperand::deleted() { 8769b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling getParent()->replaceOperand(this, 0); 88c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner} 89c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 905d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnervoid MDNodeOperand::allUsesReplacedWith(Value *NV) { 9169b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling getParent()->replaceOperand(this, NV); 92c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner} 93c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 94c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner//===----------------------------------------------------------------------===// 95b2a33b46469a6d2c0e61122002079efb7d6d3f9cChris Lattner// MDNode implementation. 960a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel// 97c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 985d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// getOperandPtr - Helper function to get the MDNodeOperand's coallocated on 99b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner/// the end of the MDNode. 1005d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnerstatic MDNodeOperand *getOperandPtr(MDNode *N, unsigned Op) { 101ac80975ea4103fcceab38cde69d98d3fb3b01db4Dan Gohman // Use <= instead of < to permit a one-past-the-end address. 102ac80975ea4103fcceab38cde69d98d3fb3b01db4Dan Gohman assert(Op <= N->getNumOperands() && "Invalid operand number"); 1034866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling return reinterpret_cast<MDNodeOperand*>(N + 1) + Op; 104b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner} 105b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner 106f32a960fd32b32f84bb486458ccbc905af490da9Eric Christophervoid MDNode::replaceOperandWith(unsigned i, Value *Val) { 107f32a960fd32b32f84bb486458ccbc905af490da9Eric Christopher MDNodeOperand *Op = getOperandPtr(this, i); 108f32a960fd32b32f84bb486458ccbc905af490da9Eric Christopher replaceOperand(Op, Val); 109f32a960fd32b32f84bb486458ccbc905af490da9Eric Christopher} 110f32a960fd32b32f84bb486458ccbc905af490da9Eric Christopher 111ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay FoadMDNode::MDNode(LLVMContext &C, ArrayRef<Value*> Vals, bool isFunctionLocal) 112bc5201f8371f9041e79efcca3b158335da5c2604Devang Patel: Value(Type::getMetadataTy(C), Value::MDNodeVal) { 113ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad NumOperands = Vals.size(); 1140d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 115b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner if (isFunctionLocal) 116b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner setValueSubclassData(getSubclassDataFromValue() | FunctionLocalBit); 117b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner 118b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner // Initialize the operand list, which is co-allocated on the end of the node. 119ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad unsigned i = 0; 1205d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner for (MDNodeOperand *Op = getOperandPtr(this, 0), *E = Op+NumOperands; 12169b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling Op != E; ++Op, ++i) { 12269b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling new (Op) MDNodeOperand(Vals[i]); 12369b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling 12469b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling // Mark the first MDNodeOperand as being the first in the list of operands. 12569b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling if (i == 0) 12669b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling Op->setAsFirstOperand(1); 12769b2c71abb3fa17612ebfb1fb804b656ea47ab8fBill Wendling } 128b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner} 129b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner 130f2410180d07cb1ca074ad2a9b8538bc64895e68bChris Lattner/// ~MDNode - Destroy MDNode. 131f2410180d07cb1ca074ad2a9b8538bc64895e68bChris LattnerMDNode::~MDNode() { 1320d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov assert((getSubclassDataFromValue() & DestroyFlag) != 0 && 133b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner "Not being destroyed through destroy()?"); 1346f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin LLVMContextImpl *pImpl = getType()->getContext().pImpl; 1356f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin if (isNotUniqued()) { 1366f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin pImpl->NonUniquedMDNodes.erase(this); 1376f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin } else { 13854a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner pImpl->MDNodeSet.RemoveNode(this); 13954a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner } 1400d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 141b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner // Destroy the operands. 1425d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner for (MDNodeOperand *Op = getOperandPtr(this, 0), *E = Op+NumOperands; 143b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner Op != E; ++Op) 1445d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner Op->~MDNodeOperand(); 145f2410180d07cb1ca074ad2a9b8538bc64895e68bChris Lattner} 146f2410180d07cb1ca074ad2a9b8538bc64895e68bChris Lattner 1478fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandezstatic const Function *getFunctionForValue(Value *V) { 1488fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandez if (!V) return NULL; 149203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (Instruction *I = dyn_cast<Instruction>(V)) { 150203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands BasicBlock *BB = I->getParent(); 151203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands return BB ? BB->getParent() : 0; 152203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands } 153d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner if (Argument *A = dyn_cast<Argument>(V)) 154d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner return A->getParent(); 155203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) 156203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands return BB->getParent(); 157203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (MDNode *MD = dyn_cast<MDNode>(V)) 158203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands return MD->getFunction(); 1598fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandez return NULL; 1608fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandez} 1618fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandez 162e05f66ef2e37bcbd88acaeef2bf14ddb1f04488fVictor Hernandez#ifndef NDEBUG 1638fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandezstatic const Function *assertLocalFunction(const MDNode *N) { 164d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner if (!N->isFunctionLocal()) return 0; 165e05f66ef2e37bcbd88acaeef2bf14ddb1f04488fVictor Hernandez 1666db2389d694a5cd8560bc47676a7f3aeba928e73Devang Patel // FIXME: This does not handle cyclic function local metadata. 167d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner const Function *F = 0, *NewF = 0; 168c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { 1698fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandez if (Value *V = N->getOperand(i)) { 170d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner if (MDNode *MD = dyn_cast<MDNode>(V)) 171d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner NewF = assertLocalFunction(MD); 172d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner else 173d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner NewF = getFunctionForValue(V); 17454630e1cef710e65751e2147cbdd2e018292c435Victor Hernandez } 175d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner if (F == 0) 176d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner F = NewF; 177d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner else 178d3a6d90da74a59150ad781feb7cae0406c13e324Chris Lattner assert((NewF == 0 || F == NewF) &&"inconsistent function-local metadata"); 179c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez } 180c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez return F; 181c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez} 18254630e1cef710e65751e2147cbdd2e018292c435Victor Hernandez#endif 183c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez 184c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez// getFunction - If this metadata is function-local and recursively has a 185c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez// function-local operand, return the first such operand's parent function. 1866cead7879aa8902905809e3853d31093a5511c2fVictor Hernandez// Otherwise, return null. getFunction() should not be used for performance- 1876cead7879aa8902905809e3853d31093a5511c2fVictor Hernandez// critical code because it recursively visits all the MDNode's operands. 1888fffff537194e2375e65600f27d716c99f0eb38aVictor Hernandezconst Function *MDNode::getFunction() const { 18954630e1cef710e65751e2147cbdd2e018292c435Victor Hernandez#ifndef NDEBUG 19054630e1cef710e65751e2147cbdd2e018292c435Victor Hernandez return assertLocalFunction(this); 1914d6ccb5f68cd7c6418a209f1fa4dbade569e4493David Blaikie#else 192c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez if (!isFunctionLocal()) return NULL; 193d29f5282e06a395e696130d57aa3b1e0c73a60d4Duncan Sands for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 194d29f5282e06a395e696130d57aa3b1e0c73a60d4Duncan Sands if (const Function *F = getFunctionForValue(getOperand(i))) 195d29f5282e06a395e696130d57aa3b1e0c73a60d4Duncan Sands return F; 19654630e1cef710e65751e2147cbdd2e018292c435Victor Hernandez return NULL; 1974d6ccb5f68cd7c6418a209f1fa4dbade569e4493David Blaikie#endif 198c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez} 199c7650b4d1907becbf2ed112074fd2c4a6f174aa8Victor Hernandez 200b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner// destroy - Delete this node. Only when there are no uses. 201b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattnervoid MDNode::destroy() { 202b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner setValueSubclassData(getSubclassDataFromValue() | DestroyFlag); 203a61d3a98c47b009274530830b2489d49ce215dbbEric Christopher // Placement delete, then free the memory. 204b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner this->~MDNode(); 205b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner free(this); 2060a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel} 2070a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel 208f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner/// isFunctionLocalValue - Return true if this is a value that would require a 209f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner/// function-local MDNode. 210f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattnerstatic bool isFunctionLocalValue(Value *V) { 211f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner return isa<Instruction>(V) || isa<Argument>(V) || isa<BasicBlock>(V) || 212f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner (isa<MDNode>(V) && cast<MDNode>(V)->isFunctionLocal()); 213f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner} 214f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner 215ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay FoadMDNode *MDNode::getMDNode(LLVMContext &Context, ArrayRef<Value*> Vals, 216ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad FunctionLocalness FL, bool Insert) { 2175f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel LLVMContextImpl *pImpl = Context.pImpl; 2187548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman 2197548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman // Add all the operand pointers. Note that we don't have to add the 2207548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman // isFunctionLocal bit because that's implied by the operands. 22156b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // Note that if the operands are later nulled out, the node will be 22256b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // removed from the uniquing map. 2237548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman FoldingSetNodeID ID; 224ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad for (unsigned i = 0; i != Vals.size(); ++i) 2257548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman ID.AddPointer(Vals[i]); 2267548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman 2277548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman void *InsertPoint; 2284000afe712a7fd9e584919c43d2aa09b154946c1Duncan Sands MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint); 2294000afe712a7fd9e584919c43d2aa09b154946c1Duncan Sands 2304000afe712a7fd9e584919c43d2aa09b154946c1Duncan Sands if (N || !Insert) 2317548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman return N; 2324000afe712a7fd9e584919c43d2aa09b154946c1Duncan Sands 233e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez bool isFunctionLocal = false; 234e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez switch (FL) { 235e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez case FL_Unknown: 236ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad for (unsigned i = 0; i != Vals.size(); ++i) { 237e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez Value *V = Vals[i]; 238e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez if (!V) continue; 239f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner if (isFunctionLocalValue(V)) { 240e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez isFunctionLocal = true; 241e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez break; 24224e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez } 24324e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez } 244e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez break; 245e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez case FL_No: 246e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez isFunctionLocal = false; 247e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez break; 248e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez case FL_Yes: 249e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez isFunctionLocal = true; 250e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez break; 251e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez } 25224e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez 253e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez // Coallocate space for the node and Operands together, then placement new. 2544866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling void *Ptr = malloc(sizeof(MDNode) + Vals.size() * sizeof(MDNodeOperand)); 255ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad N = new (Ptr) MDNode(Context, Vals, isFunctionLocal); 256e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez 257611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer // Cache the operand hash. 258611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer N->Hash = ID.ComputeHash(); 259611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer 260e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez // InsertPoint will have been set by the FindNodeOrInsertPos call. 261e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez pImpl->MDNodeSet.InsertNode(N, InsertPoint); 2620d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 2635f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel return N; 264647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson} 265647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson 266566bd12e54247b96823112e945e67ed7b9b7dce0Devang PatelMDNode *MDNode::get(LLVMContext &Context, ArrayRef<Value*> Vals) { 267ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad return getMDNode(Context, Vals, FL_Unknown); 26824e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez} 26924e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez 270ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay FoadMDNode *MDNode::getWhenValsUnresolved(LLVMContext &Context, 271ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad ArrayRef<Value*> Vals, 272ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad bool isFunctionLocal) { 273ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad return getMDNode(Context, Vals, isFunctionLocal ? FL_Yes : FL_No); 27424e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez} 27524e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez 276ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay FoadMDNode *MDNode::getIfExists(LLVMContext &Context, ArrayRef<Value*> Vals) { 277ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad return getMDNode(Context, Vals, FL_Unknown, false); 278e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez} 279e685f230b6f4f7cd65f45e07cbbbcaa4d66a1ceaVictor Hernandez 280ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay FoadMDNode *MDNode::getTemporary(LLVMContext &Context, ArrayRef<Value*> Vals) { 281ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad MDNode *N = 2824866363304bdde4ad6204b1aa312395c6cc8221eBill Wendling (MDNode *)malloc(sizeof(MDNode) + Vals.size() * sizeof(MDNodeOperand)); 283ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad N = new (N) MDNode(Context, Vals, FL_No); 284489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman N->setValueSubclassData(N->getSubclassDataFromValue() | 285489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman NotUniquedBit); 286489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman LeakDetector::addGarbageObject(N); 287489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman return N; 288489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman} 289489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman 290489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohmanvoid MDNode::deleteTemporary(MDNode *N) { 291489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman assert(N->use_empty() && "Temporary MDNode has uses!"); 292990bdd50d17f8a05c14392cc402a7e098fd2505fDan Gohman assert(!N->getContext().pImpl->MDNodeSet.RemoveNode(N) && 29397cfa7dc0aca6cc88f5c0033a1b848f883329055Dan Gohman "Deleting a non-temporary uniqued node!"); 29497cfa7dc0aca6cc88f5c0033a1b848f883329055Dan Gohman assert(!N->getContext().pImpl->NonUniquedMDNodes.erase(N) && 29597cfa7dc0aca6cc88f5c0033a1b848f883329055Dan Gohman "Deleting a non-temporary non-uniqued node!"); 296489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman assert((N->getSubclassDataFromValue() & NotUniquedBit) && 297489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman "Temporary MDNode does not have NotUniquedBit set!"); 298489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman assert((N->getSubclassDataFromValue() & DestroyFlag) == 0 && 299990bdd50d17f8a05c14392cc402a7e098fd2505fDan Gohman "Temporary MDNode has DestroyFlag set!"); 300489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman LeakDetector::removeGarbageObject(N); 3019dd3e92e1d73b8aee01861b22447898cba9f89bcBenjamin Kramer N->destroy(); 302489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman} 303489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman 3045d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// getOperand - Return specified operand. 3055d0cacdbb6577f2449986f345858db17dc1bcf59Chris LattnerValue *MDNode::getOperand(unsigned i) const { 306eda774a6c682bc39610130cf8a183e656230c9efDavid Blaikie assert(i < getNumOperands() && "Invalid operand number"); 307b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner return *getOperandPtr(const_cast<MDNode*>(this), i); 308c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner} 309c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 310b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattnervoid MDNode::Profile(FoldingSetNodeID &ID) const { 3117548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman // Add all the operand pointers. Note that we don't have to add the 3127548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman // isFunctionLocal bit because that's implied by the operands. 31356b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // Note that if the operands are later nulled out, the node will be 31456b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // removed from the uniquing map. 3155d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 3165d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner ID.AddPointer(getOperand(i)); 317b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner} 318c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 3196f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskinvoid MDNode::setIsNotUniqued() { 3206f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin setValueSubclassData(getSubclassDataFromValue() | NotUniquedBit); 3216f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin LLVMContextImpl *pImpl = getType()->getContext().pImpl; 3226f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin pImpl->NonUniquedMDNodes.insert(this); 32306fdaccc89d9abdc7e03797b25173791a2f5692fDevang Patel} 324c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 3255d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner// Replace value from this node's operand list. 3265d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnervoid MDNode::replaceOperand(MDNodeOperand *Op, Value *To) { 327df58389ef1fb8373d900975a6a66e4fbe0344f83Chris Lattner Value *From = *Op; 3280d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 329f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // If is possible that someone did GV->RAUW(inst), replacing a global variable 330f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // with an instruction or some other function-local object. If this is a 331f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // non-function-local MDNode, it can't point to a function-local object. 332f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // Handle this case by implicitly dropping the MDNode reference to null. 333203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands // Likewise if the MDNode is function-local but for a different function. 334203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (To && isFunctionLocalValue(To)) { 335203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (!isFunctionLocal()) 336203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands To = 0; 337203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands else { 338203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands const Function *F = getFunction(); 339203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands const Function *FV = getFunctionForValue(To); 340203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands // Metadata can be function-local without having an associated function. 341203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands // So only consider functions to have changed if non-null. 342203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (F && FV && F != FV) 343203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands To = 0; 344203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands } 345203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands } 346f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner 347df58389ef1fb8373d900975a6a66e4fbe0344f83Chris Lattner if (From == To) 3485f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel return; 3495f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel 35054a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // Update the operand. 351b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner Op->set(To); 35254a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner 35354a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // If this node is already not being uniqued (because one of the operands 35454a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // already went to null), then there is nothing else to do here. 35554a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner if (isNotUniqued()) return; 3560d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 357496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner LLVMContextImpl *pImpl = getType()->getContext().pImpl; 358496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner 359496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner // Remove "this" from the context map. FoldingSet doesn't have to reprofile 360496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner // this node to remove it, so we don't care what state the operands are in. 361496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner pImpl->MDNodeSet.RemoveNode(this); 362df58389ef1fb8373d900975a6a66e4fbe0344f83Chris Lattner 36354a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // If we are dropping an argument to null, we choose to not unique the MDNode 36454a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // anymore. This commonly occurs during destruction, and uniquing these 36556b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // brings little reuse. Also, this means we don't need to include 36656b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // isFunctionLocal bits in FoldingSetNodeIDs for MDNodes. 36754a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner if (To == 0) { 36854a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner setIsNotUniqued(); 36954a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner return; 37054a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner } 3710d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 37254a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // Now that the node is out of the folding set, get ready to reinsert it. 37354a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // First, check to see if another node with the same operands already exists 374f53458f693fcf813b4c6c785034141017bf35893Dan Gohman // in the set. If so, then this node is redundant. 3755f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel FoldingSetNodeID ID; 3765f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel Profile(ID); 3775f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel void *InsertPoint; 378f375ebeed674ccf850d6647a3aaa979e4621896dDan Gohman if (MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint)) { 379f53458f693fcf813b4c6c785034141017bf35893Dan Gohman replaceAllUsesWith(N); 380f53458f693fcf813b4c6c785034141017bf35893Dan Gohman destroy(); 381f53458f693fcf813b4c6c785034141017bf35893Dan Gohman return; 3825f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel } 3835f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel 384611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer // Cache the operand hash. 385611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer Hash = ID.ComputeHash(); 386496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner // InsertPoint will have been set by the FindNodeOrInsertPos call. 387496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner pImpl->MDNodeSet.InsertNode(this, InsertPoint); 3885781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman 3895781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman // If this MDValue was previously function-local but no longer is, clear 3905781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman // its function-local flag. 3915781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (isFunctionLocal() && !isFunctionLocalValue(To)) { 3925781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman bool isStillFunctionLocal = false; 3935781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 3945781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman Value *V = getOperand(i); 3955781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (!V) continue; 3965781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (isFunctionLocalValue(V)) { 3975781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman isStillFunctionLocal = true; 3985781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman break; 3995781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman } 4005781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman } 4015781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (!isStillFunctionLocal) 4025781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman setValueSubclassData(getSubclassDataFromValue() & ~FunctionLocalBit); 4035781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman } 4045f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel} 4055f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel 4067b4ff9343d911a1b9c76c512787beb7a45f8270dHal FinkelMDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) { 4077b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!A || !B) 4087b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 4097b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4107b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APFloat AVal = cast<ConstantFP>(A->getOperand(0))->getValueAPF(); 4117b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APFloat BVal = cast<ConstantFP>(B->getOperand(0))->getValueAPF(); 4127b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (AVal.compare(BVal) == APFloat::cmpLessThan) 4137b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A; 4147b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return B; 4157b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4167b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4177b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkelstatic bool isContiguous(const ConstantRange &A, const ConstantRange &B) { 4187b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A.getUpper() == B.getLower() || A.getLower() == B.getUpper(); 4197b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4207b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4217b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkelstatic bool canBeMerged(const ConstantRange &A, const ConstantRange &B) { 4227b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return !A.intersectWith(B).isEmptySet() || isContiguous(A, B); 4237b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4247b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 425a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topperstatic bool tryMergeRange(SmallVectorImpl<Value *> &EndPoints, ConstantInt *Low, 4267b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *High) { 4277b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange NewRange(Low->getValue(), High->getValue()); 4287b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel unsigned Size = EndPoints.size(); 4297b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APInt LB = cast<ConstantInt>(EndPoints[Size - 2])->getValue(); 4307b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APInt LE = cast<ConstantInt>(EndPoints[Size - 1])->getValue(); 4317b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange LastRange(LB, LE); 4327b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (canBeMerged(NewRange, LastRange)) { 4337b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange Union = LastRange.unionWith(NewRange); 4347b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel Type *Ty = High->getType(); 4357b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints[Size - 2] = ConstantInt::get(Ty, Union.getLower()); 4367b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints[Size - 1] = ConstantInt::get(Ty, Union.getUpper()); 4377b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return true; 4387b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4397b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return false; 4407b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4417b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 442a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topperstatic void addRange(SmallVectorImpl<Value *> &EndPoints, ConstantInt *Low, 4437b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *High) { 4447b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!EndPoints.empty()) 4457b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (tryMergeRange(EndPoints, Low, High)) 4467b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return; 4477b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4487b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints.push_back(Low); 4497b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints.push_back(High); 4507b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4517b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4527b4ff9343d911a1b9c76c512787beb7a45f8270dHal FinkelMDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) { 4537b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // Given two ranges, we want to compute the union of the ranges. This 4547b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // is slightly complitade by having to combine the intervals and merge 4557b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // the ones that overlap. 4567b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4577b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!A || !B) 4587b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 4597b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4607b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (A == B) 4617b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A; 4627b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4637b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // First, walk both lists in older of the lower boundary of each interval. 4647b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // At each step, try to merge the new interval to the last one we adedd. 4657b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel SmallVector<Value*, 4> EndPoints; 4667b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int AI = 0; 4677b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int BI = 0; 4687b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int AN = A->getNumOperands() / 2; 4697b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int BN = B->getNumOperands() / 2; 4707b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (AI < AN && BI < BN) { 4717b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *ALow = cast<ConstantInt>(A->getOperand(2 * AI)); 4727b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *BLow = cast<ConstantInt>(B->getOperand(2 * BI)); 4737b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4747b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (ALow->getValue().slt(BLow->getValue())) { 4757b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, ALow, cast<ConstantInt>(A->getOperand(2 * AI + 1))); 4767b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++AI; 4777b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } else { 4787b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, BLow, cast<ConstantInt>(B->getOperand(2 * BI + 1))); 4797b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++BI; 4807b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4817b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4827b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (AI < AN) { 4837b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, cast<ConstantInt>(A->getOperand(2 * AI)), 4847b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel cast<ConstantInt>(A->getOperand(2 * AI + 1))); 4857b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++AI; 4867b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4877b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (BI < BN) { 4887b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, cast<ConstantInt>(B->getOperand(2 * BI)), 4897b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel cast<ConstantInt>(B->getOperand(2 * BI + 1))); 4907b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++BI; 4917b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4927b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4937b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // If we have more than 2 ranges (4 endpoints) we have to try to merge 4947b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // the last and first ones. 4957b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel unsigned Size = EndPoints.size(); 4967b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (Size > 4) { 4977b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *FB = cast<ConstantInt>(EndPoints[0]); 4987b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *FE = cast<ConstantInt>(EndPoints[1]); 4997b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (tryMergeRange(EndPoints, FB, FE)) { 5007b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel for (unsigned i = 0; i < Size - 2; ++i) { 5017b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints[i] = EndPoints[i + 2]; 5027b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5037b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints.resize(Size - 2); 5047b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5057b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5067b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 5077b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // If in the end we have a single range, it is possible that it is now the 5087b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // full range. Just drop the metadata in that case. 5097b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (EndPoints.size() == 2) { 5107b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange Range(cast<ConstantInt>(EndPoints[0])->getValue(), 5117b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel cast<ConstantInt>(EndPoints[1])->getValue()); 5127b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (Range.isFullSet()) 5137b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 5147b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5157b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 5167b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return MDNode::get(A->getContext(), EndPoints); 5177b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 5187b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 519f457d1316dec017cf204b54524878310c356bf64Devang Patel//===----------------------------------------------------------------------===// 520b2a33b46469a6d2c0e61122002079efb7d6d3f9cChris Lattner// NamedMDNode implementation. 521f457d1316dec017cf204b54524878310c356bf64Devang Patel// 52226028f27ddd132b3284943e11aca130c2911abc4Devang Patel 523d9c86dc6d95885f0c88f8068a06eab87da328490Dan Gohmanstatic SmallVector<TrackingVH<MDNode>, 4> &getNMDOps(void *Operands) { 524d9c86dc6d95885f0c88f8068a06eab87da328490Dan Gohman return *(SmallVector<TrackingVH<MDNode>, 4>*)Operands; 52557109697282c6dffd04e2e275606352914217114Chris Lattner} 52657109697282c6dffd04e2e275606352914217114Chris Lattner 52717aa92c92a925b4a674440c7ef088c223990e854Dan GohmanNamedMDNode::NamedMDNode(const Twine &N) 52817aa92c92a925b4a674440c7ef088c223990e854Dan Gohman : Name(N.str()), Parent(0), 52917aa92c92a925b4a674440c7ef088c223990e854Dan Gohman Operands(new SmallVector<TrackingVH<MDNode>, 4>()) { 530ab67e705f59d567afded845465f358b8a66ab62eDevang Patel} 531ab67e705f59d567afded845465f358b8a66ab62eDevang Patel 53257109697282c6dffd04e2e275606352914217114Chris LattnerNamedMDNode::~NamedMDNode() { 53357109697282c6dffd04e2e275606352914217114Chris Lattner dropAllReferences(); 53457109697282c6dffd04e2e275606352914217114Chris Lattner delete &getNMDOps(Operands); 53557109697282c6dffd04e2e275606352914217114Chris Lattner} 53657109697282c6dffd04e2e275606352914217114Chris Lattner 5375d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// getNumOperands - Return number of NamedMDNode operands. 5385d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnerunsigned NamedMDNode::getNumOperands() const { 53957109697282c6dffd04e2e275606352914217114Chris Lattner return (unsigned)getNMDOps(Operands).size(); 54057109697282c6dffd04e2e275606352914217114Chris Lattner} 54157109697282c6dffd04e2e275606352914217114Chris Lattner 5425d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// getOperand - Return specified operand. 5433e30c2a3c54c50246e6cccf0c8842619e29fe66cDevang PatelMDNode *NamedMDNode::getOperand(unsigned i) const { 5445d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner assert(i < getNumOperands() && "Invalid Operand number!"); 545872814ae048df032bddf9299c850f5bda08299a9Dan Gohman return dyn_cast<MDNode>(&*getNMDOps(Operands)[i]); 54657109697282c6dffd04e2e275606352914217114Chris Lattner} 54757109697282c6dffd04e2e275606352914217114Chris Lattner 5485d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// addOperand - Add metadata Operand. 5493e30c2a3c54c50246e6cccf0c8842619e29fe66cDevang Patelvoid NamedMDNode::addOperand(MDNode *M) { 5505781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman assert(!M->isFunctionLocal() && 5515781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman "NamedMDNode operands must not be function-local!"); 552d9c86dc6d95885f0c88f8068a06eab87da328490Dan Gohman getNMDOps(Operands).push_back(TrackingVH<MDNode>(M)); 55357109697282c6dffd04e2e275606352914217114Chris Lattner} 55457109697282c6dffd04e2e275606352914217114Chris Lattner 555a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel/// eraseFromParent - Drop all references and remove the node from parent 556a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel/// module. 557a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patelvoid NamedMDNode::eraseFromParent() { 55817aa92c92a925b4a674440c7ef088c223990e854Dan Gohman getParent()->eraseNamedMetadata(this); 559a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel} 560a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel 561a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel/// dropAllReferences - Remove all uses and clear node vector. 562a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patelvoid NamedMDNode::dropAllReferences() { 56357109697282c6dffd04e2e275606352914217114Chris Lattner getNMDOps(Operands).clear(); 564a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel} 565a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel 5660386f01e061513094504bc11f8352a40173cada7Devang Patel/// getName - Return a constant reference to this named metadata's name. 5670386f01e061513094504bc11f8352a40173cada7Devang PatelStringRef NamedMDNode::getName() const { 5680386f01e061513094504bc11f8352a40173cada7Devang Patel return StringRef(Name); 5690386f01e061513094504bc11f8352a40173cada7Devang Patel} 570937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel 571937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel//===----------------------------------------------------------------------===// 572081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner// Instruction Metadata method implementations. 573081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner// 57458a230a4917592f5c529cb40e75bfc3e1c681b69Devang Patel 57585dadecbd664f60f0c7e4fbb44f083d43d01cfb7Benjamin Kramervoid Instruction::setMetadata(StringRef Kind, MDNode *Node) { 576081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Node == 0 && !hasMetadata()) return; 577081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner setMetadata(getContext().getMDKindID(Kind), Node); 578937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel} 579937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel 58085dadecbd664f60f0c7e4fbb44f083d43d01cfb7Benjamin KramerMDNode *Instruction::getMetadataImpl(StringRef Kind) const { 581081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return getMetadataImpl(getContext().getMDKindID(Kind)); 5823990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner} 5833990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner 584081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner/// setMetadata - Set the metadata of of the specified kind to the specified 585081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner/// node. This updates/replaces metadata if already present, or removes it if 586081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner/// Node is null. 587081134741b40b342fb2f85722c9cea5d412489a8Chris Lattnervoid Instruction::setMetadata(unsigned KindID, MDNode *Node) { 588081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Node == 0 && !hasMetadata()) return; 5890d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 590ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle 'dbg' as a special case since it is not stored in the hash table. 591ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (KindID == LLVMContext::MD_dbg) { 59284e679beea11ac55ed7871eec4deaccdf393de3eChris Lattner DbgLoc = DebugLoc::getFromDILocation(Node); 593ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner return; 594ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner } 595ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 5963990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Handle the case when we're adding/updating metadata on an instruction. 5973990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner if (Node) { 598081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this]; 599ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner assert(!Info.empty() == hasMetadataHashEntry() && 600ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner "HasMetadata bit is wonked"); 6013990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner if (Info.empty()) { 602ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner setHasMetadataHashEntry(true); 6033990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } else { 6043990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Handle replacement of an existing value. 6053990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner for (unsigned i = 0, e = Info.size(); i != e; ++i) 606081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Info[i].first == KindID) { 6073990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Info[i].second = Node; 6083990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner return; 6093990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6103990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6110d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 6123990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // No replacement, just add it to the list. 613081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner Info.push_back(std::make_pair(KindID, Node)); 61474da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel return; 6153990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6160d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 6173990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Otherwise, we're removing metadata from an instruction. 618da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky assert((hasMetadataHashEntry() == 619da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky getContext().pImpl->MetadataStore.count(this)) && 6203990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner "HasMetadata bit out of date!"); 621da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky if (!hasMetadataHashEntry()) 622da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky return; // Nothing to remove! 623081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this]; 6240d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 6253990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Common case is removing the only entry. 626081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Info.size() == 1 && Info[0].first == KindID) { 627081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner getContext().pImpl->MetadataStore.erase(this); 628ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner setHasMetadataHashEntry(false); 6293990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner return; 6303990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6310d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 632ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle removal of an existing value. 6333990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner for (unsigned i = 0, e = Info.size(); i != e; ++i) 634081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Info[i].first == KindID) { 6353990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Info[i] = Info.back(); 6363990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Info.pop_back(); 6373990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner assert(!Info.empty() && "Removing last entry should be handled above"); 63874da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel return; 63974da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel } 6403990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Otherwise, removing an entry that doesn't exist on the instruction. 64174da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel} 6422353122a3c8f735deb1cb3c9c61785280923e09cNick Lewycky 6433990b121cf4a0b280ed3e54cf13870cbf4259e78Chris LattnerMDNode *Instruction::getMetadataImpl(unsigned KindID) const { 644ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle 'dbg' as a special case since it is not stored in the hash table. 645ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (KindID == LLVMContext::MD_dbg) 64661336ae001e07c6d68454b1494e45954d373fb51Chris Lattner return DbgLoc.getAsMDNode(getContext()); 647ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 648ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (!hasMetadataHashEntry()) return 0; 649ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 650081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this]; 651ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner assert(!Info.empty() && "bit out of sync with hash table"); 6520d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 653081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner for (LLVMContextImpl::MDMapTy::iterator I = Info.begin(), E = Info.end(); 654081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner I != E; ++I) 655081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (I->first == KindID) 656081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return I->second; 657081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return 0; 6583990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner} 6593990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner 6603990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattnervoid Instruction::getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, 661ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner MDNode*> > &Result) const { 662ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner Result.clear(); 663ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 664ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle 'dbg' as a special case since it is not stored in the hash table. 66561336ae001e07c6d68454b1494e45954d373fb51Chris Lattner if (!DbgLoc.isUnknown()) { 66661336ae001e07c6d68454b1494e45954d373fb51Chris Lattner Result.push_back(std::make_pair((unsigned)LLVMContext::MD_dbg, 66761336ae001e07c6d68454b1494e45954d373fb51Chris Lattner DbgLoc.getAsMDNode(getContext()))); 668ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (!hasMetadataHashEntry()) return; 669ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner } 670ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 671ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner assert(hasMetadataHashEntry() && 672ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner getContext().pImpl->MetadataStore.count(this) && 673081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner "Shouldn't have called this"); 674081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner const LLVMContextImpl::MDMapTy &Info = 675081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner getContext().pImpl->MetadataStore.find(this)->second; 676081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner assert(!Info.empty() && "Shouldn't have called this"); 6770d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 678081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner Result.append(Info.begin(), Info.end()); 6790d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 680081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner // Sort the resulting array so it is stable. 681081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Result.size() > 1) 682081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner array_pod_sort(Result.begin(), Result.end()); 6833990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner} 6843990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner 68561336ae001e07c6d68454b1494e45954d373fb51Chris Lattnervoid Instruction:: 68661336ae001e07c6d68454b1494e45954d373fb51Chris LattnergetAllMetadataOtherThanDebugLocImpl(SmallVectorImpl<std::pair<unsigned, 68761336ae001e07c6d68454b1494e45954d373fb51Chris Lattner MDNode*> > &Result) const { 68861336ae001e07c6d68454b1494e45954d373fb51Chris Lattner Result.clear(); 68961336ae001e07c6d68454b1494e45954d373fb51Chris Lattner assert(hasMetadataHashEntry() && 69061336ae001e07c6d68454b1494e45954d373fb51Chris Lattner getContext().pImpl->MetadataStore.count(this) && 69161336ae001e07c6d68454b1494e45954d373fb51Chris Lattner "Shouldn't have called this"); 69261336ae001e07c6d68454b1494e45954d373fb51Chris Lattner const LLVMContextImpl::MDMapTy &Info = 693f563fc35c89b7518baf2eb6580bd72041e39651bBill Wendling getContext().pImpl->MetadataStore.find(this)->second; 69461336ae001e07c6d68454b1494e45954d373fb51Chris Lattner assert(!Info.empty() && "Shouldn't have called this"); 69561336ae001e07c6d68454b1494e45954d373fb51Chris Lattner Result.append(Info.begin(), Info.end()); 696f563fc35c89b7518baf2eb6580bd72041e39651bBill Wendling 69761336ae001e07c6d68454b1494e45954d373fb51Chris Lattner // Sort the resulting array so it is stable. 69861336ae001e07c6d68454b1494e45954d373fb51Chris Lattner if (Result.size() > 1) 69961336ae001e07c6d68454b1494e45954d373fb51Chris Lattner array_pod_sort(Result.begin(), Result.end()); 70061336ae001e07c6d68454b1494e45954d373fb51Chris Lattner} 70161336ae001e07c6d68454b1494e45954d373fb51Chris Lattner 7024f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman/// clearMetadataHashEntries - Clear all hashtable-based metadata from 7034f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman/// this instruction. 7044f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohmanvoid Instruction::clearMetadataHashEntries() { 7054f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman assert(hasMetadataHashEntry() && "Caller should check"); 7064f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman getContext().pImpl->MetadataStore.erase(this); 7074f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman setHasMetadataHashEntry(false); 708508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner} 709508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner 710