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 144d919438898d542850449235da7f6dc55e6ca152Owen Anderson#include "LLVMContextImpl.h" 150d1e40728d668085257b78657b381e1f13d77d52Chris Lattner#include "llvm/Constant.h" 16b04adddd50dfa4c3fbdad3b15d601402254c1ff5Anton Korobeynikov#include "llvm/Constants.h" 170d1e40728d668085257b78657b381e1f13d77d52Chris Lattner#include "llvm/DerivedTypes.h" 18009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/InstrTypes.h" 19bb4f8d40458eb086cb901e19c4be0777e2a73dceDevang Patel#include "llvm/Instructions.h" 203a7a68c10880c2a28387617b42d14d774e218727Dan Gohman#include "llvm/Operator.h" 210d1e40728d668085257b78657b381e1f13d77d52Chris Lattner#include "llvm/Module.h" 22ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer#include "llvm/ValueSymbolTable.h" 236e0d1cb30957a636c53158d3089e6fb88348a57aDaniel Dunbar#include "llvm/ADT/SmallString.h" 242e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling#include "llvm/Support/Debug.h" 254d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman#include "llvm/Support/GetElementPtrTypeIterator.h" 26ab7c09b6b6f4516a631fd6788918c237c83939afTorok Edwin#include "llvm/Support/ErrorHandling.h" 27551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/LeakDetector.h" 28722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#include "llvm/Support/ManagedStatic.h" 29722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#include "llvm/Support/ValueHandle.h" 30722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#include "llvm/ADT/DenseMap.h" 31009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include <algorithm> 3231f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 33d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 34009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 35009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// Value Class 36009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 37009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 38db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic inline Type *checkType(Type *Ty) { 3982d18aa0e42a4858c2cb7c15934cc3e567432490Chris Lattner assert(Ty && "Value defined with a null type: Error!"); 401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return const_cast<Type*>(Ty); 4182d18aa0e42a4858c2cb7c15934cc3e567432490Chris Lattner} 4282d18aa0e42a4858c2cb7c15934cc3e567432490Chris Lattner 43db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerValue::Value(Type *ty, unsigned scid) 443990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner : SubclassID(scid), HasValueHandle(0), 451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SubclassOptionalData(0), SubclassData(0), VTy((Type*)checkType(ty)), 466f4266506bca785828bacda55bd5db9172f990c6Gabor Greif UseList(0), Name(0) { 471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // FIXME: Why isn't this in the subclass gunk?? 48db71d63467bdb7b629641fee3272b47bd028e09fDevang Patel if (isa<CallInst>(this) || isa<InvokeInst>(this)) 491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) && 501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "invalid CallInst type!"); 51bb4f8d40458eb086cb901e19c4be0777e2a73dceDevang Patel else if (!isa<Constant>(this) && !isa<BasicBlock>(this)) 521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((VTy->isFirstClassType() || VTy->isVoidTy()) && 53a9e7781b3b8e457946491529816feab73c66d774Chris Lattner "Cannot create non-first-class values except for constants!"); 54009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 55009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 56afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon HenriksenValue::~Value() { 57722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Notify all ValueHandles (if present) that this value is going away. 58722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (HasValueHandle) 59722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase::ValueIsDeleted(this); 60ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 61009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#ifndef NDEBUG // Only in -g mode... 62ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // Check to make sure that there are no uses of this value that are still 63ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // around when the value is destroyed. If there are, then we have a dangling 64ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // reference and something is wrong. This code is here to print out what is 65fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // still being referenced. The value in question should be printed as 66ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // a <badref> 67ee976f33713016a96e3fbb394b7d0c5465be25d7Chris Lattner // 68afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon Henriksen if (!use_empty()) { 69a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer dbgs() << "While deleting: " << *VTy << " %" << getName() << "\n"; 70afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon Henriksen for (use_iterator I = use_begin(), E = use_end(); I != E; ++I) 716892c7a92d0d2132b8361f7324824a680d09134cDavid Greene dbgs() << "Use still stuck around after Def is destroyed:" 722e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling << **I << "\n"; 73009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 74009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#endif 75afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon Henriksen assert(use_empty() && "Uses remain when a value is destroyed!"); 764f95d2bda4235d36acd95688d0744d7363214706Chris Lattner 774f95d2bda4235d36acd95688d0744d7363214706Chris Lattner // If this value is named, destroy the name. This should not be in a symtab 784f95d2bda4235d36acd95688d0744d7363214706Chris Lattner // at this point. 793ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling if (Name && SubclassID != MDStringVal) 804f95d2bda4235d36acd95688d0744d7363214706Chris Lattner Name->Destroy(); 81ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 824f95d2bda4235d36acd95688d0744d7363214706Chris Lattner // There should be no uses of this object anymore, remove it. 834f95d2bda4235d36acd95688d0744d7363214706Chris Lattner LeakDetector::removeGarbageObject(this); 84009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 85009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8629d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// hasNUses - Return true if this Value has exactly N users. 8729d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// 8829d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattnerbool Value::hasNUses(unsigned N) const { 8960ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif const_use_iterator UI = use_begin(), E = use_end(); 9029d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner 9129d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner for (; N; --N, ++UI) 9229d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner if (UI == E) return false; // Too few. 9329d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner return UI == E; 9429d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner} 9529d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner 968daf056c90c2590709090b0c27045e1a45803461Chris Lattner/// hasNUsesOrMore - Return true if this value has N users or more. This is 978daf056c90c2590709090b0c27045e1a45803461Chris Lattner/// logically equivalent to getNumUses() >= N. 988daf056c90c2590709090b0c27045e1a45803461Chris Lattner/// 998daf056c90c2590709090b0c27045e1a45803461Chris Lattnerbool Value::hasNUsesOrMore(unsigned N) const { 10060ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif const_use_iterator UI = use_begin(), E = use_end(); 1018daf056c90c2590709090b0c27045e1a45803461Chris Lattner 1028daf056c90c2590709090b0c27045e1a45803461Chris Lattner for (; N; --N, ++UI) 1038daf056c90c2590709090b0c27045e1a45803461Chris Lattner if (UI == E) return false; // Too few. 1048daf056c90c2590709090b0c27045e1a45803461Chris Lattner 1058daf056c90c2590709090b0c27045e1a45803461Chris Lattner return true; 1068daf056c90c2590709090b0c27045e1a45803461Chris Lattner} 1078daf056c90c2590709090b0c27045e1a45803461Chris Lattner 108502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng/// isUsedInBasicBlock - Return true if this value is used in the specified 109502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng/// basic block. 110c4f72dd6e759a170808ecfc6be784f8598367484Bill Wendlingbool Value::isUsedInBasicBlock(const BasicBlock *BB) const { 1114da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer // Start by scanning over the instructions looking for a use before we start 1124da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer // the expensive use iteration. 1134da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer unsigned MaxBlockSize = 3; 1144da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 1154da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer if (std::find(I->op_begin(), I->op_end(), this) != I->op_end()) 1164da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer return true; 1174da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer if (MaxBlockSize-- == 0) // If the block is larger fall back to use_iterator 1184da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer break; 1194da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer } 1204da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer 1214da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer if (MaxBlockSize != 0) // We scanned the entire block and found no use. 1224da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer return false; 1234da7f90b1780e4d1ba38da64c849b9c2b1c67071Benjamin Kramer 12460ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif for (const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) { 125502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng const Instruction *User = dyn_cast<Instruction>(*I); 126502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng if (User && User->getParent() == BB) 127502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng return true; 128502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng } 129502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng return false; 130502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng} 131502a4f5162498ec420e3cb22f667808d726dd7daEvan Cheng 1328daf056c90c2590709090b0c27045e1a45803461Chris Lattner 13329d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// getNumUses - This method computes the number of uses of this Value. This 13429d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// is a linear time operation. Use hasOneUse or hasNUses to check for specific 13529d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner/// values. 13629d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattnerunsigned Value::getNumUses() const { 13729d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner return (unsigned)std::distance(use_begin(), use_end()); 13829d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner} 13929d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner 1407216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattnerstatic bool getSymTab(Value *V, ValueSymbolTable *&ST) { 141ea7acb859111a7f55c497e0b7cf569ac81e97208Chris Lattner ST = 0; 1427216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner if (Instruction *I = dyn_cast<Instruction>(V)) { 1430d1e40728d668085257b78657b381e1f13d77d52Chris Lattner if (BasicBlock *P = I->getParent()) 1440d1e40728d668085257b78657b381e1f13d77d52Chris Lattner if (Function *PP = P->getParent()) 14578d033e086e19e016273de014f9214aa6f3f844bReid Spencer ST = &PP->getValueSymbolTable(); 1467216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner } else if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 147ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Function *P = BB->getParent()) 148ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ST = &P->getValueSymbolTable(); 1497216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 150ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Module *P = GV->getParent()) 151ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ST = &P->getValueSymbolTable(); 1527216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner } else if (Argument *A = dyn_cast<Argument>(V)) { 153ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Function *P = A->getParent()) 154ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ST = &P->getValueSymbolTable(); 155e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel } else if (isa<MDString>(V)) 156e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel return true; 157e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel else { 1587216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner assert(isa<Constant>(V) && "Unknown value type!"); 1597216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner return true; // no name is setable for this. 1600d1e40728d668085257b78657b381e1f13d77d52Chris Lattner } 1617216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner return false; 1627216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner} 1637216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner 164499027fb4826e25919f2ea154ca4db73842560afDaniel DunbarStringRef Value::getName() const { 1654fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar // Make sure the empty string is still a C string. For historical reasons, 1664fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar // some clients want to call .data() on the result and expect it to be null 1674fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar // terminated. 1684fa4990bdcb1fc2aa7831b1e6b113998366b2918Daniel Dunbar if (!Name) return StringRef("", 0); 169499027fb4826e25919f2ea154ca4db73842560afDaniel Dunbar return Name->getKey(); 17071996e73d8050d2b8805b14a48ab635155b11a12Chris Lattner} 17171996e73d8050d2b8805b14a48ab635155b11a12Chris Lattner 1723f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbarvoid Value::setName(const Twine &NewName) { 1733ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling assert(SubclassID != MDStringVal && 1743ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling "Cannot set the name of MDString with this method!"); 1753ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling 1765149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar // Fast path for common IRBuilder case of setName("") when there is no name. 1775149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar if (NewName.isTriviallyEmpty() && !hasName()) 1785149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar return; 1795149932068f535e1ff13b91c9669f55718c60a07Daniel Dunbar 180e476004b94582c64a0fabaa0e251a0f070909843Daniel Dunbar SmallString<256> NameData; 181b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer StringRef NameRef = NewName.toStringRef(NameData); 182042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner 18307f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar // Name isn't changing? 184b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer if (getName() == NameRef) 18507f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar return; 18607f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar 187f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer assert(!getType()->isVoidTy() && "Cannot assign a name to void values!"); 188ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 1897216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner // Get the symbol table to update for this object. 1907216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner ValueSymbolTable *ST; 1917216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner if (getSymTab(this, ST)) 1927216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner return; // Cannot set a name on this value (e.g. constant). 1930d1e40728d668085257b78657b381e1f13d77d52Chris Lattner 194dec628eead87b20773c98a00830580df211acc98Chris Lattner if (!ST) { // No symbol table to update? Just do the change. 195b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer if (NameRef.empty()) { 196dec628eead87b20773c98a00830580df211acc98Chris Lattner // Free the name for this value. 197dec628eead87b20773c98a00830580df211acc98Chris Lattner Name->Destroy(); 198dec628eead87b20773c98a00830580df211acc98Chris Lattner Name = 0; 199042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner return; 20004cb800c324ef661017aff474e266ed7f2cddb90Chris Lattner } 201ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 20207f6903cbefe268d7fbf7f17fc8c1cddae16db5aDaniel Dunbar if (Name) 203042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner Name->Destroy(); 204ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 205042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner // NOTE: Could optimize for the case the name is shrinking to not deallocate 206042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner // then reallocated. 207ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 208042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner // Create the new name. 209b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer Name = ValueName::Create(NameRef.begin(), NameRef.end()); 210042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner Name->setValue(this); 211dec628eead87b20773c98a00830580df211acc98Chris Lattner return; 212dec628eead87b20773c98a00830580df211acc98Chris Lattner } 213ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 214dec628eead87b20773c98a00830580df211acc98Chris Lattner // NOTE: Could optimize for the case the name is shrinking to not deallocate 215dec628eead87b20773c98a00830580df211acc98Chris Lattner // then reallocated. 216dec628eead87b20773c98a00830580df211acc98Chris Lattner if (hasName()) { 217dec628eead87b20773c98a00830580df211acc98Chris Lattner // Remove old name. 218dec628eead87b20773c98a00830580df211acc98Chris Lattner ST->removeValueName(Name); 219dec628eead87b20773c98a00830580df211acc98Chris Lattner Name->Destroy(); 220dec628eead87b20773c98a00830580df211acc98Chris Lattner Name = 0; 221dec628eead87b20773c98a00830580df211acc98Chris Lattner 222b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer if (NameRef.empty()) 223042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner return; 22404cb800c324ef661017aff474e266ed7f2cddb90Chris Lattner } 225dec628eead87b20773c98a00830580df211acc98Chris Lattner 226dec628eead87b20773c98a00830580df211acc98Chris Lattner // Name is changing to something new. 227b357e06f672996400343d38b08014a5b6a7d5b2dBenjamin Kramer Name = ST->createValueName(NameRef, this); 2280d1e40728d668085257b78657b381e1f13d77d52Chris Lattner} 2290d1e40728d668085257b78657b381e1f13d77d52Chris Lattner 230042ad36871d67a2db48bf41a8dbde3a5676fc96fChris Lattner 2317216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner/// takeName - transfer the name from V to this value, setting V's name to 232ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar/// empty. It is an error to call V->takeName(V). 2337216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattnervoid Value::takeName(Value *V) { 2343ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling assert(SubclassID != MDStringVal && "Cannot take the name of an MDString!"); 2353ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling 2360878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ValueSymbolTable *ST = 0; 2370878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // If this value has a name, drop it. 2380878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (hasName()) { 2390878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Get the symtab this is in. 2400878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (getSymTab(this, ST)) { 2410878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // We can't set a name on this value, but we need to clear V's name if 2420878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // it has one. 2433f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbar if (V->hasName()) V->setName(""); 2440878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner return; // Cannot set a name on this value (e.g. constant). 2450878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner } 246ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2470878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Remove old name. 2480878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (ST) 2490878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ST->removeValueName(Name); 2500878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name->Destroy(); 2510878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name = 0; 252ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar } 253ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2540878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Now we know that this has no name. 255ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2560878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // If V has no name either, we're done. 2570878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (!V->hasName()) return; 258ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2590878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Get this's symtab if we didn't before. 2600878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (!ST) { 2610878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (getSymTab(this, ST)) { 2620878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Clear V's name. 2633f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbar V->setName(""); 2640878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner return; // Cannot set a name on this value (e.g. constant). 2650878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner } 2660878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner } 267ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2680878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Get V's ST, this should always succed, because V has a name. 2690878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ValueSymbolTable *VST; 2700878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner bool Failure = getSymTab(V, VST); 2718e68c3873549ca31533e2e3e40dda3a43cb79566Jeffrey Yasskin assert(!Failure && "V has a name, so it should have a ST!"); (void)Failure; 272ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2730878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // If these values are both in the same symtab, we can do this very fast. 2740878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // This works even if both values have no symtab yet. 2750878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (ST == VST) { 2760878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Take the name! 2770878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name = V->Name; 2780878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner V->Name = 0; 2790878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name->setValue(this); 280f41916e75dc9c622fa81b91eb6a5e0a36fa13754Chris Lattner return; 281f41916e75dc9c622fa81b91eb6a5e0a36fa13754Chris Lattner } 282ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2830878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // Otherwise, things are slightly more complex. Remove V's name from VST and 2840878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner // then reinsert it into ST. 285ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2860878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (VST) 2870878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner VST->removeValueName(V->Name); 2880878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name = V->Name; 2890878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner V->Name = 0; 2900878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner Name->setValue(this); 291ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 2920878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner if (ST) 2930878c310596d564e75657bf3c771431b4ef7eea5Chris Lattner ST->reinsertValue(this); 2947216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner} 2957216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner 2967216811ea22d68cbf8df092cda8e64e13e394ac8Chris Lattner 297678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattnervoid Value::replaceAllUsesWith(Value *New) { 298678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner assert(New && "Value::replaceAllUsesWith(<null>) is invalid!"); 299678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner assert(New != this && "this->replaceAllUsesWith(this) is NOT valid!"); 300678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner assert(New->getType() == getType() && 301678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner "replaceAllUses of value with new value of different type!"); 302678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner 303722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Notify all ValueHandles (if present) that this value is going away. 304722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (HasValueHandle) 305722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase::ValueIsRAUWd(this, New); 306678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner 30729d1ca6c424df225b9fd48473f0d6419fdd44bd7Chris Lattner while (!use_empty()) { 3086f4266506bca785828bacda55bd5db9172f990c6Gabor Greif Use &U = *UseList; 3092bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner // Must handle Constants specially, we cannot call replaceUsesOfWith on a 3102d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner // constant because they are uniqued. 311c3cc71abbcac9a5d172e64002e2262c8f1a41967Chris Lattner if (Constant *C = dyn_cast<Constant>(U.getUser())) { 3122d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner if (!isa<GlobalValue>(C)) { 313d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner C->replaceUsesOfWithOnConstant(this, New, &U); 3142d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner continue; 3152d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner } 3162bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner } 317678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner 3182d691333acec66118ede55b6d7ec7a3083bc1e01Chris Lattner U.set(New); 3192bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner } 320678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner 32195c3e48f9557adb6064d580684bb14cacec2f826Jay Foad if (BasicBlock *BB = dyn_cast<BasicBlock>(this)) 32295c3e48f9557adb6064d580684bb14cacec2f826Jay Foad BB->replaceSuccessorsPhiUsesWith(cast<BasicBlock>(New)); 3232bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner} 3242bc065b63a8377456ddbe149621b3daf15f052a4Chris Lattner 32584dfc32ff906271c373819595e60a173624e1184Chandler Carruthnamespace { 32684dfc32ff906271c373819595e60a173624e1184Chandler Carruth// Various metrics for how much to strip off of pointers. 32784dfc32ff906271c373819595e60a173624e1184Chandler Carruthenum PointerStripKind { 32884dfc32ff906271c373819595e60a173624e1184Chandler Carruth PSK_ZeroIndices, 329274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth PSK_InBoundsConstantIndices, 330274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth PSK_InBounds 33184dfc32ff906271c373819595e60a173624e1184Chandler Carruth}; 33284dfc32ff906271c373819595e60a173624e1184Chandler Carruth 33384dfc32ff906271c373819595e60a173624e1184Chandler Carruthtemplate <PointerStripKind StripKind> 33484dfc32ff906271c373819595e60a173624e1184Chandler Carruthstatic Value *stripPointerCastsAndOffsets(Value *V) { 33584dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!V->getType()->isPointerTy()) 33684dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 33750f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman 33850f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman // Even though we don't look through PHI nodes, we could be called on an 33950f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman // instruction in an unreachable block, which may be on a cycle. 34050f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman SmallPtrSet<Value *, 4> Visited; 34150f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman 34250f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman Visited.insert(V); 343f08bf1193c390bfe4b25d8533f146742d0277d06Duncan Sands do { 344016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 34584dfc32ff906271c373819595e60a173624e1184Chandler Carruth switch (StripKind) { 34684dfc32ff906271c373819595e60a173624e1184Chandler Carruth case PSK_ZeroIndices: 34784dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!GEP->hasAllZeroIndices()) 34884dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 34984dfc32ff906271c373819595e60a173624e1184Chandler Carruth break; 350274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth case PSK_InBoundsConstantIndices: 35184dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!GEP->hasAllConstantIndices()) 35284dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 353274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth // fallthrough 35484dfc32ff906271c373819595e60a173624e1184Chandler Carruth case PSK_InBounds: 35584dfc32ff906271c373819595e60a173624e1184Chandler Carruth if (!GEP->isInBounds()) 35684dfc32ff906271c373819595e60a173624e1184Chandler Carruth return V; 35784dfc32ff906271c373819595e60a173624e1184Chandler Carruth break; 35884dfc32ff906271c373819595e60a173624e1184Chandler Carruth } 359016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman V = GEP->getPointerOperand(); 360016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman } else if (Operator::getOpcode(V) == Instruction::BitCast) { 361016de81177ec5c950f1668be4a48992bc1ee0d75Dan Gohman V = cast<Operator>(V)->getOperand(0); 362aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 363aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman if (GA->mayBeOverridden()) 364aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman return V; 365aac1bfb99a7a43ce145748f41f64f970f5499de6Dan Gohman V = GA->getAliasee(); 366f08bf1193c390bfe4b25d8533f146742d0277d06Duncan Sands } else { 367f08bf1193c390bfe4b25d8533f146742d0277d06Duncan Sands return V; 3680b12ecf6ff6b5d3a144178257b6206f0c4788792Anton Korobeynikov } 3691df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(V->getType()->isPointerTy() && "Unexpected operand type!"); 37050f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman } while (Visited.insert(V)); 37150f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman 37250f424c3d079d4774bb323de1e0b77cf4627be69Dan Gohman return V; 3730b12ecf6ff6b5d3a144178257b6206f0c4788792Anton Korobeynikov} 37484dfc32ff906271c373819595e60a173624e1184Chandler Carruth} // namespace 37584dfc32ff906271c373819595e60a173624e1184Chandler Carruth 37684dfc32ff906271c373819595e60a173624e1184Chandler CarruthValue *Value::stripPointerCasts() { 37784dfc32ff906271c373819595e60a173624e1184Chandler Carruth return stripPointerCastsAndOffsets<PSK_ZeroIndices>(this); 37884dfc32ff906271c373819595e60a173624e1184Chandler Carruth} 37984dfc32ff906271c373819595e60a173624e1184Chandler Carruth 380274d377ea68195989c3238fe96ce2ca812a12fafChandler CarruthValue *Value::stripInBoundsConstantOffsets() { 381274d377ea68195989c3238fe96ce2ca812a12fafChandler Carruth return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(this); 38284dfc32ff906271c373819595e60a173624e1184Chandler Carruth} 38384dfc32ff906271c373819595e60a173624e1184Chandler Carruth 38484dfc32ff906271c373819595e60a173624e1184Chandler CarruthValue *Value::stripInBoundsOffsets() { 38584dfc32ff906271c373819595e60a173624e1184Chandler Carruth return stripPointerCastsAndOffsets<PSK_InBounds>(this); 38684dfc32ff906271c373819595e60a173624e1184Chandler Carruth} 3870b12ecf6ff6b5d3a144178257b6206f0c4788792Anton Korobeynikov 3884d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman/// isDereferenceablePointer - Test if this value is always a pointer to 38967b6464377a444a15a1a26fb8ca7cd54fc056de8Nick Lewycky/// allocated and suitably aligned memory for a simple load or store. 39037abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewyckystatic bool isDereferenceablePointer(const Value *V, 39137abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky SmallPtrSet<const Value *, 32> &Visited) { 3924d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Note that it is not safe to speculate into a malloc'd region because 3934d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // malloc may return null. 3944d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // It's also not always safe to follow a bitcast, for example: 3954d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // bitcast i8* (alloca i8) to i32* 3964d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // would result in a 4-byte load from a 1-byte alloca. Some cases could 3974d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // be handled using TargetData to check sizes and alignments though. 3984d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 3994d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // These are obviously ok. 40037abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (isa<AllocaInst>(V)) return true; 4014d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4024d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Global variables which can't collapse to null are ok. 40337abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) 4044d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return !GV->hasExternalWeakLinkage(); 4054d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4063928af6ac47f9abef7dff32823a5fd41743c8fbcChris Lattner // byval arguments are ok. 40737abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (const Argument *A = dyn_cast<Argument>(V)) 4083928af6ac47f9abef7dff32823a5fd41743c8fbcChris Lattner return A->hasByValAttr(); 40937abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky 4104d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // For GEPs, determine if the indexing lands within the allocated object. 41137abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 4124d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Conservatively require that the base pointer be fully dereferenceable. 41337abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (!Visited.insert(GEP->getOperand(0))) 41437abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky return false; 41537abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky if (!isDereferenceablePointer(GEP->getOperand(0), Visited)) 4164d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4174d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Check the indices. 4184d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman gep_type_iterator GTI = gep_type_begin(GEP); 4194d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman for (User::const_op_iterator I = GEP->op_begin()+1, 4204d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman E = GEP->op_end(); I != E; ++I) { 4214d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman Value *Index = *I; 422db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = *GTI++; 4234d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Struct indices can't be out of bounds. 4244d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (isa<StructType>(Ty)) 4254d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman continue; 4264d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman ConstantInt *CI = dyn_cast<ConstantInt>(Index); 4274d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (!CI) 4284d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4294d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Zero is always ok. 4304d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (CI->isZero()) 4314d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman continue; 4324d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Check to see that it's within the bounds of an array. 433db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *ATy = dyn_cast<ArrayType>(Ty); 4344d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (!ATy) 4354d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4364d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (CI->getValue().getActiveBits() > 64) 4374d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4384d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman if (CI->getZExtValue() >= ATy->getNumElements()) 4394d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4404d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman } 4414d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // Indices check out; this is dereferenceable. 4424d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return true; 4434d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman } 4444d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 4454d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman // If we don't know, assume the worst. 4464d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman return false; 4474d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman} 4484d70a2949007edeaad4662d5cdcb2d272cb2b2ffDan Gohman 44937abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky/// isDereferenceablePointer - Test if this value is always a pointer to 45037abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky/// allocated and suitably aligned memory for a simple load or store. 45137abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewyckybool Value::isDereferenceablePointer() const { 45237abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky SmallPtrSet<const Value *, 32> Visited; 45337abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky return ::isDereferenceablePointer(this, Visited); 45437abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky} 45537abc488a0527bb682af5aa6c4f376b5b99d67e4Nick Lewycky 45601c8e0233d086354b55d2047506ac6a8fc3c9f65Chris Lattner/// DoPHITranslation - If this value is a PHI node with CurBB as its parent, 457c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner/// return the value in the PHI node corresponding to PredBB. If not, return 458c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner/// ourself. This is useful if you want to know the value something has in a 459c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner/// predecessor block. 460ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel DunbarValue *Value::DoPHITranslation(const BasicBlock *CurBB, 461c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner const BasicBlock *PredBB) { 462c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner PHINode *PN = dyn_cast<PHINode>(this); 463c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner if (PN && PN->getParent() == CurBB) 464c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner return PN->getIncomingValueForBlock(PredBB); 465c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner return this; 466c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner} 467c7f7c1dc5067a36c8ae337610dcbbe55d525c80cChris Lattner 468e922c0201916e0b980ab3cfe91e1413e68d55647Owen AndersonLLVMContext &Value::getContext() const { return VTy->getContext(); } 469e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson 470722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===----------------------------------------------------------------------===// 471722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// ValueHandleBase Class 472722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===----------------------------------------------------------------------===// 473722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 474fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump/// AddToExistingUseList - Add this ValueHandle to the use list for VP, where 475fe095f39e7009c51d1c86769792ccbcad8cdd2ecMike Stump/// List is known to point into the existing use list. 476722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::AddToExistingUseList(ValueHandleBase **List) { 477722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(List && "Handle list is null?"); 478ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 479722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Splice ourselves into the list. 480722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Next = *List; 481722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner *List = this; 482722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner setPrevPtr(List); 483722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (Next) { 484722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Next->setPrevPtr(&Next); 4855252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(VP.getPointer() == Next->VP.getPointer() && "Added to wrong list?"); 486722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 487722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 488722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 4896a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskinvoid ValueHandleBase::AddToExistingUseListAfter(ValueHandleBase *List) { 4906a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin assert(List && "Must insert after existing node"); 4916a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 4926a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Next = List->Next; 4936a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin setPrevPtr(&List->Next); 4946a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin List->Next = this; 4956a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin if (Next) 4966a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Next->setPrevPtr(&Next); 4976a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin} 4986a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 499722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// AddToUseList - Add this ValueHandle to the use list for VP. 500722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::AddToUseList() { 5015252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(VP.getPointer() && "Null pointer doesn't have a use list!"); 502ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5035252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling LLVMContextImpl *pImpl = VP.getPointer()->getContext().pImpl; 504ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5055252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (VP.getPointer()->HasValueHandle) { 506722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // If this value already has a ValueHandle, then it must be in the 507722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // ValueHandles map already. 5085252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling ValueHandleBase *&Entry = pImpl->ValueHandles[VP.getPointer()]; 509722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry != 0 && "Value doesn't have any handles?"); 510f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson AddToExistingUseList(&Entry); 511f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson return; 512722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 513ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 514722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Ok, it doesn't have any handles yet, so we must insert it into the 515722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // DenseMap. However, doing this insertion could cause the DenseMap to 516722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // reallocate itself, which would invalidate all of the PrevP pointers that 517722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // point into the old table. Handle this by checking for reallocation and 518722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // updating the stale pointers only if needed. 5194d919438898d542850449235da7f6dc55e6ca152Owen Anderson DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles; 520722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner const void *OldBucketPtr = Handles.getPointerIntoBucketsArray(); 521ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5225252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling ValueHandleBase *&Entry = Handles[VP.getPointer()]; 523722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry == 0 && "Value really did already have handles?"); 524722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AddToExistingUseList(&Entry); 5255252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling VP.getPointer()->HasValueHandle = true; 526ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 527722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // If reallocation didn't happen or if this was the first insertion, don't 528722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // walk the table. 529ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar if (Handles.isPointerIntoBucketsArray(OldBucketPtr) || 530f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson Handles.size() == 1) { 531722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return; 532f2aac28d3040f9c716b4597ec90d237f27883866Owen Anderson } 533ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 534722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Okay, reallocation did happen. Fix the Prev Pointers. 5354d919438898d542850449235da7f6dc55e6ca152Owen Anderson for (DenseMap<Value*, ValueHandleBase*>::iterator I = Handles.begin(), 5364d919438898d542850449235da7f6dc55e6ca152Owen Anderson E = Handles.end(); I != E; ++I) { 5375252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(I->second && I->first == I->second->VP.getPointer() && 5385252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling "List invariant broken!"); 539722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner I->second->setPrevPtr(&I->second); 540722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 541722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 542722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 543722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// RemoveFromUseList - Remove this ValueHandle from its current use list. 544722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::RemoveFromUseList() { 5455252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling assert(VP.getPointer() && VP.getPointer()->HasValueHandle && 5465252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling "Pointer doesn't have a use list!"); 547722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 548722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Unlink this from its use list. 549722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase **PrevPtr = getPrevPtr(); 550722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(*PrevPtr == this && "List invariant broken"); 551ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 552722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner *PrevPtr = Next; 553722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (Next) { 554722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Next->getPrevPtr() == &Next && "List invariant broken"); 555722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Next->setPrevPtr(PrevPtr); 556722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return; 557722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 558ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 559722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // If the Next pointer was null, then it is possible that this was the last 560722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // ValueHandle watching VP. If so, delete its entry from the ValueHandles 561722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // map. 5625252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling LLVMContextImpl *pImpl = VP.getPointer()->getContext().pImpl; 5634d919438898d542850449235da7f6dc55e6ca152Owen Anderson DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles; 564722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner if (Handles.isPointerIntoBucketsArray(PrevPtr)) { 5655252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling Handles.erase(VP.getPointer()); 5665252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling VP.getPointer()->HasValueHandle = false; 567722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 568722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 569722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 570722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 571722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::ValueIsDeleted(Value *V) { 572722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(V->HasValueHandle && "Should only be called if ValueHandles present"); 573722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 574722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Get the linked list base, which is guaranteed to exist since the 575722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // HasValueHandle flag is set. 5764d919438898d542850449235da7f6dc55e6ca152Owen Anderson LLVMContextImpl *pImpl = V->getContext().pImpl; 5774d919438898d542850449235da7f6dc55e6ca152Owen Anderson ValueHandleBase *Entry = pImpl->ValueHandles[V]; 578722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry && "Value bit set but no entries exist"); 579ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 580ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // We use a local ValueHandleBase as an iterator so that ValueHandles can add 581ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // and remove themselves from the list without breaking our iteration. This 582ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // is not really an AssertingVH; we just have to give ValueHandleBase a kind. 583ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // Note that we deliberately do not the support the case when dropping a value 584ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // handle results in a new value handle being permanently added to the list 585ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // (as might occur in theory for CallbackVH's): the new value handle will not 5862c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands // be processed and the checking code will mete out righteous punishment if 587ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // the handle is still present once we have finished processing all the other 588ffe8c8871a1c7119440b2b02dce746901794fa5eDuncan Sands // value handles (it is fine to momentarily add then remove a value handle). 5896a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { 5906a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.RemoveFromUseList(); 5916a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.AddToExistingUseListAfter(Entry); 5926a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin assert(Entry->Next == &Iterator && "Loop invariant broken."); 593ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 5946a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin switch (Entry->getKind()) { 595722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Assert: 5966a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin break; 597e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar case Tracking: 598e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Mark that this value has been deleted by setting it to an invalid Value 599e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // pointer. 6006a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Entry->operator=(DenseMapInfo<Value *>::getTombstoneKey()); 601e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar break; 602722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Weak: 603722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Weak just goes to null, which will unlink it from the list. 6046a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Entry->operator=(0); 605722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner break; 606722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Callback: 607c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman // Forward to the subclass's implementation. 6086a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin static_cast<CallbackVH*>(Entry)->deleted(); 609c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman break; 610722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 611722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 612ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6136a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // All callbacks, weak references, and assertingVHs should be dropped by now. 6146a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin if (V->HasValueHandle) { 6156a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin#ifndef NDEBUG // Only in +Asserts mode... 616a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer dbgs() << "While deleting: " << *V->getType() << " %" << V->getName() 6176a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin << "\n"; 6186a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin if (pImpl->ValueHandles[V]->getKind() == Assert) 6196a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin llvm_unreachable("An asserting value handle still pointed to this" 6206a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin " value!"); 6216a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 6226a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin#endif 6236a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin llvm_unreachable("All references to V were not removed?"); 6246a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin } 625722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 626722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 627722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 628722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnervoid ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) { 629722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Old->HasValueHandle &&"Should only be called if ValueHandles present"); 630722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Old != New && "Changing value into itself!"); 631ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 632722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Get the linked list base, which is guaranteed to exist since the 633722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // HasValueHandle flag is set. 6344d919438898d542850449235da7f6dc55e6ca152Owen Anderson LLVMContextImpl *pImpl = Old->getContext().pImpl; 6354d919438898d542850449235da7f6dc55e6ca152Owen Anderson ValueHandleBase *Entry = pImpl->ValueHandles[Old]; 6364d919438898d542850449235da7f6dc55e6ca152Owen Anderson 637722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner assert(Entry && "Value bit set but no entries exist"); 638ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6396a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // We use a local ValueHandleBase as an iterator so that 6406a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // ValueHandles can add and remove themselves from the list without 6416a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // breaking our iteration. This is not really an AssertingVH; we 6426a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin // just have to give ValueHandleBase some kind. 6436a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { 6446a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.RemoveFromUseList(); 6456a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Iterator.AddToExistingUseListAfter(Entry); 6466a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin assert(Entry->Next == &Iterator && "Loop invariant broken."); 647ce99a6e49ee5f849c33aa1a989b4cc08c71c3c9bDaniel Dunbar 6486a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin switch (Entry->getKind()) { 649722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Assert: 650722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Asserting handle does not follow RAUW implicitly. 651722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner break; 652e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar case Tracking: 653e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Tracking goes to new value like a WeakVH. Note that this may make it 654e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // something incompatible with its templated type. We don't want to have a 655e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // virtual (or inline) interface to handle this though, so instead we make 656460a786b349cceb79917cb76712ec4941bef69ccDaniel Dunbar // the TrackingVH accessors guarantee that a client never sees this value. 657e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 658e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // FALLTHROUGH 659722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Weak: 660722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Weak goes to the new value, which will unlink it from Old's list. 6616a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin Entry->operator=(New); 662722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner break; 663722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner case Callback: 664c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman // Forward to the subclass's implementation. 6656a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New); 666c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman break; 667722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 668722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 6692c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands 6702c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands#ifndef NDEBUG 6712c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands // If any new tracking or weak value handles were added while processing the 6722c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands // list, then complain about it now. 6732c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands if (Old->HasValueHandle) 6742c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next) 6752c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands switch (Entry->getKind()) { 6762c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands case Tracking: 6772c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands case Weak: 6782c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands dbgs() << "After RAUW from " << *Old->getType() << " %" 679a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer << Old->getName() << " to " << *New->getType() << " %" 680a7b0cb759433c715065440ee2a963a04db7f2b0bBenjamin Kramer << New->getName() << "\n"; 6812c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands llvm_unreachable("A tracking or weak value handle still pointed to the" 6822c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands " old value!\n"); 6832c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands default: 6842c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands break; 6852c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands } 6862c11046fa186a4489bfd562cd81ff8a4883cb223Duncan Sands#endif 687722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} 688722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 6894e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer// Default implementation for CallbackVH. 6904e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramervoid CallbackVH::allUsesReplacedWith(Value *) {} 6914e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer 6924e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramervoid CallbackVH::deleted() { 6934e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer setValPtr(NULL); 6944e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer} 695