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 140a9f7b9c3ebe7d0ec033462e1a7c9101279956f9Devang Patel#include "llvm/Metadata.h" 1537da0ad07bfd5e3856ce5d182b27b4c499c03c9aChris Lattner#include "LLVMContextImpl.h" 16647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson#include "llvm/LLVMContext.h" 17f457d1316dec017cf204b54524878310c356bf64Devang Patel#include "llvm/Module.h" 18937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel#include "llvm/Instruction.h" 199d89df169027035bf692b3d397bb93cff7bdc860Devang Patel#include "llvm/ADT/DenseMap.h" 209d89df169027035bf692b3d397bb93cff7bdc860Devang Patel#include "llvm/ADT/StringMap.h" 21d77fdba5737ee71b63681160fba5b2fc200583f4Devang Patel#include "llvm/ADT/SmallString.h" 221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner#include "llvm/ADT/STLExtras.h" 2328bc9d88260a3e153ead4311c9129e3d3ad07736Devang Patel#include "SymbolTableListTraitsImpl.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 { 306b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner return *getOperandPtr(const_cast<MDNode*>(this), i); 307c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner} 308c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 309b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattnervoid MDNode::Profile(FoldingSetNodeID &ID) const { 3107548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman // Add all the operand pointers. Note that we don't have to add the 3117548fb37f1fe2187c97a1fb5bf1d44e9cd34698fDan Gohman // isFunctionLocal bit because that's implied by the operands. 31256b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // Note that if the operands are later nulled out, the node will be 31356b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // removed from the uniquing map. 3145d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 3155d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner ID.AddPointer(getOperand(i)); 316b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner} 317c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 3186f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskinvoid MDNode::setIsNotUniqued() { 3196f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin setValueSubclassData(getSubclassDataFromValue() | NotUniquedBit); 3206f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin LLVMContextImpl *pImpl = getType()->getContext().pImpl; 3216f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin pImpl->NonUniquedMDNodes.insert(this); 32206fdaccc89d9abdc7e03797b25173791a2f5692fDevang Patel} 323c5e08a963973f43c10869cd249c0718d307dd031Chris Lattner 3245d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner// Replace value from this node's operand list. 3255d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnervoid MDNode::replaceOperand(MDNodeOperand *Op, Value *To) { 326df58389ef1fb8373d900975a6a66e4fbe0344f83Chris Lattner Value *From = *Op; 3270d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 328f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // If is possible that someone did GV->RAUW(inst), replacing a global variable 329f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // with an instruction or some other function-local object. If this is a 330f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // non-function-local MDNode, it can't point to a function-local object. 331f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner // Handle this case by implicitly dropping the MDNode reference to null. 332203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands // Likewise if the MDNode is function-local but for a different function. 333203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (To && isFunctionLocalValue(To)) { 334203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (!isFunctionLocal()) 335203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands To = 0; 336203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands else { 337203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands const Function *F = getFunction(); 338203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands const Function *FV = getFunctionForValue(To); 339203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands // Metadata can be function-local without having an associated function. 340203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands // So only consider functions to have changed if non-null. 341203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands if (F && FV && F != FV) 342203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands To = 0; 343203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands } 344203f7cb68b6c509b388d1662d8439693f75bb964Duncan Sands } 345f3f325b82fdeeb055225d98d9076214108d35f39Chris Lattner 346df58389ef1fb8373d900975a6a66e4fbe0344f83Chris Lattner if (From == To) 3475f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel return; 3485f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel 34954a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // Update the operand. 350b76359e36e75dfe16c5153c3cac903efbb2cd8d7Chris Lattner Op->set(To); 35154a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner 35254a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // If this node is already not being uniqued (because one of the operands 35354a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // already went to null), then there is nothing else to do here. 35454a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner if (isNotUniqued()) return; 3550d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 356496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner LLVMContextImpl *pImpl = getType()->getContext().pImpl; 357496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner 358496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner // Remove "this" from the context map. FoldingSet doesn't have to reprofile 359496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner // this node to remove it, so we don't care what state the operands are in. 360496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner pImpl->MDNodeSet.RemoveNode(this); 361df58389ef1fb8373d900975a6a66e4fbe0344f83Chris Lattner 36254a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // If we are dropping an argument to null, we choose to not unique the MDNode 36354a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // anymore. This commonly occurs during destruction, and uniquing these 36456b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // brings little reuse. Also, this means we don't need to include 36556b092e4cd2679d5d2dc892c722fa912e0dccbf9Dan Gohman // isFunctionLocal bits in FoldingSetNodeIDs for MDNodes. 36654a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner if (To == 0) { 36754a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner setIsNotUniqued(); 36854a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner return; 36954a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner } 3700d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 37154a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // Now that the node is out of the folding set, get ready to reinsert it. 37254a1f9f9c1e2cf6f4541e998b20f5c7cfbe642d9Chris Lattner // First, check to see if another node with the same operands already exists 373f53458f693fcf813b4c6c785034141017bf35893Dan Gohman // in the set. If so, then this node is redundant. 3745f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel FoldingSetNodeID ID; 3755f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel Profile(ID); 3765f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel void *InsertPoint; 377f375ebeed674ccf850d6647a3aaa979e4621896dDan Gohman if (MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint)) { 378f53458f693fcf813b4c6c785034141017bf35893Dan Gohman replaceAllUsesWith(N); 379f53458f693fcf813b4c6c785034141017bf35893Dan Gohman destroy(); 380f53458f693fcf813b4c6c785034141017bf35893Dan Gohman return; 3815f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel } 3825f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel 383611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer // Cache the operand hash. 384611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer Hash = ID.ComputeHash(); 385496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner // InsertPoint will have been set by the FindNodeOrInsertPos call. 386496425774e8adbc526e298f91f4c6980177c1d7fChris Lattner pImpl->MDNodeSet.InsertNode(this, InsertPoint); 3875781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman 3885781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman // If this MDValue was previously function-local but no longer is, clear 3895781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman // its function-local flag. 3905781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (isFunctionLocal() && !isFunctionLocalValue(To)) { 3915781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman bool isStillFunctionLocal = false; 3925781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 3935781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman Value *V = getOperand(i); 3945781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (!V) continue; 3955781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (isFunctionLocalValue(V)) { 3965781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman isStillFunctionLocal = true; 3975781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman break; 3985781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman } 3995781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman } 4005781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman if (!isStillFunctionLocal) 4015781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman setValueSubclassData(getSubclassDataFromValue() & ~FunctionLocalBit); 4025781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman } 4035f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel} 4045f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel 4057b4ff9343d911a1b9c76c512787beb7a45f8270dHal FinkelMDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) { 4067b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!A || !B) 4077b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 4087b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4097b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (A == B) 4107b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A; 4117b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4127b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel SmallVector<MDNode *, 4> PathA; 4137b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel MDNode *T = A; 4147b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (T) { 4157b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel PathA.push_back(T); 4167b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel T = T->getNumOperands() >= 2 ? cast_or_null<MDNode>(T->getOperand(1)) : 0; 4177b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4187b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4197b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel SmallVector<MDNode *, 4> PathB; 4207b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel T = B; 4217b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (T) { 4227b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel PathB.push_back(T); 4237b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel T = T->getNumOperands() >= 2 ? cast_or_null<MDNode>(T->getOperand(1)) : 0; 4247b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4257b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4267b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int IA = PathA.size() - 1; 4277b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int IB = PathB.size() - 1; 4287b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4297b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel MDNode *Ret = 0; 4307b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (IA >= 0 && IB >=0) { 4317b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (PathA[IA] == PathB[IB]) 4327b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel Ret = PathA[IA]; 4337b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel else 4347b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel break; 4357b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel --IA; 4367b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel --IB; 4377b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4387b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return Ret; 4397b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4407b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4417b4ff9343d911a1b9c76c512787beb7a45f8270dHal FinkelMDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) { 4427b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!A || !B) 4437b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 4447b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4457b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APFloat AVal = cast<ConstantFP>(A->getOperand(0))->getValueAPF(); 4467b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APFloat BVal = cast<ConstantFP>(B->getOperand(0))->getValueAPF(); 4477b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (AVal.compare(BVal) == APFloat::cmpLessThan) 4487b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A; 4497b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return B; 4507b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4517b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4527b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkelstatic bool isContiguous(const ConstantRange &A, const ConstantRange &B) { 4537b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A.getUpper() == B.getLower() || A.getLower() == B.getUpper(); 4547b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4557b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4567b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkelstatic bool canBeMerged(const ConstantRange &A, const ConstantRange &B) { 4577b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return !A.intersectWith(B).isEmptySet() || isContiguous(A, B); 4587b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4597b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4607b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkelstatic bool tryMergeRange(SmallVector<Value*, 4> &EndPoints, ConstantInt *Low, 4617b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *High) { 4627b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange NewRange(Low->getValue(), High->getValue()); 4637b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel unsigned Size = EndPoints.size(); 4647b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APInt LB = cast<ConstantInt>(EndPoints[Size - 2])->getValue(); 4657b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel APInt LE = cast<ConstantInt>(EndPoints[Size - 1])->getValue(); 4667b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange LastRange(LB, LE); 4677b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (canBeMerged(NewRange, LastRange)) { 4687b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange Union = LastRange.unionWith(NewRange); 4697b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel Type *Ty = High->getType(); 4707b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints[Size - 2] = ConstantInt::get(Ty, Union.getLower()); 4717b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints[Size - 1] = ConstantInt::get(Ty, Union.getUpper()); 4727b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return true; 4737b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 4747b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return false; 4757b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4767b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4777b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkelstatic void addRange(SmallVector<Value*, 4> &EndPoints, ConstantInt *Low, 4787b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *High) { 4797b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!EndPoints.empty()) 4807b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (tryMergeRange(EndPoints, Low, High)) 4817b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return; 4827b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4837b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints.push_back(Low); 4847b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints.push_back(High); 4857b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 4867b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4877b4ff9343d911a1b9c76c512787beb7a45f8270dHal FinkelMDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) { 4887b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // Given two ranges, we want to compute the union of the ranges. This 4897b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // is slightly complitade by having to combine the intervals and merge 4907b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // the ones that overlap. 4917b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4927b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (!A || !B) 4937b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 4947b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4957b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (A == B) 4967b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return A; 4977b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 4987b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // First, walk both lists in older of the lower boundary of each interval. 4997b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // At each step, try to merge the new interval to the last one we adedd. 5007b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel SmallVector<Value*, 4> EndPoints; 5017b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int AI = 0; 5027b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int BI = 0; 5037b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int AN = A->getNumOperands() / 2; 5047b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel int BN = B->getNumOperands() / 2; 5057b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (AI < AN && BI < BN) { 5067b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *ALow = cast<ConstantInt>(A->getOperand(2 * AI)); 5077b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *BLow = cast<ConstantInt>(B->getOperand(2 * BI)); 5087b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 5097b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (ALow->getValue().slt(BLow->getValue())) { 5107b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, ALow, cast<ConstantInt>(A->getOperand(2 * AI + 1))); 5117b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++AI; 5127b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } else { 5137b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, BLow, cast<ConstantInt>(B->getOperand(2 * BI + 1))); 5147b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++BI; 5157b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5167b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5177b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (AI < AN) { 5187b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, cast<ConstantInt>(A->getOperand(2 * AI)), 5197b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel cast<ConstantInt>(A->getOperand(2 * AI + 1))); 5207b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++AI; 5217b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5227b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel while (BI < BN) { 5237b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel addRange(EndPoints, cast<ConstantInt>(B->getOperand(2 * BI)), 5247b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel cast<ConstantInt>(B->getOperand(2 * BI + 1))); 5257b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ++BI; 5267b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5277b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 5287b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // If we have more than 2 ranges (4 endpoints) we have to try to merge 5297b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // the last and first ones. 5307b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel unsigned Size = EndPoints.size(); 5317b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (Size > 4) { 5327b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *FB = cast<ConstantInt>(EndPoints[0]); 5337b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantInt *FE = cast<ConstantInt>(EndPoints[1]); 5347b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (tryMergeRange(EndPoints, FB, FE)) { 5357b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel for (unsigned i = 0; i < Size - 2; ++i) { 5367b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints[i] = EndPoints[i + 2]; 5377b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5387b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel EndPoints.resize(Size - 2); 5397b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5407b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5417b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 5427b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // If in the end we have a single range, it is possible that it is now the 5437b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel // full range. Just drop the metadata in that case. 5447b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (EndPoints.size() == 2) { 5457b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel ConstantRange Range(cast<ConstantInt>(EndPoints[0])->getValue(), 5467b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel cast<ConstantInt>(EndPoints[1])->getValue()); 5477b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel if (Range.isFullSet()) 5487b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return NULL; 5497b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel } 5507b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 5517b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel return MDNode::get(A->getContext(), EndPoints); 5527b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel} 5537b4ff9343d911a1b9c76c512787beb7a45f8270dHal Finkel 554f457d1316dec017cf204b54524878310c356bf64Devang Patel//===----------------------------------------------------------------------===// 555b2a33b46469a6d2c0e61122002079efb7d6d3f9cChris Lattner// NamedMDNode implementation. 556f457d1316dec017cf204b54524878310c356bf64Devang Patel// 55726028f27ddd132b3284943e11aca130c2911abc4Devang Patel 558d9c86dc6d95885f0c88f8068a06eab87da328490Dan Gohmanstatic SmallVector<TrackingVH<MDNode>, 4> &getNMDOps(void *Operands) { 559d9c86dc6d95885f0c88f8068a06eab87da328490Dan Gohman return *(SmallVector<TrackingVH<MDNode>, 4>*)Operands; 56057109697282c6dffd04e2e275606352914217114Chris Lattner} 56157109697282c6dffd04e2e275606352914217114Chris Lattner 56217aa92c92a925b4a674440c7ef088c223990e854Dan GohmanNamedMDNode::NamedMDNode(const Twine &N) 56317aa92c92a925b4a674440c7ef088c223990e854Dan Gohman : Name(N.str()), Parent(0), 56417aa92c92a925b4a674440c7ef088c223990e854Dan Gohman Operands(new SmallVector<TrackingVH<MDNode>, 4>()) { 565ab67e705f59d567afded845465f358b8a66ab62eDevang Patel} 566ab67e705f59d567afded845465f358b8a66ab62eDevang Patel 56757109697282c6dffd04e2e275606352914217114Chris LattnerNamedMDNode::~NamedMDNode() { 56857109697282c6dffd04e2e275606352914217114Chris Lattner dropAllReferences(); 56957109697282c6dffd04e2e275606352914217114Chris Lattner delete &getNMDOps(Operands); 57057109697282c6dffd04e2e275606352914217114Chris Lattner} 57157109697282c6dffd04e2e275606352914217114Chris Lattner 5725d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// getNumOperands - Return number of NamedMDNode operands. 5735d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattnerunsigned NamedMDNode::getNumOperands() const { 57457109697282c6dffd04e2e275606352914217114Chris Lattner return (unsigned)getNMDOps(Operands).size(); 57557109697282c6dffd04e2e275606352914217114Chris Lattner} 57657109697282c6dffd04e2e275606352914217114Chris Lattner 5775d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// getOperand - Return specified operand. 5783e30c2a3c54c50246e6cccf0c8842619e29fe66cDevang PatelMDNode *NamedMDNode::getOperand(unsigned i) const { 5795d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner assert(i < getNumOperands() && "Invalid Operand number!"); 580872814ae048df032bddf9299c850f5bda08299a9Dan Gohman return dyn_cast<MDNode>(&*getNMDOps(Operands)[i]); 58157109697282c6dffd04e2e275606352914217114Chris Lattner} 58257109697282c6dffd04e2e275606352914217114Chris Lattner 5835d0cacdbb6577f2449986f345858db17dc1bcf59Chris Lattner/// addOperand - Add metadata Operand. 5843e30c2a3c54c50246e6cccf0c8842619e29fe66cDevang Patelvoid NamedMDNode::addOperand(MDNode *M) { 5855781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman assert(!M->isFunctionLocal() && 5865781f3e9fc1b821f4803ddced16a59c23523f6a7Dan Gohman "NamedMDNode operands must not be function-local!"); 587d9c86dc6d95885f0c88f8068a06eab87da328490Dan Gohman getNMDOps(Operands).push_back(TrackingVH<MDNode>(M)); 58857109697282c6dffd04e2e275606352914217114Chris Lattner} 58957109697282c6dffd04e2e275606352914217114Chris Lattner 590a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel/// eraseFromParent - Drop all references and remove the node from parent 591a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel/// module. 592a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patelvoid NamedMDNode::eraseFromParent() { 59317aa92c92a925b4a674440c7ef088c223990e854Dan Gohman getParent()->eraseNamedMetadata(this); 594a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel} 595a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel 596a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel/// dropAllReferences - Remove all uses and clear node vector. 597a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patelvoid NamedMDNode::dropAllReferences() { 59857109697282c6dffd04e2e275606352914217114Chris Lattner getNMDOps(Operands).clear(); 599a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel} 600a82f8838c60b7a3b240e185983dacb3291396f3eDevang Patel 6010386f01e061513094504bc11f8352a40173cada7Devang Patel/// getName - Return a constant reference to this named metadata's name. 6020386f01e061513094504bc11f8352a40173cada7Devang PatelStringRef NamedMDNode::getName() const { 6030386f01e061513094504bc11f8352a40173cada7Devang Patel return StringRef(Name); 6040386f01e061513094504bc11f8352a40173cada7Devang Patel} 605937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel 606937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel//===----------------------------------------------------------------------===// 607081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner// Instruction Metadata method implementations. 608081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner// 60958a230a4917592f5c529cb40e75bfc3e1c681b69Devang Patel 61085dadecbd664f60f0c7e4fbb44f083d43d01cfb7Benjamin Kramervoid Instruction::setMetadata(StringRef Kind, MDNode *Node) { 611081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Node == 0 && !hasMetadata()) return; 612081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner setMetadata(getContext().getMDKindID(Kind), Node); 613937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel} 614937b1e92a9862862722732cb0f72d5ade77ac4c8Devang Patel 61585dadecbd664f60f0c7e4fbb44f083d43d01cfb7Benjamin KramerMDNode *Instruction::getMetadataImpl(StringRef Kind) const { 616081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return getMetadataImpl(getContext().getMDKindID(Kind)); 6173990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner} 6183990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner 619081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner/// setMetadata - Set the metadata of of the specified kind to the specified 620081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner/// node. This updates/replaces metadata if already present, or removes it if 621081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner/// Node is null. 622081134741b40b342fb2f85722c9cea5d412489a8Chris Lattnervoid Instruction::setMetadata(unsigned KindID, MDNode *Node) { 623081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Node == 0 && !hasMetadata()) return; 6240d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 625ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle 'dbg' as a special case since it is not stored in the hash table. 626ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (KindID == LLVMContext::MD_dbg) { 62784e679beea11ac55ed7871eec4deaccdf393de3eChris Lattner DbgLoc = DebugLoc::getFromDILocation(Node); 628ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner return; 629ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner } 630ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 6313990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Handle the case when we're adding/updating metadata on an instruction. 6323990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner if (Node) { 633081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this]; 634ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner assert(!Info.empty() == hasMetadataHashEntry() && 635ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner "HasMetadata bit is wonked"); 6363990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner if (Info.empty()) { 637ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner setHasMetadataHashEntry(true); 6383990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } else { 6393990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Handle replacement of an existing value. 6403990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner for (unsigned i = 0, e = Info.size(); i != e; ++i) 641081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Info[i].first == KindID) { 6423990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Info[i].second = Node; 6433990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner return; 6443990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6453990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6460d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 6473990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // No replacement, just add it to the list. 648081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner Info.push_back(std::make_pair(KindID, Node)); 64974da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel return; 6503990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6510d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 6523990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Otherwise, we're removing metadata from an instruction. 653da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky assert((hasMetadataHashEntry() == 654da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky getContext().pImpl->MetadataStore.count(this)) && 6553990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner "HasMetadata bit out of date!"); 656da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky if (!hasMetadataHashEntry()) 657da32cc6176d8ca2cd9cf387f5818ae911c91dc3cNick Lewycky return; // Nothing to remove! 658081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this]; 6590d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 6603990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Common case is removing the only entry. 661081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Info.size() == 1 && Info[0].first == KindID) { 662081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner getContext().pImpl->MetadataStore.erase(this); 663ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner setHasMetadataHashEntry(false); 6643990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner return; 6653990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner } 6660d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 667ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle removal of an existing value. 6683990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner for (unsigned i = 0, e = Info.size(); i != e; ++i) 669081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Info[i].first == KindID) { 6703990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Info[i] = Info.back(); 6713990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Info.pop_back(); 6723990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner assert(!Info.empty() && "Removing last entry should be handled above"); 67374da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel return; 67474da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel } 6753990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner // Otherwise, removing an entry that doesn't exist on the instruction. 67674da40a96fecd07ce0bb4eee169087bfac2e5f23Devang Patel} 6772353122a3c8f735deb1cb3c9c61785280923e09cNick Lewycky 6783990b121cf4a0b280ed3e54cf13870cbf4259e78Chris LattnerMDNode *Instruction::getMetadataImpl(unsigned KindID) const { 679ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle 'dbg' as a special case since it is not stored in the hash table. 680ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (KindID == LLVMContext::MD_dbg) 68161336ae001e07c6d68454b1494e45954d373fb51Chris Lattner return DbgLoc.getAsMDNode(getContext()); 682ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 683ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (!hasMetadataHashEntry()) return 0; 684ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 685081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner LLVMContextImpl::MDMapTy &Info = getContext().pImpl->MetadataStore[this]; 686ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner assert(!Info.empty() && "bit out of sync with hash table"); 6870d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 688081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner for (LLVMContextImpl::MDMapTy::iterator I = Info.begin(), E = Info.end(); 689081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner I != E; ++I) 690081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (I->first == KindID) 691081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return I->second; 692081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return 0; 6933990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner} 6943990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner 6953990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattnervoid Instruction::getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, 696ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner MDNode*> > &Result) const { 697ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner Result.clear(); 698ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 699ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner // Handle 'dbg' as a special case since it is not stored in the hash table. 70061336ae001e07c6d68454b1494e45954d373fb51Chris Lattner if (!DbgLoc.isUnknown()) { 70161336ae001e07c6d68454b1494e45954d373fb51Chris Lattner Result.push_back(std::make_pair((unsigned)LLVMContext::MD_dbg, 70261336ae001e07c6d68454b1494e45954d373fb51Chris Lattner DbgLoc.getAsMDNode(getContext()))); 703ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner if (!hasMetadataHashEntry()) return; 704ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner } 705ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner 706ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner assert(hasMetadataHashEntry() && 707ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner getContext().pImpl->MetadataStore.count(this) && 708081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner "Shouldn't have called this"); 709081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner const LLVMContextImpl::MDMapTy &Info = 710081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner getContext().pImpl->MetadataStore.find(this)->second; 711081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner assert(!Info.empty() && "Shouldn't have called this"); 7120d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 713081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner Result.append(Info.begin(), Info.end()); 7140d75d874bfa3cee9fbe907d8aa0bab61556e3d0eMikhail Glushenkov 715081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner // Sort the resulting array so it is stable. 716081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner if (Result.size() > 1) 717081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner array_pod_sort(Result.begin(), Result.end()); 7183990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner} 7193990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner 72061336ae001e07c6d68454b1494e45954d373fb51Chris Lattnervoid Instruction:: 72161336ae001e07c6d68454b1494e45954d373fb51Chris LattnergetAllMetadataOtherThanDebugLocImpl(SmallVectorImpl<std::pair<unsigned, 72261336ae001e07c6d68454b1494e45954d373fb51Chris Lattner MDNode*> > &Result) const { 72361336ae001e07c6d68454b1494e45954d373fb51Chris Lattner Result.clear(); 72461336ae001e07c6d68454b1494e45954d373fb51Chris Lattner assert(hasMetadataHashEntry() && 72561336ae001e07c6d68454b1494e45954d373fb51Chris Lattner getContext().pImpl->MetadataStore.count(this) && 72661336ae001e07c6d68454b1494e45954d373fb51Chris Lattner "Shouldn't have called this"); 72761336ae001e07c6d68454b1494e45954d373fb51Chris Lattner const LLVMContextImpl::MDMapTy &Info = 728f563fc35c89b7518baf2eb6580bd72041e39651bBill Wendling getContext().pImpl->MetadataStore.find(this)->second; 72961336ae001e07c6d68454b1494e45954d373fb51Chris Lattner assert(!Info.empty() && "Shouldn't have called this"); 73061336ae001e07c6d68454b1494e45954d373fb51Chris Lattner Result.append(Info.begin(), Info.end()); 731f563fc35c89b7518baf2eb6580bd72041e39651bBill Wendling 73261336ae001e07c6d68454b1494e45954d373fb51Chris Lattner // Sort the resulting array so it is stable. 73361336ae001e07c6d68454b1494e45954d373fb51Chris Lattner if (Result.size() > 1) 73461336ae001e07c6d68454b1494e45954d373fb51Chris Lattner array_pod_sort(Result.begin(), Result.end()); 73561336ae001e07c6d68454b1494e45954d373fb51Chris Lattner} 73661336ae001e07c6d68454b1494e45954d373fb51Chris Lattner 7374f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman/// clearMetadataHashEntries - Clear all hashtable-based metadata from 7384f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman/// this instruction. 7394f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohmanvoid Instruction::clearMetadataHashEntries() { 7404f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman assert(hasMetadataHashEntry() && "Caller should check"); 7414f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman getContext().pImpl->MetadataStore.erase(this); 7424f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman setHasMetadataHashEntry(false); 743508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner} 744508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner 745