13#ifndef LLVM_IR_VALUEHANDLE_H
14#define LLVM_IR_VALUEHANDLE_H
45 AddToExistingUseList(
RHS.getPrevPtr());
53 void setValPtr(
Value *V) { Val = V; }
57 : PrevPair(nullptr, Kind) {}
59 : PrevPair(nullptr, Kind), Val(V) {
82 return RHS.getValPtr();
85 setValPtr(
RHS.getValPtr());
87 AddToExistingUseList(
RHS.getPrevPtr());
94 assert(V &&
"Dereferencing deleted ValueHandle");
131 void AddToExistingUseList(ValueHandleBase **
List);
134 void AddToExistingUseListAfter(ValueHandleBase *
Node);
259template <
typename ValueTy>
261#
if LLVM_ENABLE_ABI_BREAKING_CHECKS
267#if LLVM_ENABLE_ABI_BREAKING_CHECKS
272 Value *getRawValPtr()
const {
return ThePtr; }
273 void setRawValPtr(
Value *
P) { ThePtr =
P; }
276 static Value *GetAsValue(
Value *V) {
return V; }
277 static Value *GetAsValue(
const Value *V) {
return const_cast<Value*
>(V); }
279 ValueTy *getValPtr()
const {
return static_cast<ValueTy *
>(getRawValPtr()); }
280 void setValPtr(ValueTy *
P) { setRawValPtr(GetAsValue(
P)); }
283#if LLVM_ENABLE_ABI_BREAKING_CHECKS
293 operator ValueTy*()
const {
302 setValPtr(
RHS.getValPtr());
337 "TrackingVH must be non-null and valid on dereference!");
343 assert(isa<ValueTy>(InnerHandle) &&
344 "Tracked Value was replaced by one with an invalid type!");
345 return cast<ValueTy>(InnerHandle);
363 operator ValueTy*()
const {
384 virtual void anchor();
444template <
typename ValueTy>
446#
if LLVM_ENABLE_ABI_BREAKING_CHECKS
453 static Value *GetAsValue(
Value *V) {
return V; }
454 static Value *GetAsValue(
const Value *V) {
return const_cast<Value *
>(V); }
456#if LLVM_ENABLE_ABI_BREAKING_CHECKS
463 bool Poisoned =
false;
469 void deleted()
override {
470 assert(!Poisoned &&
"Tried to delete an already poisoned handle!");
476 void allUsesReplacedWith(
Value *)
override {
477 assert(!Poisoned &&
"Tried to RAUW an already poisoned handle!");
482 Value *ThePtr =
nullptr;
484 Value *getRawValPtr()
const {
return ThePtr; }
485 void setRawValPtr(
Value *
P) { ThePtr =
P; }
488 ValueTy *getValPtr()
const {
489#if LLVM_ENABLE_ABI_BREAKING_CHECKS
490 assert(!Poisoned &&
"Accessed a poisoned value handle!");
492 return static_cast<ValueTy *
>(getRawValPtr());
494 void setValPtr(ValueTy *
P) { setRawValPtr(GetAsValue(
P)); }
498#if LLVM_ENABLE_ABI_BREAKING_CHECKS
512 Poisoned =
RHS.Poisoned;
519 operator ValueTy *()
const {
return getValPtr(); }
static Error getInt(StringRef R, IntTy &Result)
Get an unsigned integer, including error checks.
This file defines DenseMapInfo traits for DenseMap.
This file defines the PointerIntPair class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value handle that asserts if the Value is deleted.
ValueTy * operator=(ValueTy *RHS)
ValueTy & operator*() const
ValueTy * operator=(const AssertingVH< ValueTy > &RHS)
ValueTy * operator->() const
AssertingVH(const AssertingVH &)=default
Value handle with callbacks on RAUW and destruction.
virtual void allUsesReplacedWith(Value *)
Callback for Value RAUW.
CallbackVH(const Value *P)
CallbackVH & operator=(const CallbackVH &)=default
CallbackVH(const CallbackVH &)=default
virtual void deleted()
Callback for Value destruction.
PointerIntPair - This class implements a pair of a pointer and small integer.
void setPointer(PointerTy PtrVal) &
PointerTy getPointer() const
Value handle that poisons itself if the Value is deleted.
ValueTy & operator*() const
ValueTy * operator->() const
Value handle that tracks a Value across RAUW.
ValueTy * operator->() const
ValueTy * getValPtr() const
static Value * GetAsValue(const Value *V)
static Value * GetAsValue(Value *V)
ValueTy & operator*() const
void setValPtr(ValueTy *P)
ValueTy * operator=(ValueTy *RHS)
This is the common base class of value handles.
Value & operator*() const
ValueHandleBase(HandleBaseKind Kind, Value *V)
static bool isValid(Value *V)
void RemoveFromUseList()
Remove this ValueHandle from its current use list.
Value * operator->() const
Value * operator=(Value *RHS)
Value * operator=(const ValueHandleBase &RHS)
Value * getValPtr() const
static void ValueIsDeleted(Value *V)
void clearValPtr()
Clear the underlying pointer without clearing the use list.
ValueHandleBase(HandleBaseKind Kind)
static void ValueIsRAUWd(Value *Old, Value *New)
HandleBaseKind
This indicates what sub class the handle actually is.
ValueHandleBase(HandleBaseKind Kind, const ValueHandleBase &RHS)
ValueHandleBase(const ValueHandleBase &RHS)
LLVM Value Representation.
Value handle that is nullable, but tries to track the Value.
WeakTrackingVH(const WeakTrackingVH &RHS)
Value * operator=(const ValueHandleBase &RHS)
Value * operator=(Value *RHS)
WeakTrackingVH & operator=(const WeakTrackingVH &RHS)=default
bool pointsToAliveValue() const
A nullable Value handle that is nullable.
WeakVH(const WeakVH &RHS)
WeakVH & operator=(const WeakVH &RHS)=default
Value * operator=(const ValueHandleBase &RHS)
Value * operator=(Value *RHS)
This is an optimization pass for GlobalISel generic memory operations.
static bool isEqual(const T *LHS, const PoisoningVH< T > &RHS)
static PoisoningVH< T > getTombstoneKey()
static unsigned getHashValue(const T *Val)
static unsigned getHashValue(const PoisoningVH< T > &Val)
static bool isEqual(const PoisoningVH< T > &LHS, const PoisoningVH< T > &RHS)
static PoisoningVH< T > getEmptyKey()
static bool isEqual(const WeakVH &LHS, const WeakVH &RHS)
static unsigned getHashValue(const WeakVH &Val)
static WeakVH getEmptyKey()
static WeakVH getTombstoneKey()
An information struct used to provide DenseMap with the various necessary components for a given valu...
static SimpleType getSimplifiedValue(WeakTrackingVH &WVH)
static SimpleType getSimplifiedValue(WeakVH &WVH)
static SimpleType getSimplifiedValue(const WeakVH &WVH)
Define a template that can be specialized by smart pointers to reflect the fact that they are automat...
static SimpleType & getSimplifiedValue(From &Val)