41 cl::desc(
"Deref attributes and metadata infer facts at definition only"));
47 assert(Ty &&
"Value defined with a null type: Error!");
49 "Cannot have values with typed pointer types");
54 : VTy(
checkType(ty)), UseList(nullptr), SubclassID(scid), HasValueHandle(0),
55 SubclassOptionalData(0), SubclassData(0), NumUserOperands(0),
57 static_assert(ConstantFirstVal == 0,
"!(SubclassID < ConstantFirstVal)");
62 if (SubclassID >= InstructionVal)
63 OpCode = SubclassID - InstructionVal;
64 if (OpCode == Instruction::Call || OpCode == Instruction::Invoke ||
65 OpCode == Instruction::CallBr)
67 "invalid CallBase type!");
68 else if (SubclassID != BasicBlockVal &&
69 ( SubclassID > ConstantLastVal))
71 "Cannot create non-first-class values except for constants!");
72 static_assert(
sizeof(
Value) == 2 *
sizeof(
void *) + 2 *
sizeof(
unsigned),
98 dbgs() <<
"While deleting: " << *VTy <<
" %" <<
getName() <<
"\n";
99 for (
auto *U :
users())
100 dbgs() <<
"Use still stuck around after Def is destroyed:" << *U <<
"\n";
112#define HANDLE_VALUE(Name) \
113 case Value::Name##Val: \
114 delete static_cast<Name *>(this); \
116#define HANDLE_MEMORY_VALUE(Name) \
117 case Value::Name##Val: \
118 static_cast<DerivedUser *>(this)->DeleteValue( \
119 static_cast<DerivedUser *>(this)); \
121#define HANDLE_CONSTANT(Name) \
122 case Value::Name##Val: \
123 llvm_unreachable("constants should be destroyed with destroyConstant"); \
125#define HANDLE_INSTRUCTION(Name)
126#include "llvm/IR/Value.def"
128#define HANDLE_INST(N, OPC, CLASS) \
129 case Value::InstructionVal + Instruction::OPC: \
130 delete static_cast<CLASS *>(this); \
132#define HANDLE_USER_INST(N, OPC, CLASS)
133#include "llvm/IR/Instruction.def"
140void Value::destroyValueName() {
144 Name->Destroy(Allocator);
168 Use *Result =
nullptr;
170 if (!U.getUser()->isDroppable()) {
180 User *Result =
nullptr;
181 for (
auto *U :
users()) {
182 if (!U->isDroppable()) {
183 if (Result && Result != U)
203 if (U.getUser()->isDroppable() && ShouldDrop(&U))
205 for (
Use *U : ToBeEdited)
212 if (UsrOp.get() ==
this)
219 if (
auto *Assume = dyn_cast<AssumeInst>(U.getUser())) {
220 unsigned OpNo = U.getOperandNo();
226 BOI.
Tag = Assume->getContext().pImpl->getOrInsertBundleTag(
"ignore");
243 for (; BI != BE && UI != UE; ++BI, ++UI) {
248 const auto *
User = dyn_cast<Instruction>(*UI);
249 if (
User &&
User->getParent() == BB)
264 ST = PP->getValueSymbolTable();
265 }
else if (
BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
267 ST =
P->getValueSymbolTable();
268 }
else if (
GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
269 if (
Module *
P = GV->getParent())
270 ST = &
P->getValueSymbolTable();
271 }
else if (
Argument *
A = dyn_cast<Argument>(V)) {
273 ST =
P->getValueSymbolTable();
275 assert(isa<Constant>(V) &&
"Unknown value type!");
287 "No name entry found!");
296 "HasName bit out of sync!");
318void Value::setNameImpl(
const Twine &NewName) {
324 if (!NeedNewName && !
hasName())
334 "Null bytes are not allowed in names");
340 assert(!
getType()->isVoidTy() &&
"Cannot assign a name to void values!");
352 if (!NameRef.
empty()) {
379 setNameImpl(NewName);
380 if (
Function *
F = dyn_cast<Function>(
this))
381 F->recalculateIntrinsicID();
385 assert(V !=
this &&
"Illegal call to this->takeName(this)!");
393 if (V->hasName()) V->setName(
"");
406 if (!V->hasName())
return;
420 assert(!Failure &&
"V has a name, so it should have a ST!"); (void)Failure;
427 V->setValueName(
nullptr);
436 VST->removeValueName(V->getValueName());
438 V->setValueName(
nullptr);
442 ST->reinsertValue(
this);
459 const GlobalValue *GV = dyn_cast<GlobalValue>(
this);
465 assert(M->isMaterialized());
472 if (!Cache.
insert(Expr).second)
478 auto *CE = dyn_cast<ConstantExpr>(O);
491 auto *
C = dyn_cast<Constant>(V);
495 auto *CE = dyn_cast<ConstantExpr>(Expr);
504void Value::doRAUW(
Value *New, ReplaceMetadataUses ReplaceMetaUses) {
505 assert(New &&
"Value::replaceAllUsesWith(<null>) is invalid!");
507 "this->replaceAllUsesWith(expr(this)) is NOT valid!");
509 "replaceAllUses of value with new value of different type!");
521 if (
auto *
C = dyn_cast<Constant>(
U.getUser())) {
522 if (!isa<GlobalValue>(
C)) {
523 C->handleOperandChange(
this, New);
531 if (
BasicBlock *BB = dyn_cast<BasicBlock>(
this))
532 BB->replaceSuccessorsPhiUsesWith(cast<BasicBlock>(New));
536 doRAUW(New, ReplaceMetadataUses::Yes);
540 doRAUW(New, ReplaceMetadataUses::No);
545 assert(New &&
"Value::replaceUsesWithIf(<null>) is invalid!");
547 "replaceUses of value with new value of different type!");
553 if (!ShouldReplace(U))
557 if (
auto *
C = dyn_cast<Constant>(U.getUser())) {
558 if (!isa<GlobalValue>(
C)) {
567 while (!Consts.
empty()) {
579 for (
auto *DVI : DbgUsers) {
580 if (DVI->getParent() != BB)
581 DVI->replaceVariableLocationOp(V, New);
588 assert(New &&
"Value::replaceUsesOutsideBlock(<null>, BB) is invalid!");
590 "this->replaceUsesOutsideBlock(expr(this), BB) is NOT valid!");
592 "replaceUses of value with new value of different type!");
593 assert(BB &&
"Basic block that may contain a use of 'New' must be defined\n");
597 auto *
I = dyn_cast<Instruction>(U.getUser());
599 return !
I ||
I->getParent() != BB;
605enum PointerStripKind {
607 PSK_ZeroIndicesAndAliases,
608 PSK_ZeroIndicesSameRepresentation,
609 PSK_ForAliasAnalysis,
610 PSK_InBoundsConstantIndices,
614template <Po
interStripKind StripKind>
static void NoopCallback(
const Value *) {}
616template <Po
interStripKind StripKind>
617static const Value *stripPointerCastsAndOffsets(
620 if (!
V->getType()->isPointerTy())
630 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
632 case PSK_ZeroIndices:
633 case PSK_ZeroIndicesAndAliases:
634 case PSK_ZeroIndicesSameRepresentation:
635 case PSK_ForAliasAnalysis:
636 if (!
GEP->hasAllZeroIndices())
639 case PSK_InBoundsConstantIndices:
640 if (!
GEP->hasAllConstantIndices())
644 if (!
GEP->isInBounds())
648 V =
GEP->getPointerOperand();
650 V = cast<Operator>(V)->getOperand(0);
651 if (!
V->getType()->isPointerTy())
653 }
else if (StripKind != PSK_ZeroIndicesSameRepresentation &&
657 V = cast<Operator>(V)->getOperand(0);
658 }
else if (StripKind == PSK_ZeroIndicesAndAliases && isa<GlobalAlias>(V)) {
659 V = cast<GlobalAlias>(V)->getAliasee();
660 }
else if (StripKind == PSK_ForAliasAnalysis && isa<PHINode>(V) &&
661 cast<PHINode>(V)->getNumIncomingValues() == 1) {
662 V = cast<PHINode>(V)->getIncomingValue(0);
664 if (
const auto *Call = dyn_cast<CallBase>(V)) {
665 if (
const Value *RV =
Call->getReturnedArgOperand()) {
672 if (StripKind == PSK_ForAliasAnalysis &&
673 (
Call->getIntrinsicID() == Intrinsic::launder_invariant_group ||
674 Call->getIntrinsicID() == Intrinsic::strip_invariant_group)) {
675 V =
Call->getArgOperand(0);
681 assert(
V->getType()->isPointerTy() &&
"Unexpected operand type!");
682 }
while (Visited.
insert(V).second);
689 return stripPointerCastsAndOffsets<PSK_ZeroIndices>(
this);
693 return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndAliases>(
this);
697 return stripPointerCastsAndOffsets<PSK_ZeroIndicesSameRepresentation>(
this);
701 return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(
this);
705 return stripPointerCastsAndOffsets<PSK_ForAliasAnalysis>(
this);
710 bool AllowInvariantGroup,
712 if (!
getType()->isPtrOrPtrVectorTy())
717 "The offset bit width does not match the DL specification.");
723 const Value *V =
this;
725 if (
auto *
GEP = dyn_cast<GEPOperator>(V)) {
727 if (!AllowNonInbounds && !
GEP->isInBounds())
736 APInt GEPOffset(
DL.getIndexTypeSizeInBits(V->getType()), 0);
737 if (!
GEP->accumulateConstantOffset(
DL, GEPOffset, ExternalAnalysis))
743 if (GEPOffset.getSignificantBits() >
BitWidth)
749 if (!ExternalAnalysis) {
752 bool Overflow =
false;
760 V =
GEP->getPointerOperand();
763 V = cast<Operator>(V)->getOperand(0);
764 }
else if (
auto *GA = dyn_cast<GlobalAlias>(V)) {
765 if (!GA->isInterposable())
766 V = GA->getAliasee();
767 }
else if (
const auto *Call = dyn_cast<CallBase>(V)) {
768 if (
const Value *RV =
Call->getReturnedArgOperand())
770 if (AllowInvariantGroup &&
Call->isLaunderOrStripInvariantGroup())
771 V =
Call->getArgOperand(0);
773 assert(
V->getType()->isPtrOrPtrVectorTy() &&
"Unexpected operand type!");
774 }
while (Visited.
insert(V).second);
781 return stripPointerCastsAndOffsets<PSK_InBounds>(
this, Func);
789 if (isa<Constant>(
this))
794 if (
auto *
A = dyn_cast<Argument>(
this)) {
795 if (
A->hasPointeeInMemoryValueAttr())
803 if (
F->doesNotFreeMemory() &&
F->hasNoSync())
808 if (
auto *
I = dyn_cast<Instruction>(
this))
809 F =
I->getFunction();
810 if (
auto *
A = dyn_cast<Argument>(
this))
825 const auto &GCName =
F->getGC();
826 if (GCName ==
"statepoint-example") {
827 auto *PT = cast<PointerType>(this->
getType());
828 if (PT->getAddressSpace() != 1)
838 for (
auto &Fn : *
F->getParent())
839 if (Fn.getIntrinsicID() == Intrinsic::experimental_gc_statepoint)
848 bool &CanBeFreed)
const {
854 if (
const Argument *
A = dyn_cast<Argument>(
this)) {
855 DerefBytes =
A->getDereferenceableBytes();
856 if (DerefBytes == 0) {
858 if (
Type *ArgMemTy =
A->getPointeeInMemoryValueType()) {
859 if (ArgMemTy->isSized()) {
861 DerefBytes =
DL.getTypeStoreSize(ArgMemTy).getKnownMinValue();
866 if (DerefBytes == 0) {
867 DerefBytes =
A->getDereferenceableOrNullBytes();
870 }
else if (
const auto *Call = dyn_cast<CallBase>(
this)) {
871 DerefBytes = Call->getRetDereferenceableBytes();
872 if (DerefBytes == 0) {
873 DerefBytes = Call->getRetDereferenceableOrNullBytes();
876 }
else if (
const LoadInst *LI = dyn_cast<LoadInst>(
this)) {
877 if (
MDNode *MD = LI->getMetadata(LLVMContext::MD_dereferenceable)) {
878 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
881 if (DerefBytes == 0) {
883 LI->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
884 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
889 }
else if (
auto *IP = dyn_cast<IntToPtrInst>(
this)) {
890 if (
MDNode *MD = IP->getMetadata(LLVMContext::MD_dereferenceable)) {
891 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
894 if (DerefBytes == 0) {
896 IP->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
897 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
902 }
else if (
auto *AI = dyn_cast<AllocaInst>(
this)) {
903 if (!AI->isArrayAllocation()) {
905 DL.getTypeStoreSize(AI->getAllocatedType()).getKnownMinValue();
909 }
else if (
auto *GV = dyn_cast<GlobalVariable>(
this)) {
910 if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
913 DerefBytes =
DL.getTypeStoreSize(GV->getValueType()).getFixedValue();
923 if (
auto *GO = dyn_cast<GlobalObject>(
this)) {
924 if (isa<Function>(GO)) {
925 Align FunctionPtrAlign =
DL.getFunctionPtrAlign().valueOrOne();
926 switch (
DL.getFunctionPtrAlignType()) {
928 return FunctionPtrAlign;
930 return std::max(FunctionPtrAlign, GO->getAlign().valueOrOne());
936 if (
auto *GVar = dyn_cast<GlobalVariable>(GO)) {
937 Type *ObjectType = GVar->getValueType();
942 if (GVar->isStrongDefinitionForLinker())
943 return DL.getPreferredAlign(GVar);
945 return DL.getABITypeAlign(ObjectType);
950 }
else if (
const Argument *
A = dyn_cast<Argument>(
this)) {
952 if (!Alignment &&
A->hasStructRetAttr()) {
954 Type *EltTy =
A->getParamStructRetType();
956 return DL.getABITypeAlign(EltTy);
959 }
else if (
const AllocaInst *AI = dyn_cast<AllocaInst>(
this)) {
960 return AI->getAlign();
961 }
else if (
const auto *Call = dyn_cast<CallBase>(
this)) {
963 if (!Alignment && Call->getCalledFunction())
964 Alignment = Call->getCalledFunction()->getAttributes().getRetAlignment();
966 }
else if (
const LoadInst *LI = dyn_cast<LoadInst>(
this)) {
967 if (
MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
968 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
971 }
else if (
auto *CstPtr = dyn_cast<Constant>(
this)) {
974 CstPtr = CstPtr->stripPointerCasts();
978 size_t TrailingZeros = CstInt->getValue().countr_zero();
989static std::optional<int64_t>
993 for (
unsigned i = 1; i !=
Idx; ++i, ++GTI)
998 for (
unsigned i =
Idx, e =
GEP->getNumOperands(); i != e; ++i, ++GTI) {
1001 return std::nullopt;
1014 if (
Size.isScalable())
1015 return std::nullopt;
1025 const Value *Ptr2 =
this;
1035 const GEPOperator *GEP1 = dyn_cast<GEPOperator>(Ptr1);
1036 const GEPOperator *GEP2 = dyn_cast<GEPOperator>(Ptr2);
1045 return std::nullopt;
1055 if (!IOffset1 || !IOffset2)
1056 return std::nullopt;
1057 return *IOffset2 - *IOffset1 + Offset2.
getSExtValue() -
1063 auto *PN = dyn_cast<PHINode>(
this);
1064 if (PN && PN->getParent() == CurBB)
1065 return PN->getIncomingValueForBlock(PredBB);
1072 if (!UseList || !UseList->Next)
1076 Use *Head = UseList;
1077 Use *Current = UseList->Next;
1078 Head->Next =
nullptr;
1080 Use *Next = Current->Next;
1081 Current->Next = Head;
1082 Head->Prev = &Current->Next;
1087 Head->Prev = &UseList;
1091 auto *Arg = dyn_cast<Argument>(
this);
1093 return Arg->hasSwiftErrorAttr();
1094 auto *Alloca = dyn_cast<AllocaInst>(
this);
1097 return Alloca->isSwiftError();
1112 Next->setPrevPtr(&Next);
1118 assert(
List &&
"Must insert after existing node");
1121 setPrevPtr(&
List->Next);
1124 Next->setPrevPtr(&Next);
1127void ValueHandleBase::AddToUseList() {
1136 assert(Entry &&
"Value doesn't have any handles?");
1137 AddToExistingUseList(&Entry);
1150 assert(!Entry &&
"Value really did already have handles?");
1151 AddToExistingUseList(&Entry);
1157 Handles.
size() == 1) {
1163 E = Handles.
end();
I !=
E; ++
I) {
1164 assert(
I->second &&
I->first ==
I->second->getValPtr() &&
1165 "List invariant broken!");
1166 I->second->setPrevPtr(&
I->second);
1172 "Pointer doesn't have a use list!");
1176 assert(*PrevPtr ==
this &&
"List invariant broken");
1180 assert(Next->getPrevPtr() == &Next &&
"List invariant broken");
1181 Next->setPrevPtr(PrevPtr);
1197 assert(V->HasValueHandle &&
"Should only be called if ValueHandles present");
1203 assert(Entry &&
"Value bit set but no entries exist");
1215 Iterator.RemoveFromUseList();
1216 Iterator.AddToExistingUseListAfter(Entry);
1217 assert(Entry->Next == &Iterator &&
"Loop invariant broken.");
1219 switch (Entry->getKind()) {
1226 Entry->operator=(
nullptr);
1236 if (V->HasValueHandle) {
1238 dbgs() <<
"While deleting: " << *V->getType() <<
" %" << V->getName()
1250 assert(Old->HasValueHandle &&
"Should only be called if ValueHandles present");
1251 assert(Old != New &&
"Changing value into itself!");
1253 "replaceAllUses of value with new value of different type!");
1260 assert(Entry &&
"Value bit set but no entries exist");
1267 Iterator.RemoveFromUseList();
1268 Iterator.AddToExistingUseListAfter(Entry);
1269 assert(Entry->Next == &Iterator &&
"Loop invariant broken.");
1271 switch (Entry->getKind()) {
1278 Entry->operator=(New);
1282 static_cast<CallbackVH*
>(Entry)->allUsesReplacedWith(New);
1290 if (Old->HasValueHandle)
1291 for (Entry = pImpl->
ValueHandles[Old]; Entry; Entry = Entry->Next)
1292 switch (Entry->getKind()) {
1294 dbgs() <<
"After RAUW from " << *Old->
getType() <<
" %"
1295 << Old->
getName() <<
" to " << *New->getType() <<
" %"
1296 << New->getName() <<
"\n";
1298 "A weak tracking value handle still pointed to the old value!\n");
1306void CallbackVH::anchor() {}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
static std::optional< int64_t > getOffsetFromIndex(const GEPOperator *GEP, unsigned Idx, const DataLayout &DL)
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
static Type * checkType(Type *Ty)
static bool getSymTab(Value *V, ValueSymbolTable *&ST)
static void replaceDbgUsesOutsideBlock(Value *V, Value *New, BasicBlock *BB)
Replace llvm.dbg.
static bool isUnDroppableUser(const User *U)
static cl::opt< unsigned > UseDerefAtPointSemantics("use-dereferenceable-at-point-semantics", cl::Hidden, cl::init(false), cl::desc("Deref attributes and metadata infer facts at definition only"))
Class for arbitrary precision integers.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
int64_t getSExtValue() const
Get sign extended value.
an instruction to allocate memory on the stack
This class represents an incoming formal argument to a Function.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
InstListType::const_iterator const_iterator
Value handle with callbacks on RAUW and destruction.
A constant value that is initialized with an expression using other constant values.
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
This is the shared class of boolean and integer constants.
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
static ConstantInt * getTrue(LLVMContext &Context)
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
This is an important base class in LLVM.
A parsed version of the target data layout string in and methods for querying it.
@ MultipleOfFunctionAlign
The function pointer alignment is a multiple of the function alignment.
@ Independent
The function pointer alignment is independent of the function alignment.
bool erase(const KeyT &Val)
bool isPointerIntoBucketsArray(const void *Ptr) const
isPointerIntoBucketsArray - Return true if the specified pointer points somewhere into the DenseMap's...
const void * getPointerIntoBucketsArray() const
getPointerIntoBucketsArray() - Return an opaque pointer into the buckets array.
Type * getSourceElementType() const
Module * getParent()
Get the module that this global value is contained inside of...
DenseMap< const Value *, ValueName * > ValueNames
ValueHandlesTy ValueHandles
This is an important class for using LLVM in a threaded context.
bool shouldDiscardValueNames() const
Return true if the Context runtime configuration is set to discard all value names.
LLVMContextImpl *const pImpl
An instruction for reading from memory.
A Module instance is used to store all the information related to an LLVM module.
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void setValue(const ValueTy &V)
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
static StringMapEntry * create(StringRef key, AllocatorTy &allocator, InitTy &&...initVals)
Create a StringMapEntry for the specified key construct the value using InitiVals.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
static constexpr size_t npos
Class to represent struct types.
Value handle that tracks a Value across RAUW.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
bool isTriviallyEmpty() const
Check if this twine is trivially empty; a false return value does not necessarily mean the twine is e...
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isStructTy() const
True if this is an instance of StructType.
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
bool isVoidTy() const
Return true if this is 'void'.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
A Use represents the edge between a Value definition and its users.
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
bool isDroppable() const
A droppable user is a user for which uses can be dropped without affecting correctness and should be ...
This is the common base class of value handles.
void RemoveFromUseList()
Remove this ValueHandle from its current use list.
Value * getValPtr() const
static void ValueIsDeleted(Value *V)
static void ValueIsRAUWd(Value *Old, Value *New)
This class provides a symbol table of name/value pairs.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
static constexpr uint64_t MaximumAlignment
user_iterator_impl< const User > const_user_iterator
user_iterator user_begin()
const Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) const
Translate PHI node to its predecessor from the given basic block.
Value(Type *Ty, unsigned scid)
const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr) const
Accumulate the constant offset this value has compared to a base pointer.
void reverseUseList()
Reverse the use-list.
void assertModuleIsMaterializedImpl() const
bool hasNUndroppableUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
bool hasOneUser() const
Return true if there is exactly one user of this value.
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
void setName(const Twine &Name)
Change the name of the value.
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
std::string getNameOrAsOperand() const
bool hasOneUse() const
Return true if there is exactly one use of this value.
~Value()
Value's destructor should be virtual by design, but that would require that Value and all of its subc...
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const
Strip off pointer casts and inbounds GEPs.
iterator_range< user_iterator > users()
static void dropDroppableUse(Use &U)
Remove the droppable use U.
Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
unsigned getValueID() const
Return an ID for the concrete type of this object.
bool isUsedInBasicBlock(const BasicBlock *BB) const
Check if this value is used in the specified basic block.
bool materialized_use_empty() const
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
bool isUsedByMetadata() const
Return true if there is metadata referencing this value.
bool hasNUsesOrMore(unsigned N) const
Return true if this value has N uses or more.
void dropDroppableUsesIn(User &Usr)
Remove every use of this value in User that can safely be removed.
Use * getSingleUndroppableUse()
Return true if there is exactly one use of this value that cannot be dropped.
bool canBeFreed() const
Return true if the memory object referred to by V can by freed in the scope for which the SSA value d...
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
void replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)
Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...
void setValueName(ValueName *VN)
User * getUniqueUndroppableUser()
Return true if there is exactly one unique user of this value that cannot be dropped (that user can h...
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
bool isSwiftError() const
Return true if this value is a swifterror value.
void deleteValue()
Delete a pointer to a generic Value.
ValueName * getValueName() const
const Value * stripPointerCastsSameRepresentation() const
Strip off pointer casts, all-zero GEPs and address space casts but ensures the representation of the ...
void dropDroppableUses(llvm::function_ref< bool(const Use *)> ShouldDrop=[](const Use *) { return true;})
Remove every uses that can safely be removed.
void replaceUsesOutsideBlock(Value *V, BasicBlock *BB)
replaceUsesOutsideBlock - Go through the uses list for this definition and make each use point to "V"...
LLVMContext & getContext() const
All values hold a context through their type.
static constexpr unsigned MaxAlignmentExponent
The maximum alignment for instructions.
unsigned getNumUses() const
This method computes the number of uses of this Value.
iterator_range< use_iterator > uses()
std::optional< int64_t > getPointerOffsetFrom(const Value *Other, const DataLayout &DL) const
If this ptr is provably equal to Other plus a constant offset, return that offset in bytes.
uint64_t getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull, bool &CanBeFreed) const
Returns the number of bytes known to be dereferenceable for the pointer value.
void clearMetadata()
Erase all metadata attached to this Value.
StringRef getName() const
Return a constant reference to the value's name.
void replaceNonMetadataUsesWith(Value *V)
Change non-metadata uses of this to point to a new Value.
void takeName(Value *V)
Transfer the name from V to this value.
bool hasNUndroppableUses(unsigned N) const
Return true if there this value.
const Value * stripPointerCastsForAliasAnalysis() const
Strip off pointer casts, all-zero GEPs, single-argument phi nodes and invariant group info.
An efficient, type-erasing, non-owning reference to a callable.
StructType * getStructTypeOrNull() const
Type * getIndexedType() const
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
NodeAddr< FuncNode * > Func
This is an optimization pass for GlobalISel generic memory operations.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
bool hasNItemsOrMore(IterTy &&Begin, IterTy &&End, unsigned N, Pred &&ShouldBeCounted=[](const decltype(*std::declval< IterTy >()) &) { return true;}, std::enable_if_t< !std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< std::remove_reference_t< decltype(Begin)> >::iterator_category >::value, void > *=nullptr)
Return true if the sequence [Begin, End) has N or more items.
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V)
Finds the debug info intrinsics describing a value.
bool hasNItems(IterTy &&Begin, IterTy &&End, unsigned N, Pred &&ShouldBeCounted=[](const decltype(*std::declval< IterTy >()) &) { return true;}, std::enable_if_t< !std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< std::remove_reference_t< decltype(Begin)> >::iterator_category >::value, void > *=nullptr)
Return true if the sequence [Begin, End) has exactly N items.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
constexpr unsigned BitWidth
gep_type_iterator gep_type_begin(const User *GEP)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Used to keep track of an operand bundle.
StringMapEntry< uint32_t > * Tag
The operand bundle tag, interned by LLVMContextImpl::getOrInsertBundleTag.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.