15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H
68 "Bitfields must be contiguous");
122 return Align(1ULL << getSubclassData<AlignmentField>());
126 setSubclassData<AlignmentField>(
Log2(
Align));
137 return getSubclassData<UsedWithInAllocaField>();
142 setSubclassData<UsedWithInAllocaField>(V);
146 bool isSwiftError()
const {
return getSubclassData<SwiftErrorField>(); }
152 return (
I->getOpcode() == Instruction::Alloca);
155 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
161 template <
typename Bitfield>
162 void setSubclassData(
typename Bitfield::Type
Value) {
163 Instruction::setSubclassData<Bitfield>(
Value);
178 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
179 "Bitfields must be contiguous");
202 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
209 return Align(1ULL << (getSubclassData<AlignmentField>()));
213 setSubclassData<AlignmentField>(
Log2(
Align));
218 return getSubclassData<OrderingField>();
223 setSubclassData<OrderingField>(Ordering);
264 return I->getOpcode() == Instruction::Load;
267 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
273 template <
typename Bitfield>
274 void setSubclassData(
typename Bitfield::Type
Value) {
275 Instruction::setSubclassData<Bitfield>(
Value);
294 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
295 "Bitfields must be contiguous");
316 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
317 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
320 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
329 return Align(1ULL << (getSubclassData<AlignmentField>()));
333 setSubclassData<AlignmentField>(
Log2(
Align));
338 return getSubclassData<OrderingField>();
344 setSubclassData<OrderingField>(Ordering);
388 return I->getOpcode() == Instruction::Store;
391 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
397 template <
typename Bitfield>
398 void setSubclassData(
typename Bitfield::Type
Value) {
399 Instruction::setSubclassData<Bitfield>(
Value);
438 void *
operator new(
size_t S) {
return User::operator
new(S, 0); }
439 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
443 return getSubclassData<OrderingField>();
449 setSubclassData<OrderingField>(Ordering);
464 return I->getOpcode() == Instruction::Fence;
467 return isa<Instruction>(V) && classof(cast<Instruction>(V));
473 template <
typename Bitfield>
474 void setSubclassData(
typename Bitfield::Type
Value) {
475 Instruction::setSubclassData<Bitfield>(
Value);
499 template <
unsigned Offset>
500 using AtomicOrderingBitfieldElement =
517 void *
operator new(
size_t S) {
return User::operator
new(S, 3); }
518 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
531 "Bitfields must be contiguous");
536 return Align(1ULL << getSubclassData<AlignmentField>());
540 setSubclassData<AlignmentField>(
Log2(
Align));
546 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
553 bool isWeak()
const {
return getSubclassData<WeakField>(); }
555 void setWeak(
bool IsWeak) { setSubclassData<WeakField>(IsWeak); }
574 return getSubclassData<SuccessOrderingField>();
580 "invalid CmpXchg success ordering");
581 setSubclassData<SuccessOrderingField>(Ordering);
586 return getSubclassData<FailureOrderingField>();
592 "invalid CmpXchg failure ordering");
593 setSubclassData<FailureOrderingField>(Ordering);
644 switch (SuccessOrdering) {
660 return I->getOpcode() == Instruction::AtomicCmpXchg;
663 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
669 template <
typename Bitfield>
670 void setSubclassData(
typename Bitfield::Type
Value) {
671 Instruction::setSubclassData<Bitfield>(
Value);
754 LAST_BINOP = UDecWrap,
759 template <
unsigned Offset>
760 using AtomicOrderingBitfieldElement =
764 template <
unsigned Offset>
765 using BinOpBitfieldElement =
774 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
775 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
784 "Bitfields must be contiguous");
803 setSubclassData<OperationField>(
Operation);
809 return Align(1ULL << getSubclassData<AlignmentField>());
813 setSubclassData<AlignmentField>(
Log2(
Align));
818 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
829 return getSubclassData<AtomicOrderingField>();
835 "atomicrmw instructions can only be atomic.");
837 "atomicrmw instructions cannot be unordered.");
838 setSubclassData<AtomicOrderingField>(Ordering);
864 return isFPOperation(getOperation());
869 return I->getOpcode() == Instruction::AtomicRMW;
872 return isa<Instruction>(V) && classof(cast<Instruction>(V));
881 template <
typename Bitfield>
882 void setSubclassData(
typename Bitfield::Type
Value) {
883 Instruction::setSubclassData<Bitfield>(
Value);
907 assert(Ty &&
"Invalid GetElementPtrInst indices for type!");
915 Type *SourceElementType;
916 Type *ResultElementType;
939 const Twine &NameStr =
"",
942 assert(PointeeType &&
"Must specify element type");
944 NameStr, InsertBefore);
949 const Twine &NameStr =
"",
952 Create(PointeeType,
Ptr, IdxList, NameStr, InsertBefore);
953 GEP->setNoWrapFlags(NW);
961 const Twine &NameStr =
"",
964 NameStr, InsertBefore);
976 return ResultElementType;
1046 if (
auto *IndexVTy = dyn_cast<VectorType>(
Index->getType())) {
1103 APInt &ConstantOffset)
const;
1106 return (
I->getOpcode() == Instruction::GetElementPtr);
1109 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1118GetElementPtrInst::GetElementPtrInst(
Type *PointeeType,
Value *
Ptr,
1120 const Twine &NameStr,
1124 Values, InsertBefore),
1125 SourceElementType(PointeeType),
1126 ResultElementType(getIndexedType(PointeeType, IdxList)) {
1127 init(
Ptr, IdxList, NameStr);
1142 assert(isIntPredicate() &&
1143 "Invalid ICmp predicate value");
1145 "Both operands to ICmp instruction are not of the same type!");
1148 getOperand(0)->
getType()->isPtrOrPtrVectorTy()) &&
1149 "Invalid operand types for ICmp instruction");
1165 const Twine &NameStr =
""
1168 RHS, NameStr, InsertBefore) {
1179 const Twine &NameStr =
""
1192 return getSignedPredicate(getPredicate());
1197 static Predicate getSignedPredicate(Predicate
pred);
1204 return getUnsignedPredicate(getPredicate());
1209 static Predicate getUnsignedPredicate(Predicate
pred);
1214 return P == ICMP_EQ ||
P == ICMP_NE;
1220 return isEquality(getPredicate());
1230 return !isEquality();
1236 return !isEquality(
P);
1242 return P == ICMP_SGT ||
P == ICMP_UGT;
1248 return P == ICMP_SLT ||
P == ICMP_ULT;
1254 return P == ICMP_SGE ||
P == ICMP_UGE;
1260 return P == ICMP_SLE ||
P == ICMP_ULE;
1273 setPredicate(getSwappedPredicate());
1283 return I->getOpcode() == Instruction::ICmp;
1286 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1302 "Both operands to FCmp instruction are not of the same type!");
1305 "Invalid operand types for FCmp instruction");
1321 const Twine &NameStr =
""
1324 RHS, NameStr, InsertBefore) {
1332 const Twine &NameStr =
"",
1335 RHS, NameStr, nullptr, FlagsSource) {
1384 return I->getOpcode() == Instruction::FCmp;
1387 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1407 :
CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore) {}
1417 static int ComputeNumOperands(
int NumArgs,
int NumBundleInputs = 0) {
1420 return 1 + NumArgs + NumBundleInputs;
1432 return new (ComputeNumOperands(0))
CallInst(Ty,
F, NameStr, InsertBefore);
1436 const Twine &NameStr,
1438 return new (ComputeNumOperands(Args.size()))
1439 CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore);
1444 const Twine &NameStr =
"",
1446 const int NumOperands =
1450 return new (NumOperands, DescriptorBytes)
1451 CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
1456 return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
1462 const Twine &NameStr =
"",
1464 return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
1465 NameStr, InsertBefore);
1469 const Twine &NameStr,
1471 return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
1495 Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
1496 "Bitfields must be contiguous");
1499 return getSubclassData<TailCallKindField>();
1512 setSubclassData<TailCallKindField>(TCK);
1525 return I->getOpcode() == Instruction::Call;
1528 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1537 template <
typename Bitfield>
1538 void setSubclassData(
typename Bitfield::Type
Value) {
1539 Instruction::setSubclassData<Bitfield>(
Value);
1543CallInst::CallInst(
FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1544 ArrayRef<OperandBundleDef> Bundles,
const Twine &NameStr,
1545 InsertPosition InsertBefore)
1546 : CallBase(Ty->getReturnType(), Instruction::
Call,
1547 OperandTraits<CallBase>::op_end(this) -
1548 (
Args.
size() + CountBundleInputs(Bundles) + 1),
1551 init(Ty, Func, Args, Bundles, NameStr);
1585 const Twine &NameStr =
"",
1622 return I->getOpcode() == Instruction::Select;
1625 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1662 return I->getOpcode() == VAArg;
1665 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1688 const Twine &NameStr =
"",
1711 return I->getOpcode() == Instruction::ExtractElement;
1714 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1734 const Twine &NameStr =
"",
1745 const Twine &NameStr =
"",
1752 static bool isValidOperands(
const Value *Vec,
const Value *NewElt,
1766 return I->getOpcode() == Instruction::InsertElement;
1769 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1812 const Twine &NameStr =
"",
1815 const Twine &NameStr =
"",
1818 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
1819 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
1827 static bool isValidOperands(
const Value *V1,
const Value *V2,
1829 static bool isValidOperands(
const Value *V1,
const Value *V2,
1847 static void getShuffleMask(
const Constant *Mask,
1853 Result.assign(ShuffleMask.
begin(), ShuffleMask.
end());
1874 unsigned NumSourceElts = cast<VectorType>(
Op<0>()->
getType())
1876 .getKnownMinValue();
1877 unsigned NumMaskElts = ShuffleMask.
size();
1878 return NumSourceElts != NumMaskElts;
1885 unsigned NumSourceElts = cast<VectorType>(
Op<0>()->
getType())
1887 .getKnownMinValue();
1888 unsigned NumMaskElts = ShuffleMask.
size();
1889 return NumSourceElts < NumMaskElts;
1897 static bool isSingleSourceMask(
ArrayRef<int> Mask,
int NumSrcElts);
1899 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
1901 getShuffleMask(Mask, MaskAsInts);
1902 return isSingleSourceMask(MaskAsInts, NumSrcElts);
1910 return !changesLength() &&
1911 isSingleSourceMask(ShuffleMask, ShuffleMask.
size());
1919 static bool isIdentityMask(
ArrayRef<int> Mask,
int NumSrcElts);
1921 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
1925 if (isa<ScalableVectorType>(Mask->getType()))
1929 getShuffleMask(Mask, MaskAsInts);
1930 return isIdentityMask(MaskAsInts, NumSrcElts);
1940 if (isa<ScalableVectorType>(
getType()))
1943 return !changesLength() && isIdentityMask(ShuffleMask, ShuffleMask.
size());
1948 bool isIdentityWithPadding()
const;
1952 bool isIdentityWithExtract()
const;
1957 bool isConcat()
const;
1967 static bool isSelectMask(
ArrayRef<int> Mask,
int NumSrcElts);
1969 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
1971 getShuffleMask(Mask, MaskAsInts);
1972 return isSelectMask(MaskAsInts, NumSrcElts);
1984 return !changesLength() && isSelectMask(ShuffleMask, ShuffleMask.
size());
1994 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
1996 getShuffleMask(Mask, MaskAsInts);
2013 static bool isZeroEltSplatMask(
ArrayRef<int> Mask,
int NumSrcElts);
2015 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2017 getShuffleMask(Mask, MaskAsInts);
2018 return isZeroEltSplatMask(MaskAsInts, NumSrcElts);
2028 return !changesLength() &&
2029 isZeroEltSplatMask(ShuffleMask, ShuffleMask.
size());
2064 static bool isTransposeMask(
ArrayRef<int> Mask,
int NumSrcElts);
2066 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2068 getShuffleMask(Mask, MaskAsInts);
2069 return isTransposeMask(MaskAsInts, NumSrcElts);
2078 return !changesLength() && isTransposeMask(ShuffleMask, ShuffleMask.
size());
2089 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2091 getShuffleMask(Mask, MaskAsInts);
2092 return isSpliceMask(MaskAsInts, NumSrcElts,
Index);
2100 return !changesLength() &&
2101 isSpliceMask(ShuffleMask, ShuffleMask.
size(),
Index);
2107 static bool isExtractSubvectorMask(
ArrayRef<int> Mask,
int NumSrcElts,
2111 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2114 if (isa<ScalableVectorType>(Mask->getType()))
2117 getShuffleMask(Mask, MaskAsInts);
2118 return isExtractSubvectorMask(MaskAsInts, NumSrcElts,
Index);
2125 if (isa<ScalableVectorType>(
getType()))
2129 cast<FixedVectorType>(
Op<0>()->
getType())->getNumElements();
2130 return isExtractSubvectorMask(ShuffleMask, NumSrcElts,
Index);
2137 static bool isInsertSubvectorMask(
ArrayRef<int> Mask,
int NumSrcElts,
2138 int &NumSubElts,
int &
Index);
2140 int &NumSubElts,
int &
Index) {
2141 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2144 if (isa<ScalableVectorType>(Mask->getType()))
2147 getShuffleMask(Mask, MaskAsInts);
2148 return isInsertSubvectorMask(MaskAsInts, NumSrcElts, NumSubElts,
Index);
2155 if (isa<ScalableVectorType>(
getType()))
2159 cast<FixedVectorType>(
Op<0>()->
getType())->getNumElements();
2160 return isInsertSubvectorMask(ShuffleMask, NumSrcElts, NumSubElts,
Index);
2167 static bool isReplicationMask(
ArrayRef<int> Mask,
int &ReplicationFactor,
2171 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2174 if (isa<ScalableVectorType>(Mask->getType()))
2177 getShuffleMask(Mask, MaskAsInts);
2178 return isReplicationMask(MaskAsInts, ReplicationFactor, VF);
2182 bool isReplicationMask(
int &ReplicationFactor,
int &VF)
const;
2193 static bool isOneUseSingleSourceMask(
ArrayRef<int> Mask,
int VF);
2197 bool isOneUseSingleSourceMask(
int VF)
const;
2202 unsigned InVecNumElts) {
2203 for (
int &
Idx : Mask) {
2206 Idx =
Idx < (int)InVecNumElts ?
Idx + InVecNumElts :
Idx - InVecNumElts;
2208 "shufflevector mask index out of range");
2213 bool isInterleave(
unsigned Factor);
2234 static bool isInterleaveMask(
ArrayRef<int> Mask,
unsigned Factor,
2235 unsigned NumInputElts,
2238 unsigned NumInputElts) {
2240 return isInterleaveMask(Mask, Factor, NumInputElts, StartIndexes);
2246 static bool isDeInterleaveMaskOfFactor(
ArrayRef<int> Mask,
unsigned Factor,
2250 return isDeInterleaveMaskOfFactor(Mask, Factor, Unused);
2264 static bool isBitRotateMask(
ArrayRef<int> Mask,
unsigned EltSizeInBits,
2265 unsigned MinSubElts,
unsigned MaxSubElts,
2266 unsigned &NumSubElts,
unsigned &RotateAmt);
2270 return I->getOpcode() == Instruction::ShuffleVector;
2273 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2312 const Twine &NameStr =
"",
2333 return getOperand(0);
2336 return getOperand(0);
2347 return (
unsigned)Indices.
size();
2356 return I->getOpcode() == Instruction::ExtractValue;
2359 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2363ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
2364 const Twine &NameStr,
2365 InsertPosition InsertBefore)
2367 ExtractValue, Agg, InsertBefore) {
2368 init(Idxs, NameStr);
2393 const Twine &NameStr =
"",
2397 const Twine &NameStr);
2407 void *
operator new(
size_t S) {
return User::operator
new(S, 2); }
2408 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
2412 const Twine &NameStr =
"",
2453 return (
unsigned)Indices.
size();
2462 return I->getOpcode() == Instruction::InsertValue;
2465 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
2474InsertValueInst::InsertValueInst(
Value *Agg,
Value *Val,
2480 init(Agg, Val, Idxs, NameStr);
2496 unsigned ReservedSpace;
2500 explicit PHINode(
Type *Ty,
unsigned NumReservedValues,
2501 const Twine &NameStr =
"",
2503 :
Instruction(Ty, Instruction::PHI,
nullptr, 0, InsertBefore),
2504 ReservedSpace(NumReservedValues) {
2507 allocHungoffUses(ReservedSpace);
2527 const Twine &NameStr =
"",
2529 return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
2548 return block_begin() + getNumOperands();
2552 return make_range(block_begin(), block_end());
2566 return getOperand(i);
2569 assert(V &&
"PHI node got a null value!");
2571 "All operands to PHI node must be the same type as the PHI node!");
2586 return block_begin()[i];
2593 assert(
this == U.getUser() &&
"Iterator doesn't point to PHI's Uses?");
2594 return getIncomingBlock(
unsigned(&U - op_begin()));
2601 return getIncomingBlock(
I.getUse());
2617 assert(New && Old &&
"PHI node got a null basic block!");
2618 for (
unsigned Op = 0, NumOps = getNumOperands();
Op != NumOps; ++
Op)
2619 if (getIncomingBlock(
Op) == Old)
2620 setIncomingBlock(
Op, New);
2626 if (getNumOperands() == ReservedSpace)
2629 setNumHungOffUseOperands(getNumOperands() + 1);
2630 setIncomingValue(getNumOperands() - 1, V);
2631 setIncomingBlock(getNumOperands() - 1, BB);
2642 Value *removeIncomingValue(
unsigned Idx,
bool DeletePHIIfEmpty =
true);
2645 int Idx = getBasicBlockIndex(BB);
2646 assert(
Idx >= 0 &&
"Invalid basic block argument to remove!");
2647 return removeIncomingValue(
Idx, DeletePHIIfEmpty);
2652 void removeIncomingValueIf(
function_ref<
bool(
unsigned)> Predicate,
2653 bool DeletePHIIfEmpty =
true);
2659 for (
unsigned i = 0, e = getNumOperands(); i != e; ++i)
2660 if (block_begin()[i] == BB)
2666 int Idx = getBasicBlockIndex(BB);
2667 assert(
Idx >= 0 &&
"Invalid basic block argument!");
2668 return getIncomingValue(
Idx);
2673 assert(BB &&
"PHI node got a null basic block!");
2675 for (
unsigned Op = 0, NumOps = getNumOperands();
Op != NumOps; ++
Op)
2676 if (getIncomingBlock(
Op) == BB) {
2678 setIncomingValue(
Op, V);
2681 assert(Found &&
"Invalid basic block argument to set!");
2686 Value *hasConstantValue()
const;
2691 bool hasConstantOrUndefValue()
const;
2698 return getBasicBlockIndex(Pred) >= 0;
2704 return I->getOpcode() == Instruction::PHI;
2707 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2711 void growOperands();
2737 unsigned ReservedSpace;
2749 void *
operator new(
size_t S) {
return User::operator
new(S); }
2751 void growOperands(
unsigned Size);
2752 void init(
unsigned NumReservedValues,
const Twine &NameStr);
2761 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
2766 const Twine &NameStr =
"",
2775 bool isCleanup()
const {
return getSubclassData<CleanupField>(); }
2786 return cast<Constant>(getOperandList()[
Idx]);
2791 return !isa<ArrayType>(getOperandList()[
Idx]->
getType());
2796 return isa<ArrayType>(getOperandList()[
Idx]->
getType());
2808 return I->getOpcode() == Instruction::LandingPad;
2811 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2858 return new(!!retVal)
ReturnInst(
C, retVal, InsertBefore);
2862 return new (0)
ReturnInst(
C,
nullptr, InsertAtEnd);
2870 return getNumOperands() != 0 ? getOperand(0) :
nullptr;
2877 return (
I->getOpcode() == Instruction::Ret);
2880 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2884 BasicBlock *getSuccessor(
unsigned idx)
const {
2888 void setSuccessor(
unsigned idx, BasicBlock *
B) {
2941 std::random_access_iterator_tag, BasicBlock *,
2942 ptrdiff_t, BasicBlock *, BasicBlock *> {
2952 std::random_access_iterator_tag,
2953 const BasicBlock *, ptrdiff_t, const BasicBlock *,
2954 const BasicBlock *> {
2964 return new(1)
BranchInst(IfTrue, InsertBefore);
2980 assert(isConditional() &&
"Cannot get condition of an uncond branch!");
2985 assert(isConditional() &&
"Cannot set condition of unconditional branch!");
2992 assert(i < getNumSuccessors() &&
"Successor # out of range for Branch!");
2993 return cast_or_null<BasicBlock>((&
Op<-1>() - i)->
get());
2997 assert(idx < getNumSuccessors() &&
"Successor # out of range for Branch!");
2998 *(&
Op<-1>() - idx) = NewSucc;
3006 void swapSuccessors();
3016 std::next(value_op_begin(), isConditional() ? 1 : 0)),
3022 return (
I->getOpcode() == Instruction::Br);
3025 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3043 unsigned ReservedSpace;
3059 void *
operator new(
size_t S) {
return User::operator
new(S); }
3062 void growOperands();
3071 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
3074 static const unsigned DefaultPseudoIndex =
static_cast<unsigned>(~0L-1);
3083 template <
typename SwitchInstT,
typename ConstantIntT,
typename BasicBlockT>
3102 assert((
unsigned)Index < SI->getNumCases() &&
3103 "Index out the number of cases.");
3104 return reinterpret_cast<ConstantIntT *
>(
SI->getOperand(2 +
Index * 2));
3109 assert(((
unsigned)Index < SI->getNumCases() ||
3110 (
unsigned)
Index == DefaultPseudoIndex) &&
3111 "Index out the number of cases.");
3112 return SI->getSuccessor(getSuccessorIndex());
3121 (
unsigned)Index < SI->getNumCases()) &&
3122 "Index out the number of cases.");
3123 return (
unsigned)
Index != DefaultPseudoIndex ?
Index + 1 : 0;
3127 assert(
SI ==
RHS.SI &&
"Incompatible operators.");
3144 assert((
unsigned)Index < SI->getNumCases() &&
3145 "Index out the number of cases.");
3146 SI->setOperand(2 +
Index*2,
reinterpret_cast<Value*
>(V));
3151 SI->setSuccessor(getSuccessorIndex(), S);
3155 template <
typename CaseHandleT>
3158 std::random_access_iterator_tag,
3159 const CaseHandleT> {
3160 using SwitchInstT =
typename CaseHandleT::SwitchInstType;
3176 unsigned SuccessorIndex) {
3177 assert(SuccessorIndex < SI->getNumSuccessors() &&
3178 "Successor index # out of range!");
3193 (
unsigned)(Case.Index +
N) <= Case.SI->getNumCases() &&
3194 "Case.Index out the number of cases.");
3202 (
unsigned)(Case.Index -
N) <= Case.SI->getNumCases() &&
3203 "Case.Index out the number of cases.");
3208 assert(Case.SI ==
RHS.Case.SI &&
"Incompatible operators.");
3209 return Case.Index -
RHS.Case.Index;
3212 return Case ==
RHS.Case;
3215 assert(Case.SI ==
RHS.Case.SI &&
"Incompatible operators.");
3216 return Case.Index <
RHS.Case.Index;
3238 return cast<BasicBlock>(getOperand(1));
3244 return isa<UnreachableInst>(getDefaultDest()->getFirstNonPHIOrDbg());
3248 setOperand(1,
reinterpret_cast<Value*
>(DefaultCase));
3254 return getNumOperands()/2 - 1;
3272 return CaseIt(
this, getNumCases());
3297 return CaseIt(
this, DefaultPseudoIndex);
3310 const_cast<const SwitchInst *
>(
this)->findCaseValue(
C)->getCaseIndex());
3316 if (
I != case_end())
3319 return case_default();
3325 if (BB == getDefaultDest())
3329 for (
auto Case : cases()) {
3330 if (Case.getCaseSuccessor() != BB)
3336 CI = Case.getCaseValue();
3355 CaseIt removeCase(CaseIt
I);
3359 assert(idx < getNumSuccessors() &&
"Successor idx out of range for switch!");
3360 return cast<BasicBlock>(getOperand(idx*2+1));
3363 assert(idx < getNumSuccessors() &&
"Successor # out of range for switch!");
3364 setOperand(idx * 2 + 1, NewSucc);
3369 return I->getOpcode() == Instruction::Switch;
3372 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3380 std::optional<SmallVector<uint32_t, 8>> Weights;
3381 bool Changed =
false;
3433 unsigned ReservedSpace;
3447 void *
operator new(
size_t S) {
return User::operator
new(S); }
3450 void growOperands();
3459 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
3467 std::random_access_iterator_tag, BasicBlock *,
3468 ptrdiff_t, BasicBlock *, BasicBlock *> {
3478 std::random_access_iterator_tag,
3479 const BasicBlock *, ptrdiff_t, const BasicBlock *,
3480 const BasicBlock *> {
3515 void removeDestination(
unsigned i);
3519 return cast<BasicBlock>(getOperand(i+1));
3522 setOperand(i + 1, NewSucc);
3537 return I->getOpcode() == Instruction::IndirectBr;
3540 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3560 static constexpr int NumExtraOperands = 2;
3563 static constexpr int NormalDestOpEndIdx = -3;
3566 static constexpr int UnwindDestOpEndIdx = -2;
3583 static int ComputeNumOperands(
int NumArgs,
int NumBundleInputs = 0) {
3586 return 1 + NumExtraOperands + NumArgs + NumBundleInputs;
3598 const Twine &NameStr,
3600 int NumOperands = ComputeNumOperands(Args.size());
3601 return new (NumOperands)
3602 InvokeInst(Ty, Func, IfNormal, IfException, Args, std::nullopt,
3603 NumOperands, NameStr, InsertBefore);
3609 const Twine &NameStr =
"",
3612 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
3615 return new (NumOperands, DescriptorBytes)
3616 InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
3617 NameStr, InsertBefore);
3622 const Twine &NameStr,
3624 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3625 IfException, Args, std::nullopt, NameStr, InsertBefore);
3631 const Twine &NameStr =
"",
3633 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3634 IfException, Args, Bundles, NameStr, InsertBefore);
3665 assert(i < 2 &&
"Successor # out of range for invoke!");
3666 return i == 0 ? getNormalDest() : getUnwindDest();
3670 assert(i < 2 &&
"Successor # out of range for invoke!");
3672 setNormalDest(NewSucc);
3674 setUnwindDest(NewSucc);
3684 return (
I->getOpcode() == Instruction::Invoke);
3687 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3693 template <
typename Bitfield>
3694 void setSubclassData(
typename Bitfield::Type
Value) {
3695 Instruction::setSubclassData<Bitfield>(
Value);
3699InvokeInst::InvokeInst(
FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3700 BasicBlock *IfException, ArrayRef<Value *> Args,
3701 ArrayRef<OperandBundleDef> Bundles,
int NumOperands,
3702 const Twine &NameStr, InsertPosition InsertBefore)
3703 : CallBase(Ty->getReturnType(), Instruction::Invoke,
3704 OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
3706 init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
3719 unsigned NumIndirectDests;
3729 int NumOperands,
const Twine &NameStr,
3737 static int ComputeNumOperands(
int NumArgs,
int NumIndirectDests,
3738 int NumBundleInputs = 0) {
3741 return 2 + NumIndirectDests + NumArgs + NumBundleInputs;
3756 int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.
size());
3757 return new (NumOperands)
3758 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, std::nullopt,
3759 NumOperands, NameStr, InsertBefore);
3767 int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.
size(),
3771 return new (NumOperands, DescriptorBytes)
3772 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
3773 NumOperands, NameStr, InsertBefore);
3780 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
3781 IndirectDests, Args, NameStr, InsertBefore);
3788 const Twine &NameStr =
"",
3790 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
3791 IndirectDests, Args, Bundles, NameStr, InsertBefore);
3830 return IndirectDests;
3841 "Successor # out of range for callbr!");
3847 "Successor # out of range for callbr!");
3855 return (
I->getOpcode() == Instruction::CallBr);
3858 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
3864 template <
typename Bitfield>
3865 void setSubclassData(
typename Bitfield::Type
Value) {
3866 Instruction::setSubclassData<Bitfield>(
Value);
3870CallBrInst::CallBrInst(
FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
3871 ArrayRef<BasicBlock *> IndirectDests,
3872 ArrayRef<Value *> Args,
3873 ArrayRef<OperandBundleDef> Bundles,
int NumOperands,
3874 const Twine &NameStr, InsertPosition InsertBefore)
3875 : CallBase(Ty->getReturnType(), Instruction::CallBr,
3876 OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
3878 init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
3914 return I->getOpcode() == Instruction::Resume;
3917 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
3921 BasicBlock *getSuccessor(
unsigned idx)
const {
3925 void setSuccessor(
unsigned idx,
BasicBlock *NewSucc) {
3945 unsigned ReservedSpace;
3957 unsigned NumHandlers,
const Twine &NameStr,
3961 void *
operator new(
size_t S) {
return User::operator
new(S); }
3963 void init(
Value *ParentPad,
BasicBlock *UnwindDest,
unsigned NumReserved);
3964 void growOperands(
unsigned Size);
3973 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
3976 unsigned NumHandlers,
3977 const Twine &NameStr =
"",
3979 return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
3994 if (hasUnwindDest())
3995 return cast<BasicBlock>(getOperand(1));
4001 setOperand(1, UnwindDest);
4007 if (hasUnwindDest())
4008 return getNumOperands() - 2;
4009 return getNumOperands() - 1;
4013 static BasicBlock *handler_helper(
Value *V) {
return cast<BasicBlock>(V); }
4014 static const BasicBlock *handler_helper(
const Value *V) {
4015 return cast<BasicBlock>(V);
4030 if (hasUnwindDest())
4039 if (hasUnwindDest())
4058 return make_range(handler_begin(), handler_end());
4063 return make_range(handler_begin(), handler_end());
4072 void removeHandler(handler_iterator HI);
4077 "Successor # out of range for catchswitch!");
4078 return cast<BasicBlock>(getOperand(
Idx + 1));
4082 "Successor # out of range for catchswitch!");
4083 setOperand(
Idx + 1, NewSucc);
4088 return I->getOpcode() == Instruction::CatchSwitch;
4091 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4106 unsigned Values,
const Twine &NameStr,
4108 :
FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
4109 NameStr, InsertBefore) {}
4114 const Twine &NameStr =
"",
4116 unsigned Values = 1 + Args.size();
4123 return I->getOpcode() == Instruction::CleanupPad;
4126 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4136 unsigned Values,
const Twine &NameStr,
4138 :
FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
4139 NameStr, InsertBefore) {}
4143 const Twine &NameStr =
"",
4145 unsigned Values = 1 + Args.size();
4147 CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
4152 return cast<CatchSwitchInst>(
Op<-1>());
4156 Op<-1>() = CatchSwitch;
4161 return I->getOpcode() == Instruction::CatchPad;
4164 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4217 return (
I->getOpcode() == Instruction::CatchRet);
4220 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4266 unsigned Values = 1;
4281 return cast<CleanupPadInst>(
Op<0>());
4285 Op<0>() = CleanupPad;
4291 return hasUnwindDest() ? cast<BasicBlock>(
Op<1>()) :
nullptr;
4301 return (
I->getOpcode() == Instruction::CleanupRet);
4304 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4310 return getUnwindDest();
4313 void setSuccessor(
unsigned Idx, BasicBlock *
B) {
4320 template <
typename Bitfield>
4321 void setSubclassData(
typename Bitfield::Type Value) {
4322 Instruction::setSubclassData<Bitfield>(Value);
4353 void *
operator new(
size_t S) {
return User::operator
new(S, 0); }
4354 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
4360 return I->getOpcode() == Instruction::Unreachable;
4363 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4367 BasicBlock *getSuccessor(
unsigned idx)
const {
4371 void setSuccessor(
unsigned idx, BasicBlock *
B) {
4395 const Twine &NameStr =
"",
4402 return I->getOpcode() == Trunc;
4405 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4431 unsigned NoWrapKind = 0;
4459 const Twine &NameStr =
"",
4466 return I->getOpcode() == ZExt;
4469 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4490 const Twine &NameStr =
"",
4497 return I->getOpcode() == SExt;
4500 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4520 const Twine &NameStr =
"",
4527 return I->getOpcode() == FPTrunc;
4530 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4551 const Twine &NameStr =
"",
4558 return I->getOpcode() == FPExt;
4561 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4582 const Twine &NameStr =
"",
4589 return I->getOpcode() == UIToFP;
4592 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4613 const Twine &NameStr =
"",
4620 return I->getOpcode() == SIToFP;
4623 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4644 const Twine &NameStr =
"",
4651 return I->getOpcode() == FPToUI;
4654 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4675 const Twine &NameStr =
"",
4682 return I->getOpcode() == FPToSI;
4685 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4702 const Twine &NameStr =
"",
4717 return I->getOpcode() == IntToPtr;
4720 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4741 const Twine &NameStr =
"",
4760 return I->getOpcode() == PtrToInt;
4763 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4784 const Twine &NameStr =
"",
4791 return I->getOpcode() == BitCast;
4794 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4817 const Twine &NameStr =
"",
4824 return I->getOpcode() == AddrSpaceCast;
4827 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4863 if (
auto *Load = dyn_cast<LoadInst>(V))
4864 return Load->getPointerOperand();
4865 if (
auto *Store = dyn_cast<StoreInst>(V))
4866 return Store->getPointerOperand();
4870 return const_cast<Value *
>(
4879 if (
auto *Gep = dyn_cast<GetElementPtrInst>(V))
4880 return Gep->getPointerOperand();
4889 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
4890 "Expected Load or Store instruction");
4891 if (
auto *LI = dyn_cast<LoadInst>(
I))
4892 return LI->getAlign();
4893 return cast<StoreInst>(
I)->getAlign();
4899 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
4900 "Expected Load or Store instruction");
4901 if (
auto *LI = dyn_cast<LoadInst>(
I))
4902 return LI->getPointerAddressSpace();
4903 return cast<StoreInst>(
I)->getPointerAddressSpace();
4908 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
4909 "Expected Load or Store instruction");
4910 if (
auto *LI = dyn_cast<LoadInst>(
I))
4911 return LI->getType();
4912 return cast<StoreInst>(
I)->getValueOperand()->getType();
4919 return std::nullopt;
4920 if (
auto *AI = dyn_cast<LoadInst>(
I))
4921 return AI->getSyncScopeID();
4922 if (
auto *AI = dyn_cast<StoreInst>(
I))
4923 return AI->getSyncScopeID();
4924 if (
auto *AI = dyn_cast<FenceInst>(
I))
4925 return AI->getSyncScopeID();
4926 if (
auto *AI = dyn_cast<AtomicCmpXchgInst>(
I))
4927 return AI->getSyncScopeID();
4928 if (
auto *AI = dyn_cast<AtomicRMWInst>(
I))
4929 return AI->getSyncScopeID();
4953 return I->getOpcode() == Freeze;
4956 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool isReverseMask(ArrayRef< int > M, EVT VT)
Atomic ordering constants.
static const Function * getParent(const Value *V)
This file implements methods to test, set and extract typed bits from packed unsigned integers.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
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 provides various utilities for inspecting and working with the control flow graph in LLVM I...
This file implements a map that provides insertion order iteration.
uint64_t IntrinsicInst * II
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
PowerPC Reduce CR logical Operation
StandardInstrumentations SI(Mod->getContext(), Debug, VerifyEach)
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
This defines the Use class.
Class for arbitrary precision integers.
This class represents a conversion between pointers from one address space to another.
const Value * getPointerOperand() const
Gets the pointer operand.
AddrSpaceCastInst * cloneImpl() const
Clone an identical AddrSpaceCastInst.
Value * getPointerOperand()
Gets the pointer operand.
static bool classof(const Instruction *I)
static bool classof(const Value *V)
unsigned getSrcAddressSpace() const
Returns the address space of the pointer operand.
unsigned getDestAddressSpace() const
Returns the address space of the result.
static unsigned getPointerOperandIndex()
Gets the operand index of the pointer operand.
an instruction to allocate memory on the stack
std::optional< TypeSize > getAllocationSizeInBits(const DataLayout &DL) const
Get allocation size in bits.
static bool classof(const Value *V)
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
void setSwiftError(bool V)
Specify whether this alloca is used to represent a swifterror.
bool isStaticAlloca() const
Return true if this alloca is in the entry block of the function and is a constant size.
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
void setAllocatedType(Type *Ty)
for use only in special circumstances that need to generically transform a whole instruction (eg: IR ...
static bool classof(const Instruction *I)
PointerType * getType() const
Overload to return most specific pointer type.
void setUsedWithInAlloca(bool V)
Specify whether this alloca is used to represent the arguments to a call.
AllocaInst * cloneImpl() const
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
bool isUsedWithInAlloca() const
Return true if this alloca is used as an inalloca argument to a call.
unsigned getAddressSpace() const
Return the address space for the allocation.
std::optional< TypeSize > getAllocationSize(const DataLayout &DL) const
Get allocation size in bytes.
bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1.
void setAlignment(Align Align)
const Value * getArraySize() const
Get the number of elements allocated.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
An instruction that atomically checks whether a specified value is in a memory location,...
BoolBitfieldElementT< 0 > VolatileField
const Value * getCompareOperand() const
Value * getNewValOperand()
void setSyncScopeID(SyncScope::ID SSID)
Sets the synchronization scope ID of this cmpxchg instruction.
AtomicOrdering getMergedOrdering() const
Returns a single ordering which is at least as strong as both the success and failure orderings for t...
void setWeak(bool IsWeak)
bool isVolatile() const
Return true if this is a cmpxchg from a volatile memory location.
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
BoolBitfieldElementT< VolatileField::NextBit > WeakField
AtomicOrderingBitfieldElementT< SuccessOrderingField::NextBit > FailureOrderingField
Value * getCompareOperand()
void setFailureOrdering(AtomicOrdering Ordering)
Sets the failure ordering constraint of this cmpxchg instruction.
static bool isValidFailureOrdering(AtomicOrdering Ordering)
AtomicOrdering getFailureOrdering() const
Returns the failure ordering constraint of this cmpxchg instruction.
void setSuccessOrdering(AtomicOrdering Ordering)
Sets the success ordering constraint of this cmpxchg instruction.
AlignmentBitfieldElementT< FailureOrderingField::NextBit > AlignmentField
Value * getPointerOperand()
static AtomicOrdering getStrongestFailureOrdering(AtomicOrdering SuccessOrdering)
Returns the strongest permitted ordering on failure, given the desired ordering on success.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
AtomicCmpXchgInst * cloneImpl() const
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
const Value * getPointerOperand() const
static bool classof(const Value *V)
bool isWeak() const
Return true if this cmpxchg may spuriously fail.
void setAlignment(Align Align)
void setVolatile(bool V)
Specify whether this is a volatile cmpxchg.
static bool isValidSuccessOrdering(AtomicOrdering Ordering)
AtomicOrdering getSuccessOrdering() const
Returns the success ordering constraint of this cmpxchg instruction.
AtomicOrderingBitfieldElementT< WeakField::NextBit > SuccessOrderingField
static unsigned getPointerOperandIndex()
const Value * getNewValOperand() const
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this cmpxchg instruction.
static bool classof(const Instruction *I)
an instruction that atomically reads a memory location, combines it with another value,...
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
static bool isFPOperation(BinOp Op)
static unsigned getPointerOperandIndex()
bool isVolatile() const
Return true if this is a RMW on a volatile memory location.
void setVolatile(bool V)
Specify whether this is a volatile RMW or not.
BinOpBitfieldElement< AtomicOrderingField::NextBit > OperationField
BinOp
This enumeration lists the possible modifications atomicrmw can make.
@ Min
*p = old <signed v ? old : v
@ UIncWrap
Increment one up to a maximum value.
@ Max
*p = old >signed v ? old : v
@ UMin
*p = old <unsigned v ? old : v
@ FMin
*p = minnum(old, v) minnum matches the behavior of llvm.minnum.
@ UMax
*p = old >unsigned v ? old : v
@ FMax
*p = maxnum(old, v) maxnum matches the behavior of llvm.maxnum.
@ UDecWrap
Decrement one until a minimum value or zero.
AtomicOrderingBitfieldElementT< VolatileField::NextBit > AtomicOrderingField
void setSyncScopeID(SyncScope::ID SSID)
Sets the synchronization scope ID of this rmw instruction.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
Value * getPointerOperand()
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this rmw instruction.
bool isFloatingPointOperation() const
static bool classof(const Instruction *I)
const Value * getPointerOperand() const
void setOperation(BinOp Operation)
static bool classof(const Value *V)
BinOp getOperation() const
const Value * getValOperand() const
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this rmw instruction.
void setAlignment(Align Align)
AtomicOrdering getOrdering() const
Returns the ordering constraint of this rmw instruction.
AlignmentBitfieldElementT< OperationField::NextBit > AlignmentField
BoolBitfieldElementT< 0 > VolatileField
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
LLVM Basic Block Representation.
This class represents a no-op cast from one type to another.
static bool classof(const Instruction *I)
static bool classof(const Value *V)
BitCastInst * cloneImpl() const
Clone an identical BitCastInst.
Conditional or Unconditional Branch instruction.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
iterator_range< succ_op_iterator > successors()
static BranchInst * Create(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, InsertPosition InsertBefore=nullptr)
void setCondition(Value *V)
static bool classof(const Instruction *I)
bool isConditional() const
unsigned getNumSuccessors() const
static bool classof(const Value *V)
static BranchInst * Create(BasicBlock *IfTrue, InsertPosition InsertBefore=nullptr)
BasicBlock * getSuccessor(unsigned i) const
bool isUnconditional() const
void setSuccessor(unsigned idx, BasicBlock *NewSucc)
Value * getCondition() const
iterator_range< const_succ_op_iterator > successors() const
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
void addFnAttr(Attribute::AttrKind Kind)
Adds the attribute to the function.
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
static unsigned CountBundleInputs(ArrayRef< OperandBundleDef > Bundles)
Return the total number of values used in Bundles.
unsigned arg_size() const
unsigned getNumTotalBundleOperands() const
Return the total number operands (not operand bundles) used by every operand bundle in this OperandBu...
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
static bool classof(const Value *V)
static bool classof(const Instruction *I)
SmallVector< BasicBlock *, 16 > getIndirectDests() const
static CallBrInst * Create(FunctionCallee Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
void setSuccessor(unsigned i, BasicBlock *NewSucc)
BasicBlock * getSuccessor(unsigned i) const
Value * getIndirectDestLabelUse(unsigned i) const
BasicBlock * getIndirectDest(unsigned i) const
static CallBrInst * Create(FunctionCallee Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
void setDefaultDest(BasicBlock *B)
unsigned getNumSuccessors() const
void setIndirectDest(unsigned i, BasicBlock *B)
Value * getIndirectDestLabel(unsigned i) const
getIndirectDestLabel - Return the i-th indirect dest label.
BasicBlock * getDefaultDest() const
unsigned getNumIndirectDests() const
Return the number of callbr indirect dest labels.
static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
CallBrInst * cloneImpl() const
static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
This class represents a function call, abstracting a target machine's calling convention.
bool isNoTailCall() const
void updateProfWeight(uint64_t S, uint64_t T)
Updates profile metadata by scaling it by S / T.
static bool classof(const Value *V)
void setTailCallKind(TailCallKind TCK)
static CallInst * Create(FunctionType *Ty, Value *Func, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
bool canReturnTwice() const
Return true if the call can return twice.
TailCallKind getTailCallKind() const
CallInst * cloneImpl() const
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CallInst * Create(FunctionCallee Func, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CallInst * Create(FunctionType *Ty, Value *Func, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
void setTailCall(bool IsTc=true)
bool isMustTailCall() const
static CallInst * Create(FunctionCallee Func, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
static bool classof(const Instruction *I)
static CallInst * Create(FunctionCallee Func, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
This is the base class for all instructions that perform data casts.
CatchSwitchInst * getCatchSwitch() const
Convenience accessors.
void setCatchSwitch(Value *CatchSwitch)
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static CatchPadInst * Create(Value *CatchSwitch, ArrayRef< Value * > Args, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static bool classof(const Value *V)
static bool classof(const Instruction *I)
BasicBlock * getSuccessor() const
CatchPadInst * getCatchPad() const
Convenience accessors.
void setSuccessor(BasicBlock *NewSucc)
static bool classof(const Value *V)
static CatchReturnInst * Create(Value *CatchPad, BasicBlock *BB, InsertPosition InsertBefore=nullptr)
unsigned getNumSuccessors() const
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
void setCatchPad(CatchPadInst *CatchPad)
CatchReturnInst * cloneImpl() const
Value * getCatchSwitchParentPad() const
Get the parentPad of this catchret's catchpad's catchswitch.
void setUnwindDest(BasicBlock *UnwindDest)
static bool classof(const Instruction *I)
BasicBlock *(*)(Value *) DerefFnTy
const BasicBlock *(*)(const Value *) ConstDerefFnTy
unsigned getNumSuccessors() const
const_handler_iterator handler_begin() const
Returns an iterator that points to the first handler in the CatchSwitchInst.
unsigned getNumHandlers() const
return the number of 'handlers' in this catchswitch instruction, except the default handler
void setSuccessor(unsigned Idx, BasicBlock *NewSucc)
Value * getParentPad() const
void setParentPad(Value *ParentPad)
bool unwindsToCaller() const
static bool classof(const Value *V)
handler_iterator handler_end()
Returns a read-only iterator that points one past the last handler in the CatchSwitchInst.
BasicBlock * getUnwindDest() const
BasicBlock * getSuccessor(unsigned Idx) const
const_handler_iterator handler_end() const
Returns an iterator that points one past the last handler in the CatchSwitchInst.
bool hasUnwindDest() const
handler_iterator handler_begin()
Returns an iterator that points to the first handler in CatchSwitchInst.
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
handler_range handlers()
iteration adapter for range-for loops.
const_handler_range handlers() const
iteration adapter for range-for loops.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
static bool classof(const Value *V)
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static CleanupPadInst * Create(Value *ParentPad, ArrayRef< Value * > Args=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static bool classof(const Instruction *I)
CleanupPadInst * getCleanupPad() const
Convenience accessor.
unsigned getNumSuccessors() const
BasicBlock * getUnwindDest() const
bool unwindsToCaller() const
void setCleanupPad(CleanupPadInst *CleanupPad)
static bool classof(const Value *V)
void setUnwindDest(BasicBlock *NewDest)
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, InsertPosition InsertBefore=nullptr)
bool hasUnwindDest() const
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
This class is the base class for the comparison instructions.
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
static auto FCmpPredicates()
Returns the sequence of all FCmp predicates.
bool isFPPredicate() const
Predicate getPredicate() const
Return the predicate for this instruction.
This is the shared class of boolean and integer constants.
This is an important base class in LLVM.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
This instruction compares its operands according to the predicate given to the constructor.
bool isRelational() const
FCmpInst(Predicate Pred, Value *LHS, Value *RHS, const Twine &NameStr="", Instruction *FlagsSource=nullptr)
Constructor with no-insertion semantics.
static bool classof(const Value *V)
bool isCommutative() const
static bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
static bool isEquality(Predicate Pred)
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static auto predicates()
Returns the sequence of all FCmp predicates.
FCmpInst * cloneImpl() const
Clone an identical FCmpInst.
void swapOperands()
Exchange the two operands to this instruction in such a way that it does not modify the semantics of ...
FCmpInst(InsertPosition InsertBefore, Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="")
Constructor with insertion semantics.
This class represents an extension of floating point types.
static bool classof(const Value *V)
FPExtInst * cloneImpl() const
Clone an identical FPExtInst.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
This class represents a cast from floating point to signed integer.
static bool classof(const Value *V)
FPToSIInst * cloneImpl() const
Clone an identical FPToSIInst.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
This class represents a cast from floating point to unsigned integer.
static bool classof(const Value *V)
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
FPToUIInst * cloneImpl() const
Clone an identical FPToUIInst.
This class represents a truncation of floating point types.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V)
FPTruncInst * cloneImpl() const
Clone an identical FPTruncInst.
An instruction for ordering other memory operations.
static bool classof(const Value *V)
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this fence instruction.
void setSyncScopeID(SyncScope::ID SSID)
Sets the synchronization scope ID of this fence instruction.
static bool classof(const Instruction *I)
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this fence instruction.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this fence instruction.
This class represents a freeze function that returns random concrete value if an operand is either a ...
static bool classof(const Value *V)
FreezeInst * cloneImpl() const
Clone an identical FreezeInst.
static bool classof(const Instruction *I)
friend class CatchPadInst
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Class to represent function types.
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
bool isInBounds() const
Determine whether the GEP has the inbounds flag.
bool hasNoUnsignedSignedWrap() const
Determine whether the GEP has the nusw flag.
static Type * getTypeAtIndex(Type *Ty, Value *Idx)
Return the type of the element at the given index of an indexable type.
Value * getPointerOperand()
bool hasAllZeroIndices() const
Return true if all of the indices of this GEP are zeros.
static Type * getGEPReturnType(Value *Ptr, ArrayRef< Value * > IdxList)
Returns the pointer type returned by the GEP instruction, which may be a vector of pointers.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
void setResultElementType(Type *Ty)
bool hasNoUnsignedWrap() const
Determine whether the GEP has the nuw flag.
bool hasAllConstantIndices() const
Return true if all of the indices of this GEP are constant integers.
unsigned getAddressSpace() const
Returns the address space of this instruction's pointer type.
iterator_range< const_op_iterator > indices() const
bool collectOffset(const DataLayout &DL, unsigned BitWidth, MapVector< Value *, APInt > &VariableOffsets, APInt &ConstantOffset) const
Type * getResultElementType() const
static bool classof(const Instruction *I)
static bool classof(const Value *V)
iterator_range< op_iterator > indices()
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
void setIsInBounds(bool b=true)
Set or clear the inbounds flag on this GEP instruction.
void setSourceElementType(Type *Ty)
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
Type * getSourceElementType() const
static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Type * getPointerOperandType() const
Method to return the pointer operand as a PointerType.
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, GEPNoWrapFlags NW, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static unsigned getPointerOperandIndex()
bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const
Accumulate the constant address offset of this GEP if possible.
const_op_iterator idx_begin() const
GetElementPtrInst * cloneImpl() const
void setNoWrapFlags(GEPNoWrapFlags NW)
Set nowrap flags for GEP instruction.
unsigned getNumIndices() const
GEPNoWrapFlags getNoWrapFlags() const
Get the nowrap flags for the GEP instruction.
const_op_iterator idx_end() const
const Value * getPointerOperand() const
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
This instruction compares its operands according to the predicate given to the constructor.
static bool classof(const Value *V)
ICmpInst(InsertPosition InsertBefore, Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="")
Constructor with insertion semantics.
bool isCommutative() const
static bool isGE(Predicate P)
Return true if the predicate is SGE or UGE.
static bool isLT(Predicate P)
Return true if the predicate is SLT or ULT.
static bool isGT(Predicate P)
Return true if the predicate is SGT or UGT.
static bool classof(const Instruction *I)
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
bool isEquality() const
Return true if this predicate is either EQ or NE.
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
static bool isRelational(Predicate P)
Return true if the predicate is relational (not EQ or NE).
void swapOperands()
Exchange the two operands to this instruction in such a way that it does not modify the semantics of ...
static auto predicates()
Returns the sequence of all ICmp predicates.
ICmpInst(Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="")
Constructor with no-insertion semantics.
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
Predicate getUnsignedPredicate() const
For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
static bool isLE(Predicate P)
Return true if the predicate is SLE or ULE.
Indirect Branch Instruction.
static IndirectBrInst * Create(Value *Address, unsigned NumDests, InsertPosition InsertBefore=nullptr)
BasicBlock * getDestination(unsigned i)
Return the specified destination.
static bool classof(const Value *V)
const Value * getAddress() const
static bool classof(const Instruction *I)
BasicBlock * getSuccessor(unsigned i) const
iterator_range< const_succ_op_iterator > successors() const
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
unsigned getNumDestinations() const
return the number of possible destinations in this indirectbr instruction.
const BasicBlock * getDestination(unsigned i) const
void setSuccessor(unsigned i, BasicBlock *NewSucc)
void setAddress(Value *V)
unsigned getNumSuccessors() const
iterator_range< succ_op_iterator > successors()
This instruction inserts a single (scalar) element into a VectorType value.
static bool classof(const Value *V)
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
VectorType * getType() const
Overload to return most specific vector type.
static bool classof(const Instruction *I)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
This instruction inserts a struct field of array element value into an aggregate value.
Value * getInsertedValueOperand()
static bool classof(const Instruction *I)
static unsigned getAggregateOperandIndex()
Value * getAggregateOperand()
static bool classof(const Value *V)
unsigned getNumIndices() const
ArrayRef< unsigned > getIndices() const
iterator_range< idx_iterator > indices() const
static unsigned getInsertedValueOperandIndex()
InsertValueInst * cloneImpl() const
idx_iterator idx_end() const
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
const Value * getAggregateOperand() const
const Value * getInsertedValueOperand() const
idx_iterator idx_begin() const
typename Bitfield::Element< AtomicOrdering, Offset, 3, AtomicOrdering::LAST > AtomicOrderingBitfieldElementT
typename Bitfield::Element< bool, Offset, 1 > BoolBitfieldElementT
bool isAtomic() const LLVM_READONLY
Return true if this instruction has an AtomicOrdering of unordered or higher.
typename Bitfield::Element< unsigned, Offset, 6, Value::MaxAlignmentExponent > AlignmentBitfieldElementT
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
friend class BasicBlock
Various leaf nodes.
This class represents a cast from an integer to a pointer.
static bool classof(const Instruction *I)
IntToPtrInst * cloneImpl() const
Clone an identical IntToPtrInst.
unsigned getAddressSpace() const
Returns the address space of this instruction's pointer type.
static bool classof(const Value *V)
static bool classof(const Instruction *I)
BasicBlock * getUnwindDest() const
void setNormalDest(BasicBlock *B)
static bool classof(const Value *V)
static InvokeInst * Create(FunctionCallee Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
void setSuccessor(unsigned i, BasicBlock *NewSucc)
BasicBlock * getSuccessor(unsigned i) const
void setUnwindDest(BasicBlock *B)
BasicBlock * getNormalDest() const
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static InvokeInst * Create(FunctionCallee Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
unsigned getNumSuccessors() const
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
This is an important class for using LLVM in a threaded context.
The landingpad instruction holds all of the information necessary to generate correct exception handl...
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
bool isCatch(unsigned Idx) const
Return 'true' if the clause and index Idx is a catch clause.
bool isFilter(unsigned Idx) const
Return 'true' if the clause and index Idx is a filter clause.
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
static bool classof(const Value *V)
void setCleanup(bool V)
Indicate that this landingpad instruction is a cleanup.
void reserveClauses(unsigned Size)
Grow the size of the operand list to accommodate the new number of clauses.
static bool classof(const Instruction *I)
An instruction for reading from memory.
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
const Value * getPointerOperand() const
void setAlignment(Align Align)
Value * getPointerOperand()
bool isVolatile() const
Return true if this is a load from a volatile memory location.
static bool classof(const Instruction *I)
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this load instruction.
static bool classof(const Value *V)
void setSyncScopeID(SyncScope::ID SSID)
Sets the synchronization scope ID of this load instruction.
void setAtomic(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Sets the ordering constraint and the synchronization scope ID of this load instruction.
LoadInst * cloneImpl() const
AtomicOrdering getOrdering() const
Returns the ordering constraint of this load instruction.
Type * getPointerOperandType() const
static unsigned getPointerOperandIndex()
void setVolatile(bool V)
Specify whether this is a volatile load or not.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this load instruction.
Align getAlign() const
Return the alignment of the access that is being performed.
This class implements a map that also provides access to all stored values in a deterministic order.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
BasicBlock * getIncomingBlock(Value::const_user_iterator I) const
Return incoming basic block corresponding to value use iterator.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
bool isComplete() const
If the PHI node is complete which means all of its parent's predecessors have incoming value in this ...
iterator_range< const_block_iterator > blocks() const
op_range incoming_values()
static bool classof(const Value *V)
void allocHungoffUses(unsigned N)
const_block_iterator block_begin() const
void setIncomingValueForBlock(const BasicBlock *BB, Value *V)
Set every incoming value(s) for block BB to V.
void setIncomingBlock(unsigned i, BasicBlock *BB)
BasicBlock *const * const_block_iterator
void setIncomingValue(unsigned i, Value *V)
static unsigned getOperandNumForIncomingValue(unsigned i)
void copyIncomingBlocks(iterator_range< const_block_iterator > BBRange, uint32_t ToIdx=0)
Copies the basic blocks from BBRange to the incoming basic block list of this PHINode,...
const_block_iterator block_end() const
Value * getIncomingValueForBlock(const BasicBlock *BB) const
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
static unsigned getIncomingValueNumForOperand(unsigned i)
const_op_range incoming_values() const
Value * removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true)
void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New)
Replace every incoming basic block Old to basic block New.
BasicBlock * getIncomingBlock(const Use &U) const
Return incoming basic block corresponding to an operand of the PHI.
int getBasicBlockIndex(const BasicBlock *BB) const
Return the first index of the specified basic block in the value list for this PHI.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
Class to represent pointers.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
This class represents a cast from a pointer to an integer.
Value * getPointerOperand()
Gets the pointer operand.
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
static bool classof(const Value *V)
const Value * getPointerOperand() const
Gets the pointer operand.
static unsigned getPointerOperandIndex()
Gets the operand index of the pointer operand.
static bool classof(const Instruction *I)
PtrToIntInst * cloneImpl() const
Clone an identical PtrToIntInst.
Resume the propagation of an exception.
static ResumeInst * Create(Value *Exn, InsertPosition InsertBefore=nullptr)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
Value * getValue() const
Convenience accessor.
static bool classof(const Value *V)
unsigned getNumSuccessors() const
ResumeInst * cloneImpl() const
static bool classof(const Instruction *I)
Return a value (possibly void), from a function.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
unsigned getNumSuccessors() const
static bool classof(const Value *V)
static bool classof(const Instruction *I)
static ReturnInst * Create(LLVMContext &C, BasicBlock *InsertAtEnd)
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, InsertPosition InsertBefore=nullptr)
This class represents a sign extension of integer types.
static bool classof(const Value *V)
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
SExtInst * cloneImpl() const
Clone an identical SExtInst.
This class represents a cast from signed integer to floating point.
SIToFPInst * cloneImpl() const
Clone an identical SIToFPInst.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V)
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)
void setFalseValue(Value *V)
const Value * getFalseValue() const
void setTrueValue(Value *V)
OtherOps getOpcode() const
void swapValues()
Swap the true and false values of the select instruction.
const Value * getCondition() const
SelectInst * cloneImpl() const
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static const char * areInvalidOperands(Value *Cond, Value *True, Value *False)
Return a string if the specified operands are invalid for a select operation, otherwise return null.
static bool classof(const Value *V)
void setCondition(Value *V)
const Value * getTrueValue() const
static bool classof(const Instruction *I)
This instruction constructs a fixed permutation of two input vectors.
static bool classof(const Value *V)
static bool isInterleaveMask(ArrayRef< int > Mask, unsigned Factor, unsigned NumInputElts)
Constant * getShuffleMaskForBitcode() const
Return the mask for this instruction, for use in bitcode.
bool isSingleSource() const
Return true if this shuffle chooses elements from exactly one source vector without changing the leng...
bool changesLength() const
Return true if this shuffle returns a vector with a different number of elements than its source vect...
bool isExtractSubvectorMask(int &Index) const
Return true if this shuffle mask is an extract subvector mask.
ArrayRef< int > getShuffleMask() const
static bool isInsertSubvectorMask(const Constant *Mask, int NumSrcElts, int &NumSubElts, int &Index)
static bool isSingleSourceMask(const Constant *Mask, int NumSrcElts)
int getMaskValue(unsigned Elt) const
Return the shuffle mask value of this instruction for the given element index.
void getShuffleMask(SmallVectorImpl< int > &Result) const
Return the mask for this instruction as a vector of integers.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
static bool isDeInterleaveMaskOfFactor(ArrayRef< int > Mask, unsigned Factor)
VectorType * getType() const
Overload to return most specific vector type.
bool isInsertSubvectorMask(int &NumSubElts, int &Index) const
Return true if this shuffle mask is an insert subvector mask.
bool increasesLength() const
Return true if this shuffle returns a vector with a greater number of elements than its source vector...
bool isZeroEltSplat() const
Return true if all elements of this shuffle are the same value as the first element of exactly one so...
static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts, int &Index)
bool isSelect() const
Return true if this shuffle chooses elements from its source vectors without lane crossings and all o...
static bool isSpliceMask(const Constant *Mask, int NumSrcElts, int &Index)
bool isTranspose() const
Return true if this shuffle transposes the elements of its inputs without changing the length of the ...
static void commuteShuffleMask(MutableArrayRef< int > Mask, unsigned InVecNumElts)
Change values in a shuffle permute mask assuming the two vector operands of length InVecNumElts have ...
bool isSplice(int &Index) const
Return true if this shuffle splices two inputs without changing the length of the vectors.
static bool isReverseMask(const Constant *Mask, int NumSrcElts)
static bool isSelectMask(const Constant *Mask, int NumSrcElts)
static bool classof(const Instruction *I)
static bool isZeroEltSplatMask(const Constant *Mask, int NumSrcElts)
bool isIdentity() const
Return true if this shuffle chooses elements from exactly one source vector without lane crossings an...
static bool isReplicationMask(const Constant *Mask, int &ReplicationFactor, int &VF)
static bool isIdentityMask(const Constant *Mask, int NumSrcElts)
static bool isTransposeMask(const Constant *Mask, int NumSrcElts)
bool isReverse() const
Return true if this shuffle swaps the order of elements from exactly one source vector.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
static bool classof(const Instruction *I)
AtomicOrdering getOrdering() const
Returns the ordering constraint of this store instruction.
const Value * getPointerOperand() const
Type * getPointerOperandType() const
void setVolatile(bool V)
Specify whether this is a volatile store or not.
void setAlignment(Align Align)
const Value * getValueOperand() const
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this store instruction.
Value * getValueOperand()
static bool classof(const Value *V)
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
void setSyncScopeID(SyncScope::ID SSID)
Sets the synchronization scope ID of this store instruction.
StoreInst * cloneImpl() const
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
static unsigned getPointerOperandIndex()
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this store instruction.
bool isVolatile() const
Return true if this is a store to a volatile memory location.
Value * getPointerOperand()
void setAtomic(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Sets the ordering constraint and the synchronization scope ID of this store instruction.
StringRef - Represent a constant reference to a string, i.e.
A wrapper class to simplify modification of SwitchInst cases along with their prof branch_weights met...
void setSuccessorWeight(unsigned idx, CaseWeightOpt W)
Instruction::InstListType::iterator eraseFromParent()
Delegate the call to the underlying SwitchInst::eraseFromParent() and mark this object to not touch t...
void addCase(ConstantInt *OnVal, BasicBlock *Dest, CaseWeightOpt W)
Delegate the call to the underlying SwitchInst::addCase() and set the specified branch weight for the...
SwitchInstProfUpdateWrapper(SwitchInst &SI)
~SwitchInstProfUpdateWrapper()
CaseWeightOpt getSuccessorWeight(unsigned idx)
MDNode * buildProfBranchWeightsMD()
std::optional< uint32_t > CaseWeightOpt
SwitchInst * operator->()
SwitchInst::CaseIt removeCase(SwitchInst::CaseIt I)
Delegate the call to the underlying SwitchInst::removeCase() and remove correspondent branch weight.
A handle to a particular switch case.
unsigned getCaseIndex() const
Returns number of current case.
unsigned getSuccessorIndex() const
Returns successor index for current case successor.
BasicBlockT * getCaseSuccessor() const
Resolves successor for current case.
CaseHandleImpl(SwitchInstT *SI, ptrdiff_t Index)
bool operator==(const CaseHandleImpl &RHS) const
ConstantIntT * getCaseValue() const
Resolves case value for current case.
SwitchInstT SwitchInstType
CaseHandle(SwitchInst *SI, ptrdiff_t Index)
void setValue(ConstantInt *V) const
Sets the new value for current case.
void setSuccessor(BasicBlock *S) const
Sets the new successor for current case.
const CaseHandleT & operator*() const
CaseIteratorImpl()=default
Default constructed iterator is in an invalid state until assigned to a case for a particular switch.
CaseIteratorImpl & operator-=(ptrdiff_t N)
bool operator==(const CaseIteratorImpl &RHS) const
CaseIteratorImpl & operator+=(ptrdiff_t N)
ptrdiff_t operator-(const CaseIteratorImpl &RHS) const
bool operator<(const CaseIteratorImpl &RHS) const
CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum)
Initializes case iterator for given SwitchInst and for given case number.
static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI, unsigned SuccessorIndex)
Initializes case iterator for given SwitchInst and for given successor index.
BasicBlock * getDefaultDest() const
CaseIt case_end()
Returns a read/write iterator that points one past the last in the SwitchInst.
BasicBlock * getSuccessor(unsigned idx) const
ConstCaseIt findCaseValue(const ConstantInt *C) const
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
static SwitchInst * Create(Value *Value, BasicBlock *Default, unsigned NumCases, InsertPosition InsertBefore=nullptr)
void setCondition(Value *V)
ConstCaseIt case_begin() const
Returns a read-only iterator that points to the first case in the SwitchInst.
bool defaultDestUndefined() const
Returns true if the default branch must result in immediate undefined behavior, false otherwise.
iterator_range< ConstCaseIt > cases() const
Constant iteration adapter for range-for loops.
ConstantInt * findCaseDest(BasicBlock *BB)
Finds the unique case value for a given successor.
void setSuccessor(unsigned idx, BasicBlock *NewSucc)
static bool classof(const Value *V)
unsigned getNumSuccessors() const
CaseIt case_default()
Returns an iterator that points to the default case.
void setDefaultDest(BasicBlock *DefaultCase)
unsigned getNumCases() const
Return the number of 'cases' in this switch instruction, excluding the default case.
CaseIt findCaseValue(const ConstantInt *C)
Search all of the case values for the specified constant.
Value * getCondition() const
ConstCaseIt case_default() const
CaseIt case_begin()
Returns a read/write iterator that points to the first case in the SwitchInst.
static bool classof(const Instruction *I)
iterator_range< CaseIt > cases()
Iteration adapter for range-for loops.
ConstCaseIt case_end() const
Returns a read-only iterator that points one past the last in the SwitchInst.
This class represents a truncation of integer types.
void setHasNoSignedWrap(bool B)
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
TruncInst * cloneImpl() const
Clone an identical TruncInst.
void setHasNoUnsignedWrap(bool B)
unsigned getNoWrapKind() const
Returns the no-wrap kind of the operation.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property.
static bool classof(const Value *V)
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
bool isTokenTy() const
Return true if this is 'token'.
This class represents a cast unsigned integer to floating point.
static bool classof(const Value *V)
UIToFPInst * cloneImpl() const
Clone an identical UIToFPInst.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
This function has undefined behavior.
unsigned getNumSuccessors() const
static bool classof(const Value *V)
static bool classof(const Instruction *I)
A Use represents the edge between a Value definition and its users.
void allocHungoffUses(unsigned N, bool IsPhi=false)
Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User.
const Use & getOperandUse(unsigned i) const
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
static bool classof(const Instruction *I)
Value * getPointerOperand()
VAArgInst(Value *List, Type *Ty, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
const Value * getPointerOperand() const
static bool classof(const Value *V)
static unsigned getPointerOperandIndex()
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
user_iterator_impl< const User > const_user_iterator
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
void setName(const Twine &Name)
Change the name of the value.
Base class of all SIMD vector types.
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
This class represents zero extension of integer types.
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V)
ZExtInst * cloneImpl() const
Clone an identical ZExtInst.
An efficient, type-erasing, non-owning reference to a callable.
base_list_type::iterator iterator
CRTP base class for adapting an iterator to a different type.
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
@ C
The default llvm calling convention, compatible with C.
@ BasicBlock
Various leaf nodes.
@ System
Synchronized with respect to all concurrently executing threads.
This is an optimization pass for GlobalISel generic memory operations.
Type * checkGEPType(Type *Ty)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
APInt operator*(APInt a, uint64_t RHS)
unsigned getLoadStoreAddressSpace(Value *I)
A helper function that returns the address space of the pointer operand of load or store instruction.
const Value * getLoadStorePointerOperand(const Value *V)
A helper function that returns the pointer operand of a load or store instruction.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
const Value * getPointerOperand(const Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
std::optional< SyncScope::ID > getAtomicSyncScopeID(const Instruction *I)
A helper function that returns an atomic operation's sync scope; returns std::nullopt if it is not an...
Align getLoadStoreAlignment(Value *I)
A helper function that returns the alignment of load or store instruction.
constexpr int PoisonMaskElem
AtomicOrdering
Atomic ordering for LLVM's memory model.
DWARFExpression::Operation Op
OutputIt copy(R &&Range, OutputIt Out)
constexpr unsigned BitWidth
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
auto predecessors(const MachineBasicBlock *BB)
unsigned Log2(Align A)
Returns the log2 of the alignment.
@ Default
The result values are uniform if and only if all operands are uniform.
Type * getLoadStoreType(Value *I)
A helper function that returns the type of a load or store instruction.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Describes an element of a Bitfield.
static constexpr bool areContiguous()
The const version of succ_op_iterator.
const BasicBlock * operator->() const
const_succ_op_iterator(const_value_op_iterator I)
const BasicBlock * operator*() const
Iterator type that casts an operand to a basic block.
BasicBlock * operator->() const
succ_op_iterator(value_op_iterator I)
BasicBlock * operator*() const
Used to keep track of an operand bundle.
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
HungoffOperandTraits - determine the allocation regime of the Use array when it is not a prefix to th...
The const version of succ_op_iterator.
const BasicBlock * operator*() const
const_succ_op_iterator(const_value_op_iterator I)
const BasicBlock * operator->() const
Iterator type that casts an operand to a basic block.
BasicBlock * operator*() const
succ_op_iterator(value_op_iterator I)
BasicBlock * operator->() const
Compile-time customization of User operands.
Iterator for directly iterating over the operand Values.
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...