ValueHandle.h revision f3ef5332fa3f4d5ec72c178a2b19dac363a19383
1//===- ValueHandle.h - Value Smart Pointer classes --------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file declares the ValueHandle class and its sub-classes. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_IR_VALUEHANDLE_H 15#define LLVM_IR_VALUEHANDLE_H 16 17#include "llvm/ADT/DenseMapInfo.h" 18#include "llvm/ADT/PointerIntPair.h" 19#include "llvm/IR/Value.h" 20 21namespace llvm { 22class ValueHandleBase; 23template<typename From> struct simplify_type; 24 25// ValueHandleBase** is only 4-byte aligned. 26template<> 27class PointerLikeTypeTraits<ValueHandleBase**> { 28public: 29 static inline void *getAsVoidPointer(ValueHandleBase** P) { return P; } 30 static inline ValueHandleBase **getFromVoidPointer(void *P) { 31 return static_cast<ValueHandleBase**>(P); 32 } 33 enum { NumLowBitsAvailable = 2 }; 34}; 35 36/// \brief This is the common base class of value handles. 37/// 38/// ValueHandle's are smart pointers to Value's that have special behavior when 39/// the value is deleted or ReplaceAllUsesWith'd. See the specific handles 40/// below for details. 41class ValueHandleBase { 42 friend class Value; 43protected: 44 /// \brief This indicates what sub class the handle actually is. 45 /// 46 /// This is to avoid having a vtable for the light-weight handle pointers. The 47 /// fully general Callback version does have a vtable. 48 enum HandleBaseKind { 49 Assert, 50 Callback, 51 Tracking, 52 Weak 53 }; 54 55 ValueHandleBase(const ValueHandleBase &RHS) 56 : ValueHandleBase(RHS.PrevPair.getInt(), RHS) {} 57 58 ValueHandleBase(HandleBaseKind Kind, const ValueHandleBase &RHS) 59 : PrevPair(nullptr, Kind), Next(nullptr), V(RHS.V) { 60 if (isValid(V)) 61 AddToExistingUseList(RHS.getPrevPtr()); 62 } 63 64private: 65 PointerIntPair<ValueHandleBase**, 2, HandleBaseKind> PrevPair; 66 ValueHandleBase *Next; 67 68 Value* V; 69 70public: 71 explicit ValueHandleBase(HandleBaseKind Kind) 72 : PrevPair(nullptr, Kind), Next(nullptr), V(nullptr) {} 73 ValueHandleBase(HandleBaseKind Kind, Value *V) 74 : PrevPair(nullptr, Kind), Next(nullptr), V(V) { 75 if (isValid(V)) 76 AddToUseList(); 77 } 78 79 ~ValueHandleBase() { 80 if (isValid(V)) 81 RemoveFromUseList(); 82 } 83 84 Value *operator=(Value *RHS) { 85 if (V == RHS) return RHS; 86 if (isValid(V)) RemoveFromUseList(); 87 V = RHS; 88 if (isValid(V)) AddToUseList(); 89 return RHS; 90 } 91 92 Value *operator=(const ValueHandleBase &RHS) { 93 if (V == RHS.V) return RHS.V; 94 if (isValid(V)) RemoveFromUseList(); 95 V = RHS.V; 96 if (isValid(V)) AddToExistingUseList(RHS.getPrevPtr()); 97 return V; 98 } 99 100 Value *operator->() const { return V; } 101 Value &operator*() const { return *V; } 102 103protected: 104 Value *getValPtr() const { return V; } 105 106 static bool isValid(Value *V) { 107 return V && 108 V != DenseMapInfo<Value *>::getEmptyKey() && 109 V != DenseMapInfo<Value *>::getTombstoneKey(); 110 } 111 112public: 113 // Callbacks made from Value. 114 static void ValueIsDeleted(Value *V); 115 static void ValueIsRAUWd(Value *Old, Value *New); 116 117private: 118 // Internal implementation details. 119 ValueHandleBase **getPrevPtr() const { return PrevPair.getPointer(); } 120 HandleBaseKind getKind() const { return PrevPair.getInt(); } 121 void setPrevPtr(ValueHandleBase **Ptr) { PrevPair.setPointer(Ptr); } 122 123 /// \brief Add this ValueHandle to the use list for V. 124 /// 125 /// List is the address of either the head of the list or a Next node within 126 /// the existing use list. 127 void AddToExistingUseList(ValueHandleBase **List); 128 129 /// \brief Add this ValueHandle to the use list after Node. 130 void AddToExistingUseListAfter(ValueHandleBase *Node); 131 132 /// \brief Add this ValueHandle to the use list for V. 133 void AddToUseList(); 134 /// \brief Remove this ValueHandle from its current use list. 135 void RemoveFromUseList(); 136}; 137 138/// \brief Value handle that is nullable, but tries to track the Value. 139/// 140/// This is a value handle that tries hard to point to a Value, even across 141/// RAUW operations, but will null itself out if the value is destroyed. this 142/// is useful for advisory sorts of information, but should not be used as the 143/// key of a map (since the map would have to rearrange itself when the pointer 144/// changes). 145class WeakVH : public ValueHandleBase { 146public: 147 WeakVH() : ValueHandleBase(Weak) {} 148 WeakVH(Value *P) : ValueHandleBase(Weak, P) {} 149 WeakVH(const WeakVH &RHS) 150 : ValueHandleBase(Weak, RHS) {} 151 152 WeakVH &operator=(const WeakVH &RHS) = default; 153 154 Value *operator=(Value *RHS) { 155 return ValueHandleBase::operator=(RHS); 156 } 157 Value *operator=(const ValueHandleBase &RHS) { 158 return ValueHandleBase::operator=(RHS); 159 } 160 161 operator Value*() const { 162 return getValPtr(); 163 } 164}; 165 166// Specialize simplify_type to allow WeakVH to participate in 167// dyn_cast, isa, etc. 168template <> struct simplify_type<WeakVH> { 169 typedef Value *SimpleType; 170 static SimpleType getSimplifiedValue(WeakVH &WVH) { return WVH; } 171}; 172template <> struct simplify_type<const WeakVH> { 173 typedef Value *SimpleType; 174 static SimpleType getSimplifiedValue(const WeakVH &WVH) { return WVH; } 175}; 176 177/// \brief Value handle that asserts if the Value is deleted. 178/// 179/// This is a Value Handle that points to a value and asserts out if the value 180/// is destroyed while the handle is still live. This is very useful for 181/// catching dangling pointer bugs and other things which can be non-obvious. 182/// One particularly useful place to use this is as the Key of a map. Dangling 183/// pointer bugs often lead to really subtle bugs that only occur if another 184/// object happens to get allocated to the same address as the old one. Using 185/// an AssertingVH ensures that an assert is triggered as soon as the bad 186/// delete occurs. 187/// 188/// Note that an AssertingVH handle does *not* follow values across RAUW 189/// operations. This means that RAUW's need to explicitly update the 190/// AssertingVH's as it moves. This is required because in non-assert mode this 191/// class turns into a trivial wrapper around a pointer. 192template <typename ValueTy> 193class AssertingVH 194#ifndef NDEBUG 195 : public ValueHandleBase 196#endif 197 { 198 friend struct DenseMapInfo<AssertingVH<ValueTy> >; 199 200#ifndef NDEBUG 201 Value *getRawValPtr() const { return ValueHandleBase::getValPtr(); } 202 void setRawValPtr(Value *P) { ValueHandleBase::operator=(P); } 203#else 204 Value *ThePtr; 205 Value *getRawValPtr() const { return ThePtr; } 206 void setRawValPtr(Value *P) { ThePtr = P; } 207#endif 208 // Convert a ValueTy*, which may be const, to the raw Value*. 209 static Value *GetAsValue(Value *V) { return V; } 210 static Value *GetAsValue(const Value *V) { return const_cast<Value*>(V); } 211 212 ValueTy *getValPtr() const { return static_cast<ValueTy *>(getRawValPtr()); } 213 void setValPtr(ValueTy *P) { setRawValPtr(GetAsValue(P)); } 214 215public: 216#ifndef NDEBUG 217 AssertingVH() : ValueHandleBase(Assert) {} 218 AssertingVH(ValueTy *P) : ValueHandleBase(Assert, GetAsValue(P)) {} 219 AssertingVH(const AssertingVH &RHS) : ValueHandleBase(Assert, RHS) {} 220#else 221 AssertingVH() : ThePtr(nullptr) {} 222 AssertingVH(ValueTy *P) : ThePtr(GetAsValue(P)) {} 223#endif 224 225 operator ValueTy*() const { 226 return getValPtr(); 227 } 228 229 ValueTy *operator=(ValueTy *RHS) { 230 setValPtr(RHS); 231 return getValPtr(); 232 } 233 ValueTy *operator=(const AssertingVH<ValueTy> &RHS) { 234 setValPtr(RHS.getValPtr()); 235 return getValPtr(); 236 } 237 238 ValueTy *operator->() const { return getValPtr(); } 239 ValueTy &operator*() const { return *getValPtr(); } 240}; 241 242// Specialize DenseMapInfo to allow AssertingVH to participate in DenseMap. 243template<typename T> 244struct DenseMapInfo<AssertingVH<T> > { 245 static inline AssertingVH<T> getEmptyKey() { 246 AssertingVH<T> Res; 247 Res.setRawValPtr(DenseMapInfo<Value *>::getEmptyKey()); 248 return Res; 249 } 250 static inline AssertingVH<T> getTombstoneKey() { 251 AssertingVH<T> Res; 252 Res.setRawValPtr(DenseMapInfo<Value *>::getTombstoneKey()); 253 return Res; 254 } 255 static unsigned getHashValue(const AssertingVH<T> &Val) { 256 return DenseMapInfo<Value *>::getHashValue(Val.getRawValPtr()); 257 } 258 static bool isEqual(const AssertingVH<T> &LHS, const AssertingVH<T> &RHS) { 259 return DenseMapInfo<Value *>::isEqual(LHS.getRawValPtr(), 260 RHS.getRawValPtr()); 261 } 262}; 263 264template <typename T> 265struct isPodLike<AssertingVH<T> > { 266#ifdef NDEBUG 267 static const bool value = true; 268#else 269 static const bool value = false; 270#endif 271}; 272 273 274/// \brief Value handle that tracks a Value across RAUW. 275/// 276/// TrackingVH is designed for situations where a client needs to hold a handle 277/// to a Value (or subclass) across some operations which may move that value, 278/// but should never destroy it or replace it with some unacceptable type. 279/// 280/// It is an error to do anything with a TrackingVH whose value has been 281/// destroyed, except to destruct it. 282/// 283/// It is an error to attempt to replace a value with one of a type which is 284/// incompatible with any of its outstanding TrackingVHs. 285template<typename ValueTy> 286class TrackingVH : public ValueHandleBase { 287 void CheckValidity() const { 288 Value *VP = ValueHandleBase::getValPtr(); 289 290 // Null is always ok. 291 if (!VP) return; 292 293 // Check that this value is valid (i.e., it hasn't been deleted). We 294 // explicitly delay this check until access to avoid requiring clients to be 295 // unnecessarily careful w.r.t. destruction. 296 assert(ValueHandleBase::isValid(VP) && "Tracked Value was deleted!"); 297 298 // Check that the value is a member of the correct subclass. We would like 299 // to check this property on assignment for better debugging, but we don't 300 // want to require a virtual interface on this VH. Instead we allow RAUW to 301 // replace this value with a value of an invalid type, and check it here. 302 assert(isa<ValueTy>(VP) && 303 "Tracked Value was replaced by one with an invalid type!"); 304 } 305 306 ValueTy *getValPtr() const { 307 CheckValidity(); 308 return (ValueTy*)ValueHandleBase::getValPtr(); 309 } 310 void setValPtr(ValueTy *P) { 311 CheckValidity(); 312 ValueHandleBase::operator=(GetAsValue(P)); 313 } 314 315 // Convert a ValueTy*, which may be const, to the type the base 316 // class expects. 317 static Value *GetAsValue(Value *V) { return V; } 318 static Value *GetAsValue(const Value *V) { return const_cast<Value*>(V); } 319 320public: 321 TrackingVH() : ValueHandleBase(Tracking) {} 322 TrackingVH(ValueTy *P) : ValueHandleBase(Tracking, GetAsValue(P)) {} 323 324 operator ValueTy*() const { 325 return getValPtr(); 326 } 327 328 ValueTy *operator=(ValueTy *RHS) { 329 setValPtr(RHS); 330 return getValPtr(); 331 } 332 333 ValueTy *operator->() const { return getValPtr(); } 334 ValueTy &operator*() const { return *getValPtr(); } 335}; 336 337/// \brief Value handle with callbacks on RAUW and destruction. 338/// 339/// This is a value handle that allows subclasses to define callbacks that run 340/// when the underlying Value has RAUW called on it or is destroyed. This 341/// class can be used as the key of a map, as long as the user takes it out of 342/// the map before calling setValPtr() (since the map has to rearrange itself 343/// when the pointer changes). Unlike ValueHandleBase, this class has a vtable. 344class CallbackVH : public ValueHandleBase { 345 virtual void anchor(); 346protected: 347 ~CallbackVH() = default; 348 CallbackVH(const CallbackVH &) = default; 349 CallbackVH &operator=(const CallbackVH &) = default; 350 351 void setValPtr(Value *P) { 352 ValueHandleBase::operator=(P); 353 } 354 355public: 356 CallbackVH() : ValueHandleBase(Callback) {} 357 CallbackVH(Value *P) : ValueHandleBase(Callback, P) {} 358 359 operator Value*() const { 360 return getValPtr(); 361 } 362 363 /// \brief Callback for Value destruction. 364 /// 365 /// Called when this->getValPtr() is destroyed, inside ~Value(), so you 366 /// may call any non-virtual Value method on getValPtr(), but no subclass 367 /// methods. If WeakVH were implemented as a CallbackVH, it would use this 368 /// method to call setValPtr(NULL). AssertingVH would use this method to 369 /// cause an assertion failure. 370 /// 371 /// All implementations must remove the reference from this object to the 372 /// Value that's being destroyed. 373 virtual void deleted() { setValPtr(nullptr); } 374 375 /// \brief Callback for Value RAUW. 376 /// 377 /// Called when this->getValPtr()->replaceAllUsesWith(new_value) is called, 378 /// _before_ any of the uses have actually been replaced. If WeakVH were 379 /// implemented as a CallbackVH, it would use this method to call 380 /// setValPtr(new_value). AssertingVH would do nothing in this method. 381 virtual void allUsesReplacedWith(Value *) {} 382}; 383 384} // End llvm namespace 385 386#endif 387