1722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===- llvm/Support/ValueHandle.h - Value Smart Pointer classes -*- C++ -*-===// 2722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// 3722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// The LLVM Compiler Infrastructure 4722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// 5722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// This file is distributed under the University of Illinois Open Source 6722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// License. See LICENSE.TXT for details. 7722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// 8722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===----------------------------------------------------------------------===// 9722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// 10722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// This file declares the ValueHandle class and its sub-classes. 11722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner// 12722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner//===----------------------------------------------------------------------===// 13722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 14722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#ifndef LLVM_SUPPORT_VALUEHANDLE_H 15722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#define LLVM_SUPPORT_VALUEHANDLE_H 16722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 1729384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman#include "llvm/ADT/DenseMapInfo.h" 18722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#include "llvm/ADT/PointerIntPair.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Value.h" 20722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 21722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnernamespace llvm { 22b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattnerclass ValueHandleBase; 237fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindolatemplate<typename From> struct simplify_type; 24b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner 25b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner// ValueHandleBase** is only 4-byte aligned. 26b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattnertemplate<> 27b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattnerclass PointerLikeTypeTraits<ValueHandleBase**> { 28b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattnerpublic: 29b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner static inline void *getAsVoidPointer(ValueHandleBase** P) { return P; } 30b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner static inline ValueHandleBase **getFromVoidPointer(void *P) { 31b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner return static_cast<ValueHandleBase**>(P); 32b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner } 33b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner enum { NumLowBitsAvailable = 2 }; 34b7a00daa1165576dd2bb9d17970c249d536f4a82Chris Lattner}; 35722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 36722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// ValueHandleBase - This is the common base class of value handles. 37722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// ValueHandle's are smart pointers to Value's that have special behavior when 38722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// the value is deleted or ReplaceAllUsesWith'd. See the specific handles 39722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// below for details. 40722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// 41722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerclass ValueHandleBase { 42722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner friend class Value; 43722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerprotected: 44487fa01673a1d13331b7173e9e6812e72dd4361eJeffrey Yasskin /// HandleBaseKind - This indicates what sub class the handle actually is. 45722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner /// This is to avoid having a vtable for the light-weight handle pointers. The 46c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// fully general Callback version does have a vtable. 47722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner enum HandleBaseKind { 48722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Assert, 49e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar Callback, 50e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar Tracking, 51e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar Weak 52722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner }; 53f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 545252c432dd93147fa70a536be58a15ef329de0b7Bill Wendlingprivate: 55722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner PointerIntPair<ValueHandleBase**, 2, HandleBaseKind> PrevPair; 56722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase *Next; 575252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling 585252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling // A subclass may want to store some information along with the value 595252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling // pointer. Allow them to do this by making the value pointer a pointer-int 605252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling // pair. The 'setValPtrInt' and 'getValPtrInt' methods below give them this 615252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling // access. 625252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling PointerIntPair<Value*, 2> VP; 63fc601db2ed899d800ea0a50f7ecf7de2a820cbc1Craig Topper 64fc601db2ed899d800ea0a50f7ecf7de2a820cbc1Craig Topper ValueHandleBase(const ValueHandleBase&) LLVM_DELETED_FUNCTION; 65722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerpublic: 66ff9977f8cdd5275448ca19736cd14a6e20c0dac4Dan Gohman explicit ValueHandleBase(HandleBaseKind Kind) 675252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling : PrevPair(0, Kind), Next(0), VP(0, 0) {} 68722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase(HandleBaseKind Kind, Value *V) 695252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling : PrevPair(0, Kind), Next(0), VP(V, 0) { 705252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) 71722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AddToUseList(); 72722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 73722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase(HandleBaseKind Kind, const ValueHandleBase &RHS) 74722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner : PrevPair(0, Kind), Next(0), VP(RHS.VP) { 755252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) 76722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AddToExistingUseList(RHS.getPrevPtr()); 77722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 78722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ~ValueHandleBase() { 795252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) 80f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar RemoveFromUseList(); 81722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 82f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 83722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Value *operator=(Value *RHS) { 845252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (VP.getPointer() == RHS) return RHS; 855252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) RemoveFromUseList(); 865252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling VP.setPointer(RHS); 875252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) AddToUseList(); 88722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return RHS; 89722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 90722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 91722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Value *operator=(const ValueHandleBase &RHS) { 925252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (VP.getPointer() == RHS.VP.getPointer()) return RHS.VP.getPointer(); 935252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) RemoveFromUseList(); 945252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling VP.setPointer(RHS.VP.getPointer()); 955252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling if (isValid(VP.getPointer())) AddToExistingUseList(RHS.getPrevPtr()); 965252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling return VP.getPointer(); 97722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 98f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 99722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Value *operator->() const { return getValPtr(); } 100722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner Value &operator*() const { return *getValPtr(); } 101487fa01673a1d13331b7173e9e6812e72dd4361eJeffrey Yasskin 102722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerprotected: 1035252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling Value *getValPtr() const { return VP.getPointer(); } 1045252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling 1055252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling void setValPtrInt(unsigned K) { VP.setInt(K); } 1065252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling unsigned getValPtrInt() const { return VP.getInt(); } 1075252c432dd93147fa70a536be58a15ef329de0b7Bill Wendling 10829384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman static bool isValid(Value *V) { 10929384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman return V && 11029384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman V != DenseMapInfo<Value *>::getEmptyKey() && 11129384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman V != DenseMapInfo<Value *>::getTombstoneKey(); 11229384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman } 11329384efb76a85e84f87c9bf898262d7f1069c38cDan Gohman 1147b6783a03f16376e8e2d0d9791f090ef32727c8fNadav Rotempublic: 115722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Callbacks made from Value. 116722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner static void ValueIsDeleted(Value *V); 117722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner static void ValueIsRAUWd(Value *Old, Value *New); 118f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 1197b6783a03f16376e8e2d0d9791f090ef32727c8fNadav Rotemprivate: 120722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner // Internal implementation details. 121722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueHandleBase **getPrevPtr() const { return PrevPair.getPointer(); } 122722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner HandleBaseKind getKind() const { return PrevPair.getInt(); } 123722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner void setPrevPtr(ValueHandleBase **Ptr) { PrevPair.setPointer(Ptr); } 124f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 1256a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin /// AddToExistingUseList - Add this ValueHandle to the use list for VP, where 1266a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin /// List is the address of either the head of the list or a Next node within 1276a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin /// the existing use list. 128722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner void AddToExistingUseList(ValueHandleBase **List); 129f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 1306a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin /// AddToExistingUseListAfter - Add this ValueHandle to the use list after 1316a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin /// Node. 1326a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin void AddToExistingUseListAfter(ValueHandleBase *Node); 1336a9291ad55cf3b3731d3512eb5aa72ac7cdf02f9Jeffrey Yasskin 134722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner /// AddToUseList - Add this ValueHandle to the use list for VP. 135722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner void AddToUseList(); 136722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner /// RemoveFromUseList - Remove this ValueHandle from its current use list. 137722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner void RemoveFromUseList(); 138722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner}; 139f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbar 140722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// WeakVH - This is a value handle that tries hard to point to a Value, even 141722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// across RAUW operations, but will null itself out if the value is destroyed. 142722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// this is useful for advisory sorts of information, but should not be used as 143722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// the key of a map (since the map would have to rearrange itself when the 144722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// pointer changes). 145722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerclass WeakVH : public ValueHandleBase { 146722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerpublic: 147722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner WeakVH() : ValueHandleBase(Weak) {} 148722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner WeakVH(Value *P) : ValueHandleBase(Weak, P) {} 149722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner WeakVH(const WeakVH &RHS) 150722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner : ValueHandleBase(Weak, RHS) {} 151722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 152f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner Value *operator=(Value *RHS) { 153f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner return ValueHandleBase::operator=(RHS); 154f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner } 155f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner Value *operator=(const ValueHandleBase &RHS) { 156f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner return ValueHandleBase::operator=(RHS); 157f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner } 158f6811274e18a73e7ba84a820a28cc2549a4fab44Chris Lattner 159b160f5d36d9d0ed0305e98096f4df430d07ee44fChris Lattner operator Value*() const { 160b160f5d36d9d0ed0305e98096f4df430d07ee44fChris Lattner return getValPtr(); 161b160f5d36d9d0ed0305e98096f4df430d07ee44fChris Lattner } 1620ec4146db70916c31281e091bb3b447aab497246Dan Gohman}; 1630ec4146db70916c31281e091bb3b447aab497246Dan Gohman 1640ec4146db70916c31281e091bb3b447aab497246Dan Gohman// Specialize simplify_type to allow WeakVH to participate in 1650ec4146db70916c31281e091bb3b447aab497246Dan Gohman// dyn_cast, isa, etc. 1667fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindolatemplate<> struct simplify_type<WeakVH> { 1670ec4146db70916c31281e091bb3b447aab497246Dan Gohman typedef Value* SimpleType; 1687fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola static SimpleType getSimplifiedValue(WeakVH &WVH) { 1697fe65d691dcce550d53ec9310913aab67ab6d654Rafael Espindola return WVH; 1700ec4146db70916c31281e091bb3b447aab497246Dan Gohman } 1710ec4146db70916c31281e091bb3b447aab497246Dan Gohman}; 1720ec4146db70916c31281e091bb3b447aab497246Dan Gohman 173722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// AssertingVH - This is a Value Handle that points to a value and asserts out 174722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// if the value is destroyed while the handle is still live. This is very 175722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// useful for catching dangling pointer bugs and other things which can be 176722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// non-obvious. One particularly useful place to use this is as the Key of a 177722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// map. Dangling pointer bugs often lead to really subtle bugs that only occur 178722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// if another object happens to get allocated to the same address as the old 179722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// one. Using an AssertingVH ensures that an assert is triggered as soon as 180722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// the bad delete occurs. 181722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// 182722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// Note that an AssertingVH handle does *not* follow values across RAUW 183722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// operations. This means that RAUW's need to explicitly update the 184722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner/// AssertingVH's as it moves. This is required because in non-assert mode this 1857c533169226213a6089a887b4f80f41004e10128Nick Lewycky/// class turns into a trivial wrapper around a pointer. 1866caced956460ec360c79dc7d20e872fba1b73583Chris Lattnertemplate <typename ValueTy> 187f612ff6cfbf3a59842732f0280807c0714ab9025Daniel Dunbarclass AssertingVH 188722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#ifndef NDEBUG 189722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner : public ValueHandleBase 190722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#endif 191722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner { 192722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 193722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#ifndef NDEBUG 194722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueTy *getValPtr() const { 195722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return static_cast<ValueTy*>(ValueHandleBase::getValPtr()); 196722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 197722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner void setValPtr(ValueTy *P) { 1980d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin ValueHandleBase::operator=(GetAsValue(P)); 199722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 200722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#else 201722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueTy *ThePtr; 202722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueTy *getValPtr() const { return ThePtr; } 203722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner void setValPtr(ValueTy *P) { ThePtr = P; } 204722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#endif 205722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 2060d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin // Convert a ValueTy*, which may be const, to the type the base 2070d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin // class expects. 2080d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin static Value *GetAsValue(Value *V) { return V; } 2090d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin static Value *GetAsValue(const Value *V) { return const_cast<Value*>(V); } 2100d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin 211722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattnerpublic: 212722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#ifndef NDEBUG 213722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AssertingVH() : ValueHandleBase(Assert) {} 2140d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin AssertingVH(ValueTy *P) : ValueHandleBase(Assert, GetAsValue(P)) {} 215722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AssertingVH(const AssertingVH &RHS) : ValueHandleBase(Assert, RHS) {} 216722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#else 217722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AssertingVH() : ThePtr(0) {} 218722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner AssertingVH(ValueTy *P) : ThePtr(P) {} 219722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#endif 220722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 221722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner operator ValueTy*() const { 222722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return getValPtr(); 223722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 224722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 225722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueTy *operator=(ValueTy *RHS) { 226722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner setValPtr(RHS); 227722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return getValPtr(); 228722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 2297e32c4fa72f8663abce1121965c3065f5dfa6747Daniel Dunbar ValueTy *operator=(const AssertingVH<ValueTy> &RHS) { 230722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner setValPtr(RHS.getValPtr()); 231722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner return getValPtr(); 232722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner } 233722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 234722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner ValueTy *operator->() const { return getValPtr(); } 2356caced956460ec360c79dc7d20e872fba1b73583Chris Lattner ValueTy &operator*() const { return *getValPtr(); } 236722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner}; 237722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 238ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin// Specialize DenseMapInfo to allow AssertingVH to participate in DenseMap. 239ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskintemplate<typename T> 240ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskinstruct DenseMapInfo<AssertingVH<T> > { 241ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin typedef DenseMapInfo<T*> PointerInfo; 242ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin static inline AssertingVH<T> getEmptyKey() { 243ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin return AssertingVH<T>(PointerInfo::getEmptyKey()); 244ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin } 245ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin static inline T* getTombstoneKey() { 246ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin return AssertingVH<T>(PointerInfo::getTombstoneKey()); 247ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin } 248ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin static unsigned getHashValue(const AssertingVH<T> &Val) { 249ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin return PointerInfo::getHashValue(Val); 250ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin } 251ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin static bool isEqual(const AssertingVH<T> &LHS, const AssertingVH<T> &RHS) { 252ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin return LHS == RHS; 253ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin } 2544bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattner}; 2554bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattner 2564bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattnertemplate <typename T> 2574bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattnerstruct isPodLike<AssertingVH<T> > { 258ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin#ifdef NDEBUG 2594bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattner static const bool value = true; 260ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin#else 2614bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattner static const bool value = false; 262ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin#endif 263ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin}; 264ebbcef945d33af5252486c1655ec6afdba4f97a7Jeffrey Yasskin 2654bbf4ee1491637c247e195e19e3e4a8ee5ad72faChris Lattner 266e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// TrackingVH - This is a value handle that tracks a Value (or Value subclass), 267e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// even across RAUW operations. 268e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// 269e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// TrackingVH is designed for situations where a client needs to hold a handle 270e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// to a Value (or subclass) across some operations which may move that value, 271e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// but should never destroy it or replace it with some unacceptable type. 272e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// 273e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// It is an error to do anything with a TrackingVH whose value has been 274e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// destroyed, except to destruct it. 275e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// 276e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// It is an error to attempt to replace a value with one of a type which is 277e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar/// incompatible with any of its outstanding TrackingVHs. 278e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbartemplate<typename ValueTy> 279e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbarclass TrackingVH : public ValueHandleBase { 280e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar void CheckValidity() const { 281e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar Value *VP = ValueHandleBase::getValPtr(); 282e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 283e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Null is always ok. 284870cfcf9a6189b65a8ee805b93a2c737c0183e62Chris Lattner if (!VP) return; 285e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 286e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Check that this value is valid (i.e., it hasn't been deleted). We 287e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // explicitly delay this check until access to avoid requiring clients to be 288e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // unnecessarily careful w.r.t. destruction. 289e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar assert(ValueHandleBase::isValid(VP) && "Tracked Value was deleted!"); 290e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 291e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Check that the value is a member of the correct subclass. We would like 292e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // to check this property on assignment for better debugging, but we don't 293e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // want to require a virtual interface on this VH. Instead we allow RAUW to 294e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // replace this value with a value of an invalid type, and check it here. 295e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar assert(isa<ValueTy>(VP) && 296e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar "Tracked Value was replaced by one with an invalid type!"); 297e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar } 298e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 299e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar ValueTy *getValPtr() const { 300e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar CheckValidity(); 301ec39f095f5abaf1ec90d7c6c46454032cda36e1cChris Lattner return (ValueTy*)ValueHandleBase::getValPtr(); 302e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar } 303e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar void setValPtr(ValueTy *P) { 304e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar CheckValidity(); 305e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar ValueHandleBase::operator=(GetAsValue(P)); 306e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar } 307e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 308e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // Convert a ValueTy*, which may be const, to the type the base 309e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar // class expects. 310e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar static Value *GetAsValue(Value *V) { return V; } 311e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar static Value *GetAsValue(const Value *V) { return const_cast<Value*>(V); } 312e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 313e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbarpublic: 314e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar TrackingVH() : ValueHandleBase(Tracking) {} 315070c07f2c881c9f005c411fb113011a2d5af4057Dan Gohman TrackingVH(ValueTy *P) : ValueHandleBase(Tracking, GetAsValue(P)) {} 316e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar TrackingVH(const TrackingVH &RHS) : ValueHandleBase(Tracking, RHS) {} 317e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 318e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar operator ValueTy*() const { 319e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar return getValPtr(); 320e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar } 321e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 322e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar ValueTy *operator=(ValueTy *RHS) { 323e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar setValPtr(RHS); 324e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar return getValPtr(); 325e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar } 326e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar ValueTy *operator=(const TrackingVH<ValueTy> &RHS) { 327e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar setValPtr(RHS.getValPtr()); 328e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar return getValPtr(); 329e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar } 330e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 331e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar ValueTy *operator->() const { return getValPtr(); } 332e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar ValueTy &operator*() const { return *getValPtr(); } 333e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar}; 334e5b18362dbafc8ee44ae864664fffe47066f685aDaniel Dunbar 335c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman/// CallbackVH - This is a value handle that allows subclasses to define 336c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman/// callbacks that run when the underlying Value has RAUW called on it or is 337c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman/// destroyed. This class can be used as the key of a map, as long as the user 338c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman/// takes it out of the map before calling setValPtr() (since the map has to 339c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman/// rearrange itself when the pointer changes). Unlike ValueHandleBase, this 340c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman/// class has a vtable and a virtual destructor. 341c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohmanclass CallbackVH : public ValueHandleBase { 342c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohmanprotected: 343c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman CallbackVH(const CallbackVH &RHS) 344c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman : ValueHandleBase(Callback, RHS) {} 345c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 3464e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer virtual ~CallbackVH() {} 347c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 348c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman void setValPtr(Value *P) { 349c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman ValueHandleBase::operator=(P); 350c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman } 351c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 352c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohmanpublic: 353c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman CallbackVH() : ValueHandleBase(Callback) {} 354c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman CallbackVH(Value *P) : ValueHandleBase(Callback, P) {} 355c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 356c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman operator Value*() const { 357c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman return getValPtr(); 358c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman } 359c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 360c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// Called when this->getValPtr() is destroyed, inside ~Value(), so you may 361c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// call any non-virtual Value method on getValPtr(), but no subclass methods. 362c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// If WeakVH were implemented as a CallbackVH, it would use this method to 363c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// call setValPtr(NULL). AssertingVH would use this method to cause an 364c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// assertion failure. 365c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// 366c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// All implementations must remove the reference from this object to the 367c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// Value that's being destroyed. 3684e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer virtual void deleted(); 369c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 370c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// Called when this->getValPtr()->replaceAllUsesWith(new_value) is called, 371c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// _before_ any of the uses have actually been replaced. If WeakVH were 372c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// implemented as a CallbackVH, it would use this method to call 373c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman /// setValPtr(new_value). AssertingVH would do nothing in this method. 3744e4c3408a5a1cc72b739a4b448329a281c379c55Benjamin Kramer virtual void allUsesReplacedWith(Value *); 375c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman}; 376c09b12c62208f09de9d107b320f5420ae6e4fc38Dan Gohman 377722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner} // End llvm namespace 378722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner 379722272df41d8de9c7683811b7bd8e901ee2f2785Chris Lattner#endif 380