1009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===-- Value.cpp - Implement the Value class -----------------------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// This file implements the Value, ValueHandle, and User classes. 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 12009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 13009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 140b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Value.h" 154d919438898d542850449235da7f6dc55e6ca152Owen Anderson#include "LLVMContextImpl.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/DenseMap.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallString.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constant.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 200b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DerivedTypes.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/InstrTypes.h" 220b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 230b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 240b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 250b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/ValueSymbolTable.h" 262e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling#include "llvm/Support/Debug.h" 27ab7c09b6b6f4516a631fd6788918c237c83939afTorok Edwin#include "llvm/Support/ErrorHandling.h" 28d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/GetElementPtrTypeIterator.h" 29551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/LeakDetector.h" 30722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#include "llvm/Support/ManagedStatic.h" 31722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#include "llvm/Support/ValueHandle.h" 32009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include <algorithm> 3331f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 34d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 35009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 36009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// Value Class 37009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 38009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 39db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic inline Type *checkType(Type *Ty) { 4082d18aa0e42a4858c2cb7c15934cc3e567432490Chris Lattner assert(Ty && "Value defined with a null type: Error!"); 411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return const_cast<Type*>(Ty); 4282d18aa0e42a4858c2cb7c15934cc3e567432490Chris Lattner} 4382d18aa0e42a4858c2cb7c15934cc3e567432490Chris Lattner 44db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerValue::Value(Type *ty, unsigned scid) 453990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner : SubclassID(scid), HasValueHandle(0), 461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SubclassOptionalData(0), SubclassData(0), VTy((Type*)checkType(ty)), 476f4266506bca785828bacda55bd5db9172f990c6Gabor Greif UseList(0), Name(0) { 481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // FIXME: Why isn't this in the subclass gunk?? 49488fdce9821a06732631aececa351ad75a224b19Richard Smith // Note, we cannot call isa<CallInst> before the CallInst has been 50488fdce9821a06732631aececa351ad75a224b19Richard Smith // constructed. 51488fdce9821a06732631aececa351ad75a224b19Richard Smith if (SubclassID == Instruction::Call || SubclassID == Instruction::Invoke) 521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) && 531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "invalid CallInst type!"); 54488fdce9821a06732631aececa351ad75a224b19Richard Smith else if (SubclassID != BasicBlockVal && 55488fdce9821a06732631aececa351ad75a224b19Richard Smith (SubclassID < ConstantFirstVal || SubclassID > ConstantLastVal)) 561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((VTy->isFirstClassType() || VTy->isVoidTy()) && 57a9e7781b3b8e457946491529816feab73c66d774Chris Lattner "Cannot create non-first-class values except for constants!"); 58009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 59009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 60afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon HenriksenValue::~Value() { 61722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Notify all ValueHandles (if present) that this value is going away. 62722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (HasValueHandle) 63722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase::ValueIsDeleted(this); 64ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 65009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#ifndef NDEBUG // Only in -g mode... 66ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // Check to make sure that there are no uses of this value that are still 67ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // around when the value is destroyed. If there are, then we have a dangling 68ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // reference and something is wrong. This code is here to print out what is 69fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // still being referenced. The value in question should be printed as 70ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // a <badref> 71ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // 72afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon Henriksen if (!use_empty()) { 73a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer dbgs() << "While deleting: " << *VTy << " %" << getName() << "\n"; 74afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon Henriksen for (use_iterator I = use_begin(), E = use_end(); I != E; ++I) 756892c7a92d0d2132b8361f7324824a680d09134cDavid Greene dbgs() << "Use still stuck around after Def is destroyed:" 762e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling << **I << "\n"; 77009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 78009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#endif 79afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon Henriksen assert(use_empty() && "Uses remain when a value is destroyed!"); 804f95d2bda4235d36acd95688d0744d7363214706Chris Lattner 814f95d2bda4235d36acd95688d0744d7363214706Chris Lattner // If this value is named, destroy the name. This should not be in a symtab 824f95d2bda4235d36acd95688d0744d7363214706Chris Lattner // at this point. 833ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling if (Name && SubclassID != MDStringVal) 844f95d2bda4235d36acd95688d0744d7363214706Chris Lattner Name->Destroy(); 85ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 864f95d2bda4235d36acd95688d0744d7363214706Chris Lattner // There should be no uses of this object anymore, remove it. 874f95d2bda4235d36acd95688d0744d7363214706Chris Lattner LeakDetector::removeGarbageObject(this); 88009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 89009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9029d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// hasNUses - Return true if this Value has exactly N users. 9129d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// 9229d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattnerbool Value::hasNUses(unsigned N) const { 9360ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif const_use_iterator UI = use_begin(), E = use_end(); 9429d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner 9529d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner for (; N; --N, ++UI) 9629d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner if (UI == E) return false; // Too few. 9729d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner return UI == E; 9829d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner} 9929d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner 1008daf056c90c2590709090b0c27045e1a45803461Chris Lattner/// hasNUsesOrMore - Return true if this value has N users or more. This is 1018daf056c90c2590709090b0c27045e1a45803461Chris Lattner/// logically equivalent to getNumUses() >= N. 1028daf056c90c2590709090b0c27045e1a45803461Chris Lattner/// 1038daf056c90c2590709090b0c27045e1a45803461Chris Lattnerbool Value::hasNUsesOrMore(unsigned N) const { 10460ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif const_use_iterator UI = use_begin(), E = use_end(); 1058daf056c90c2590709090b0c27045e1a45803461Chris Lattner 1068daf056c90c2590709090b0c27045e1a45803461Chris Lattner for (; N; --N, ++UI) 1078daf056c90c2590709090b0c27045e1a45803461Chris Lattner if (UI == E) return false; // Too few. 1088daf056c90c2590709090b0c27045e1a45803461Chris Lattner 1098daf056c90c2590709090b0c27045e1a45803461Chris Lattner return true; 1108daf056c90c2590709090b0c27045e1a45803461Chris Lattner} 1118daf056c90c2590709090b0c27045e1a45803461Chris Lattner 112502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng/// isUsedInBasicBlock - Return true if this value is used in the specified 113502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng/// basic block. 114c4f72dd6e759a170808ecfc6be784f8598367484Bill Wendlingbool Value::isUsedInBasicBlock(const BasicBlock *BB) const { 1154da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer // Start by scanning over the instructions looking for a use before we start 1164da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer // the expensive use iteration. 1174da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer unsigned MaxBlockSize = 3; 1184da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 1194da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer if (std::find(I->op_begin(), I->op_end(), this) != I->op_end()) 1204da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer return true; 1214da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer if (MaxBlockSize-- == 0) // If the block is larger fall back to use_iterator 1224da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer break; 1234da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer } 1244da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer 1254da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer if (MaxBlockSize != 0) // We scanned the entire block and found no use. 1264da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer return false; 1274da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer 12860ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif for (const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) { 129502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng const Instruction *User = dyn_cast<Instruction>(*I); 130502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng if (User && User->getParent() == BB) 131502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng return true; 132502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng } 133502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng return false; 134502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng} 135502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng 1368daf056c90c2590709090b0c27045e1a45803461Chris Lattner 13729d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// getNumUses - This method computes the number of uses of this Value. This 13829d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// is a linear time operation. Use hasOneUse or hasNUses to check for specific 13929d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// values. 14029d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattnerunsigned Value::getNumUses() const { 14129d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner return (unsigned)std::distance(use_begin(), use_end()); 14229d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner} 14329d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner 1447216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattnerstatic bool getSymTab(Value *V, ValueSymbolTable *&ST) { 145ea7acb859111a7f55c497e0b7cf569ac81e97208Chris Lattner ST = 0; 1467216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner if (Instruction *I = dyn_cast<Instruction>(V)) { 1470d1e40728d668085257b78657b381e1f13d77d52Chris Lattner if (BasicBlock *P = I->getParent()) 1480d1e40728d668085257b78657b381e1f13d77d52Chris Lattner if (Function *PP = P->getParent()) 14978d033e086e19e016273de014f9214aa6f3f844bReid Spencer ST = &PP->getValueSymbolTable(); 1507216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner } else if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 151ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Function *P = BB->getParent()) 152ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ST = &P->getValueSymbolTable(); 1537216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 154ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Module *P = GV->getParent()) 155ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ST = &P->getValueSymbolTable(); 1567216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner } else if (Argument *A = dyn_cast<Argument>(V)) { 157ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Function *P = A->getParent()) 158ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ST = &P->getValueSymbolTable(); 159e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel } else if (isa<MDString>(V)) 160e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel return true; 161e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel else { 1627216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner assert(isa<Constant>(V) && "Unknown value type!"); 1637216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner return true; // no name is setable for this. 1640d1e40728d668085257b78657b381e1f13d77d52Chris Lattner } 1657216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner return false; 1667216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner} 1677216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner 168499027fb4826e25919f2ea154ca4db73842560afDaniel DunbarStringRef Value::getName() const { 1694fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar // Make sure the empty string is still a C string. For historical reasons, 1704fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar // some clients want to call .data() on the result and expect it to be null 1714fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar // terminated. 1724fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar if (!Name) return StringRef("", 0); 173499027fb4826e25919f2ea154ca4db73842560afDaniel Dunbar return Name->getKey(); 17471996e73d8050d2b8805b14a48ab635155b11a12Chris Lattner} 17571996e73d8050d2b8805b14a48ab635155b11a12Chris Lattner 1763f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbarvoid Value::setName(const Twine &NewName) { 1773ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling assert(SubclassID != MDStringVal && 1783ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling "Cannot set the name of MDString with this method!"); 1793ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling 1805149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar // Fast path for common IRBuilder case of setName("") when there is no name. 1815149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar if (NewName.isTriviallyEmpty() && !hasName()) 1825149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar return; 1835149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar 184e476004b94582c64a0fabaa0e251a0f070909843Daniel Dunbar SmallString<256> NameData; 185b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer StringRef NameRef = NewName.toStringRef(NameData); 186042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner 18707f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar // Name isn't changing? 188b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer if (getName() == NameRef) 18907f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar return; 19007f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar 191f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer assert(!getType()->isVoidTy() && "Cannot assign a name to void values!"); 192ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 1937216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner // Get the symbol table to update for this object. 1947216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner ValueSymbolTable *ST; 1957216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner if (getSymTab(this, ST)) 1967216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner return; // Cannot set a name on this value (e.g. constant). 1970d1e40728d668085257b78657b381e1f13d77d52Chris Lattner 1984c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman if (Function *F = dyn_cast<Function>(this)) 1994c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman getContext().pImpl->IntrinsicIDCache.erase(F); 2004c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman 201dec628eead87b20773c98a00830580df211acc98Chris Lattner if (!ST) { // No symbol table to update? Just do the change. 202b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer if (NameRef.empty()) { 203dec628eead87b20773c98a00830580df211acc98Chris Lattner // Free the name for this value. 204dec628eead87b20773c98a00830580df211acc98Chris Lattner Name->Destroy(); 205dec628eead87b20773c98a00830580df211acc98Chris Lattner Name = 0; 206042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner return; 20704cb800c324ef661017aff474e266ed7f2cddb90Chris Lattner } 208ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 20907f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar if (Name) 210042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner Name->Destroy(); 211ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 212042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner // NOTE: Could optimize for the case the name is shrinking to not deallocate 213042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner // then reallocated. 214ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 215042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner // Create the new name. 216b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer Name = ValueName::Create(NameRef.begin(), NameRef.end()); 217042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner Name->setValue(this); 218dec628eead87b20773c98a00830580df211acc98Chris Lattner return; 219dec628eead87b20773c98a00830580df211acc98Chris Lattner } 220ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 221dec628eead87b20773c98a00830580df211acc98Chris Lattner // NOTE: Could optimize for the case the name is shrinking to not deallocate 222dec628eead87b20773c98a00830580df211acc98Chris Lattner // then reallocated. 223dec628eead87b20773c98a00830580df211acc98Chris Lattner if (hasName()) { 224dec628eead87b20773c98a00830580df211acc98Chris Lattner // Remove old name. 225dec628eead87b20773c98a00830580df211acc98Chris Lattner ST->removeValueName(Name); 226dec628eead87b20773c98a00830580df211acc98Chris Lattner Name->Destroy(); 227dec628eead87b20773c98a00830580df211acc98Chris Lattner Name = 0; 228dec628eead87b20773c98a00830580df211acc98Chris Lattner 229b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer if (NameRef.empty()) 230042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner return; 23104cb800c324ef661017aff474e266ed7f2cddb90Chris Lattner } 232dec628eead87b20773c98a00830580df211acc98Chris Lattner 233dec628eead87b20773c98a00830580df211acc98Chris Lattner // Name is changing to something new. 234b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer Name = ST->createValueName(NameRef, this); 2350d1e40728d668085257b78657b381e1f13d77d52Chris Lattner} 2360d1e40728d668085257b78657b381e1f13d77d52Chris Lattner 237042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner 2387216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner/// takeName - transfer the name from V to this value, setting V's name to 239ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar/// empty. It is an error to call V->takeName(V). 2407216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattnervoid Value::takeName(Value *V) { 2413ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling assert(SubclassID != MDStringVal && "Cannot take the name of an MDString!"); 2423ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling 2430878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ValueSymbolTable *ST = 0; 2440878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // If this value has a name, drop it. 2450878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (hasName()) { 2460878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Get the symtab this is in. 2470878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (getSymTab(this, ST)) { 2480878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // We can't set a name on this value, but we need to clear V's name if 2490878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // it has one. 2503f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbar if (V->hasName()) V->setName(""); 2510878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner return; // Cannot set a name on this value (e.g. constant). 2520878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner } 253ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2540878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Remove old name. 2550878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (ST) 2560878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ST->removeValueName(Name); 2570878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name->Destroy(); 2580878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name = 0; 259ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar } 260ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2610878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Now we know that this has no name. 262ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2630878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // If V has no name either, we're done. 2640878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (!V->hasName()) return; 265ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2660878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Get this's symtab if we didn't before. 2670878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (!ST) { 2680878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (getSymTab(this, ST)) { 2690878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Clear V's name. 2703f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbar V->setName(""); 2710878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner return; // Cannot set a name on this value (e.g. constant). 2720878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner } 2730878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner } 274ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2750878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Get V's ST, this should always succed, because V has a name. 2760878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ValueSymbolTable *VST; 2770878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner bool Failure = getSymTab(V, VST); 2788e68c3873549ca31533e2e3e40dda3a43cb79566Jeffrey Yasskin assert(!Failure && "V has a name, so it should have a ST!"); (void)Failure; 279ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2800878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // If these values are both in the same symtab, we can do this very fast. 2810878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // This works even if both values have no symtab yet. 2820878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (ST == VST) { 2830878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Take the name! 2840878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name = V->Name; 2850878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner V->Name = 0; 2860878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name->setValue(this); 287f41916e75dc9c622fa81b91eb6a5e0a36fa13754Chris Lattner return; 288f41916e75dc9c622fa81b91eb6a5e0a36fa13754Chris Lattner } 289ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2900878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Otherwise, things are slightly more complex. Remove V's name from VST and 2910878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // then reinsert it into ST. 292ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2930878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (VST) 2940878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner VST->removeValueName(V->Name); 2950878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name = V->Name; 2960878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner V->Name = 0; 2970878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name->setValue(this); 298ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2990878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (ST) 3000878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ST->reinsertValue(this); 3017216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner} 3027216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner 3037216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner 304678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattnervoid Value::replaceAllUsesWith(Value *New) { 305678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner assert(New && "Value::replaceAllUsesWith(<null>) is invalid!"); 306678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner assert(New != this && "this->replaceAllUsesWith(this) is NOT valid!"); 307678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner assert(New->getType() == getType() && 308678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner "replaceAllUses of value with new value of different type!"); 309678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner 310722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Notify all ValueHandles (if present) that this value is going away. 311722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (HasValueHandle) 312722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase::ValueIsRAUWd(this, New); 3134c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman 31429d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner while (!use_empty()) { 3156f4266506bca785828bacda55bd5db9172f990c6Gabor Greif Use &U = *UseList; 3162bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner // Must handle Constants specially, we cannot call replaceUsesOfWith on a 3172d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner // constant because they are uniqued. 318c3cc71abbcac9a5d172e64002e2262c8f1a41967Chris Lattner if (Constant *C = dyn_cast<Constant>(U.getUser())) { 3192d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner if (!isa<GlobalValue>(C)) { 320d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner C->replaceUsesOfWithOnConstant(this, New, &U); 3212d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner continue; 3222d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner } 3232bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner } 3244c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman 3252d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner U.set(New); 3262bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner } 3274c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman 32895c3e48f9557adb6064d580684bb14cacec2f826Jay Foad if (BasicBlock *BB = dyn_cast<BasicBlock>(this)) 32995c3e48f9557adb6064d580684bb14cacec2f826Jay Foad BB->replaceSuccessorsPhiUsesWith(cast<BasicBlock>(New)); 3302bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner} 3312bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner 33284dfc32ff906271c373819595e60a173624e1184Chandler Carruthnamespace { 33384dfc32ff906271c373819595e60a173624e1184Chandler Carruth// Various metrics for how much to strip off of pointers. 33484dfc32ff906271c373819595e60a173624e1184Chandler Carruthenum PointerStripKind { 33584dfc32ff906271c373819595e60a173624e1184Chandler Carruth PSK_ZeroIndices, 336274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth PSK_InBoundsConstantIndices, 337274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth PSK_InBounds 33884dfc32ff906271c373819595e60a173624e1184Chandler Carruth}; 33984dfc32ff906271c373819595e60a173624e1184Chandler Carruth 34084dfc32ff906271c373819595e60a173624e1184Chandler Carruthtemplate <PointerStripKind StripKind> 34184dfc32ff906271c373819595e60a173624e1184Chandler Carruthstatic Value *stripPointerCastsAndOffsets(Value *V) { 34284dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!V->getType()->isPointerTy()) 34384dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 34450f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman 34550f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman // Even though we don't look through PHI nodes, we could be called on an 34650f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman // instruction in an unreachable block, which may be on a cycle. 34750f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman SmallPtrSet<Value *, 4> Visited; 34850f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman 34950f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman Visited.insert(V); 350f08bf1193c390bfe4b25d8533f146742d0277d06Duncan Sands do { 351016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 35284dfc32ff906271c373819595e60a173624e1184Chandler Carruth switch (StripKind) { 35384dfc32ff906271c373819595e60a173624e1184Chandler Carruth case PSK_ZeroIndices: 35484dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!GEP->hasAllZeroIndices()) 35584dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 35684dfc32ff906271c373819595e60a173624e1184Chandler Carruth break; 357274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth case PSK_InBoundsConstantIndices: 35884dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!GEP->hasAllConstantIndices()) 35984dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 360274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth // fallthrough 36184dfc32ff906271c373819595e60a173624e1184Chandler Carruth case PSK_InBounds: 36284dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!GEP->isInBounds()) 36384dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 36484dfc32ff906271c373819595e60a173624e1184Chandler Carruth break; 36584dfc32ff906271c373819595e60a173624e1184Chandler Carruth } 366016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman V = GEP->getPointerOperand(); 367016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman } else if (Operator::getOpcode(V) == Instruction::BitCast) { 368016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman V = cast<Operator>(V)->getOperand(0); 369aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 370aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman if (GA->mayBeOverridden()) 371aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman return V; 372aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman V = GA->getAliasee(); 373f08bf1193c390bfe4b25d8533f146742d0277d06Duncan Sands } else { 374f08bf1193c390bfe4b25d8533f146742d0277d06Duncan Sands return V; 3750b12ecf6ff6b5d3a144178257b6206f0c4788792Anton Korobeynikov } 3761df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(V->getType()->isPointerTy() && "Unexpected operand type!"); 37750f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman } while (Visited.insert(V)); 37850f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman 37950f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman return V; 3800b12ecf6ff6b5d3a144178257b6206f0c4788792Anton Korobeynikov} 38184dfc32ff906271c373819595e60a173624e1184Chandler Carruth} // namespace 38284dfc32ff906271c373819595e60a173624e1184Chandler Carruth 38384dfc32ff906271c373819595e60a173624e1184Chandler CarruthValue *Value::stripPointerCasts() { 38484dfc32ff906271c373819595e60a173624e1184Chandler Carruth return stripPointerCastsAndOffsets<PSK_ZeroIndices>(this); 38584dfc32ff906271c373819595e60a173624e1184Chandler Carruth} 38684dfc32ff906271c373819595e60a173624e1184Chandler Carruth 387274d377ea68195989c3238fe96ce2ca812a12fafChandler CarruthValue *Value::stripInBoundsConstantOffsets() { 388274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(this); 38984dfc32ff906271c373819595e60a173624e1184Chandler Carruth} 39084dfc32ff906271c373819595e60a173624e1184Chandler Carruth 39184dfc32ff906271c373819595e60a173624e1184Chandler CarruthValue *Value::stripInBoundsOffsets() { 39284dfc32ff906271c373819595e60a173624e1184Chandler Carruth return stripPointerCastsAndOffsets<PSK_InBounds>(this); 39384dfc32ff906271c373819595e60a173624e1184Chandler Carruth} 3940b12ecf6ff6b5d3a144178257b6206f0c4788792Anton Korobeynikov 3954d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman/// isDereferenceablePointer - Test if this value is always a pointer to 39667b6464377a444a15a1a26fb8ca7cd54fc056de8Nick Lewycky/// allocated and suitably aligned memory for a simple load or store. 39737abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewyckystatic bool isDereferenceablePointer(const Value *V, 39837abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky SmallPtrSet<const Value *, 32> &Visited) { 3994d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Note that it is not safe to speculate into a malloc'd region because 4004d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // malloc may return null. 4014d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // It's also not always safe to follow a bitcast, for example: 4024d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // bitcast i8* (alloca i8) to i32* 4034d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // would result in a 4-byte load from a 1-byte alloca. Some cases could 4043574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow // be handled using DataLayout to check sizes and alignments though. 4054d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4064d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // These are obviously ok. 40737abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (isa<AllocaInst>(V)) return true; 4084d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4094d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Global variables which can't collapse to null are ok. 41037abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) 4114d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return !GV->hasExternalWeakLinkage(); 4124d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4133928af6ac47f9abef7dff32823a5fd41743c8fbcChris Lattner // byval arguments are ok. 41437abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (const Argument *A = dyn_cast<Argument>(V)) 4153928af6ac47f9abef7dff32823a5fd41743c8fbcChris Lattner return A->hasByValAttr(); 41637abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky 4174d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // For GEPs, determine if the indexing lands within the allocated object. 41837abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 4194d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Conservatively require that the base pointer be fully dereferenceable. 42037abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (!Visited.insert(GEP->getOperand(0))) 42137abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky return false; 42237abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (!isDereferenceablePointer(GEP->getOperand(0), Visited)) 4234d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4244d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Check the indices. 4254d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman gep_type_iterator GTI = gep_type_begin(GEP); 4264d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman for (User::const_op_iterator I = GEP->op_begin()+1, 4274d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman E = GEP->op_end(); I != E; ++I) { 4284d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman Value *Index = *I; 429db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = *GTI++; 4304d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Struct indices can't be out of bounds. 4314d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (isa<StructType>(Ty)) 4324d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman continue; 4334d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman ConstantInt *CI = dyn_cast<ConstantInt>(Index); 4344d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (!CI) 4354d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4364d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Zero is always ok. 4374d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (CI->isZero()) 4384d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman continue; 4394d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Check to see that it's within the bounds of an array. 440db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *ATy = dyn_cast<ArrayType>(Ty); 4414d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (!ATy) 4424d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4434d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (CI->getValue().getActiveBits() > 64) 4444d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4454d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (CI->getZExtValue() >= ATy->getNumElements()) 4464d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4474d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman } 4484d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Indices check out; this is dereferenceable. 4494d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return true; 4504d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman } 4514d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4524d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // If we don't know, assume the worst. 4534d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4544d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman} 4554d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 45637abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky/// isDereferenceablePointer - Test if this value is always a pointer to 45737abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky/// allocated and suitably aligned memory for a simple load or store. 45837abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewyckybool Value::isDereferenceablePointer() const { 45937abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky SmallPtrSet<const Value *, 32> Visited; 46037abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky return ::isDereferenceablePointer(this, Visited); 46137abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky} 46237abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky 46301c8e0233d086354b55d2047506ac6a8fc3c9f65Chris Lattner/// DoPHITranslation - If this value is a PHI node with CurBB as its parent, 464c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner/// return the value in the PHI node corresponding to PredBB. If not, return 465c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner/// ourself. This is useful if you want to know the value something has in a 466c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner/// predecessor block. 467ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel DunbarValue *Value::DoPHITranslation(const BasicBlock *CurBB, 468c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner const BasicBlock *PredBB) { 469c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner PHINode *PN = dyn_cast<PHINode>(this); 470c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner if (PN && PN->getParent() == CurBB) 471c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner return PN->getIncomingValueForBlock(PredBB); 472c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner return this; 473c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner} 474c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner 475e922c0201916e0b980ab3cfe91e1413e68d55647Owen AndersonLLVMContext &Value::getContext() const { return VTy->getContext(); } 476e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson 477722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===----------------------------------------------------------------------===// 478722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// ValueHandleBase Class 479722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===----------------------------------------------------------------------===// 480722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 481fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump/// AddToExistingUseList - Add this ValueHandle to the use list for VP, where 482fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump/// List is known to point into the existing use list. 483722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::AddToExistingUseList(ValueHandleBase **List) { 484722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(List && "Handle list is null?"); 485ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 486722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Splice ourselves into the list. 487722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Next = *List; 488722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner *List = this; 489722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner setPrevPtr(List); 490722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (Next) { 491722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Next->setPrevPtr(&Next); 4925252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(VP.getPointer() == Next->VP.getPointer() && "Added to wrong list?"); 493722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 494722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 495722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 4966a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskinvoid ValueHandleBase::AddToExistingUseListAfter(ValueHandleBase *List) { 4976a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin assert(List && "Must insert after existing node"); 4986a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 4996a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Next = List->Next; 5006a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin setPrevPtr(&List->Next); 5016a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin List->Next = this; 5026a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin if (Next) 5036a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Next->setPrevPtr(&Next); 5046a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin} 5056a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 506722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// AddToUseList - Add this ValueHandle to the use list for VP. 507722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::AddToUseList() { 5085252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(VP.getPointer() && "Null pointer doesn't have a use list!"); 509ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5105252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling LLVMContextImpl *pImpl = VP.getPointer()->getContext().pImpl; 511ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5125252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (VP.getPointer()->HasValueHandle) { 513722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // If this value already has a ValueHandle, then it must be in the 514722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // ValueHandles map already. 5155252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling ValueHandleBase *&Entry = pImpl->ValueHandles[VP.getPointer()]; 516722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry != 0 && "Value doesn't have any handles?"); 517f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson AddToExistingUseList(&Entry); 518f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson return; 519722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 520ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 521722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Ok, it doesn't have any handles yet, so we must insert it into the 522722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // DenseMap. However, doing this insertion could cause the DenseMap to 523722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // reallocate itself, which would invalidate all of the PrevP pointers that 524722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // point into the old table. Handle this by checking for reallocation and 525722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // updating the stale pointers only if needed. 5264d919438898d542850449235da7f6dc55e6ca152Owen Anderson DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles; 527722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner const void *OldBucketPtr = Handles.getPointerIntoBucketsArray(); 528ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5295252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling ValueHandleBase *&Entry = Handles[VP.getPointer()]; 530722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry == 0 && "Value really did already have handles?"); 531722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AddToExistingUseList(&Entry); 5325252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling VP.getPointer()->HasValueHandle = true; 533ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 534722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // If reallocation didn't happen or if this was the first insertion, don't 535722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // walk the table. 536ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Handles.isPointerIntoBucketsArray(OldBucketPtr) || 537f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson Handles.size() == 1) { 538722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return; 539f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson } 540ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 541722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Okay, reallocation did happen. Fix the Prev Pointers. 5424d919438898d542850449235da7f6dc55e6ca152Owen Anderson for (DenseMap<Value*, ValueHandleBase*>::iterator I = Handles.begin(), 5434d919438898d542850449235da7f6dc55e6ca152Owen Anderson E = Handles.end(); I != E; ++I) { 5445252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(I->second && I->first == I->second->VP.getPointer() && 5455252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling "List invariant broken!"); 546722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner I->second->setPrevPtr(&I->second); 547722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 548722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 549722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 550722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// RemoveFromUseList - Remove this ValueHandle from its current use list. 551722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::RemoveFromUseList() { 5525252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(VP.getPointer() && VP.getPointer()->HasValueHandle && 5535252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling "Pointer doesn't have a use list!"); 554722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 555722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Unlink this from its use list. 556722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase **PrevPtr = getPrevPtr(); 557722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(*PrevPtr == this && "List invariant broken"); 558ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 559722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner *PrevPtr = Next; 560722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (Next) { 561722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Next->getPrevPtr() == &Next && "List invariant broken"); 562722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Next->setPrevPtr(PrevPtr); 563722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return; 564722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 565ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 566722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // If the Next pointer was null, then it is possible that this was the last 567722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // ValueHandle watching VP. If so, delete its entry from the ValueHandles 568722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // map. 5695252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling LLVMContextImpl *pImpl = VP.getPointer()->getContext().pImpl; 5704d919438898d542850449235da7f6dc55e6ca152Owen Anderson DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles; 571722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (Handles.isPointerIntoBucketsArray(PrevPtr)) { 5725252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling Handles.erase(VP.getPointer()); 5735252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling VP.getPointer()->HasValueHandle = false; 574722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 575722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 576722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 577722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 578722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::ValueIsDeleted(Value *V) { 579722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(V->HasValueHandle && "Should only be called if ValueHandles present"); 580722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 581722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Get the linked list base, which is guaranteed to exist since the 582722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // HasValueHandle flag is set. 5834d919438898d542850449235da7f6dc55e6ca152Owen Anderson LLVMContextImpl *pImpl = V->getContext().pImpl; 5844d919438898d542850449235da7f6dc55e6ca152Owen Anderson ValueHandleBase *Entry = pImpl->ValueHandles[V]; 585722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry && "Value bit set but no entries exist"); 586ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 587ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // We use a local ValueHandleBase as an iterator so that ValueHandles can add 588ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // and remove themselves from the list without breaking our iteration. This 589ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // is not really an AssertingVH; we just have to give ValueHandleBase a kind. 590ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // Note that we deliberately do not the support the case when dropping a value 591ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // handle results in a new value handle being permanently added to the list 592ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // (as might occur in theory for CallbackVH's): the new value handle will not 5932c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands // be processed and the checking code will mete out righteous punishment if 594ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // the handle is still present once we have finished processing all the other 595ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // value handles (it is fine to momentarily add then remove a value handle). 5966a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { 5976a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.RemoveFromUseList(); 5986a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.AddToExistingUseListAfter(Entry); 5996a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin assert(Entry->Next == &Iterator && "Loop invariant broken."); 600ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6016a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin switch (Entry->getKind()) { 602722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Assert: 6036a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin break; 604e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar case Tracking: 605e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Mark that this value has been deleted by setting it to an invalid Value 606e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // pointer. 6076a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Entry->operator=(DenseMapInfo<Value *>::getTombstoneKey()); 608e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar break; 609722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Weak: 610722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Weak just goes to null, which will unlink it from the list. 6116a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Entry->operator=(0); 612722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner break; 613722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Callback: 614c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman // Forward to the subclass's implementation. 6156a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin static_cast<CallbackVH*>(Entry)->deleted(); 616c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman break; 617722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 618722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 619ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6206a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // All callbacks, weak references, and assertingVHs should be dropped by now. 6216a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin if (V->HasValueHandle) { 6226a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin#ifndef NDEBUG // Only in +Asserts mode... 623a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer dbgs() << "While deleting: " << *V->getType() << " %" << V->getName() 6246a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin << "\n"; 6256a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin if (pImpl->ValueHandles[V]->getKind() == Assert) 6266a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin llvm_unreachable("An asserting value handle still pointed to this" 6276a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin " value!"); 6286a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 6296a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin#endif 6306a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin llvm_unreachable("All references to V were not removed?"); 6316a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin } 632722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 633722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 634722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 635722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) { 636722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Old->HasValueHandle &&"Should only be called if ValueHandles present"); 637722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Old != New && "Changing value into itself!"); 638ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 639722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Get the linked list base, which is guaranteed to exist since the 640722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // HasValueHandle flag is set. 6414d919438898d542850449235da7f6dc55e6ca152Owen Anderson LLVMContextImpl *pImpl = Old->getContext().pImpl; 6424d919438898d542850449235da7f6dc55e6ca152Owen Anderson ValueHandleBase *Entry = pImpl->ValueHandles[Old]; 6434d919438898d542850449235da7f6dc55e6ca152Owen Anderson 644722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry && "Value bit set but no entries exist"); 645ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6466a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // We use a local ValueHandleBase as an iterator so that 6476a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // ValueHandles can add and remove themselves from the list without 6486a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // breaking our iteration. This is not really an AssertingVH; we 6496a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // just have to give ValueHandleBase some kind. 6506a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { 6516a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.RemoveFromUseList(); 6526a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.AddToExistingUseListAfter(Entry); 6536a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin assert(Entry->Next == &Iterator && "Loop invariant broken."); 654ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6556a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin switch (Entry->getKind()) { 656722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Assert: 657722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Asserting handle does not follow RAUW implicitly. 658722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner break; 659e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar case Tracking: 660e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Tracking goes to new value like a WeakVH. Note that this may make it 661e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // something incompatible with its templated type. We don't want to have a 662e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // virtual (or inline) interface to handle this though, so instead we make 663460a786b349cceb79917cb76712ec4941bef69ccDaniel Dunbar // the TrackingVH accessors guarantee that a client never sees this value. 664e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 665e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // FALLTHROUGH 666722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Weak: 667722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Weak goes to the new value, which will unlink it from Old's list. 6686a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Entry->operator=(New); 669722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner break; 670722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Callback: 671c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman // Forward to the subclass's implementation. 6726a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New); 673c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman break; 674722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 675722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 6762c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands 6772c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands#ifndef NDEBUG 6782c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands // If any new tracking or weak value handles were added while processing the 6792c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands // list, then complain about it now. 6802c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands if (Old->HasValueHandle) 6812c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next) 6822c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands switch (Entry->getKind()) { 6832c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands case Tracking: 6842c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands case Weak: 6852c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands dbgs() << "After RAUW from " << *Old->getType() << " %" 686a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer << Old->getName() << " to " << *New->getType() << " %" 687a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer << New->getName() << "\n"; 6882c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands llvm_unreachable("A tracking or weak value handle still pointed to the" 6892c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands " old value!\n"); 6902c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands default: 6912c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands break; 6922c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands } 6932c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands#endif 694722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 695722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 6964e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer// Default implementation for CallbackVH. 6974e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramervoid CallbackVH::allUsesReplacedWith(Value *) {} 6984e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer 6994e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramervoid CallbackVH::deleted() { 7004e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer setValPtr(NULL); 7014e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer} 702