15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H
71 "Bitfields must be contiguous");
125 return Align(1ULL << getSubclassData<AlignmentField>());
129 setSubclassData<AlignmentField>(
Log2(
Align));
140 return getSubclassData<UsedWithInAllocaField>();
145 setSubclassData<UsedWithInAllocaField>(V);
149 bool isSwiftError()
const {
return getSubclassData<SwiftErrorField>(); }
155 return (
I->getOpcode() == Instruction::Alloca);
158 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
164 template <
typename Bitfield>
165 void setSubclassData(
typename Bitfield::Type
Value) {
166 Instruction::setSubclassData<Bitfield>(
Value);
181 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
182 "Bitfields must be contiguous");
205 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
212 return Align(1ULL << (getSubclassData<AlignmentField>()));
216 setSubclassData<AlignmentField>(
Log2(
Align));
221 return getSubclassData<OrderingField>();
226 setSubclassData<OrderingField>(Ordering);
267 return I->getOpcode() == Instruction::Load;
270 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
276 template <
typename Bitfield>
277 void setSubclassData(
typename Bitfield::Type
Value) {
278 Instruction::setSubclassData<Bitfield>(
Value);
297 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
298 "Bitfields must be contiguous");
321 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
322 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
325 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
334 return Align(1ULL << (getSubclassData<AlignmentField>()));
338 setSubclassData<AlignmentField>(
Log2(
Align));
343 return getSubclassData<OrderingField>();
349 setSubclassData<OrderingField>(Ordering);
393 return I->getOpcode() == Instruction::Store;
396 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
402 template <
typename Bitfield>
403 void setSubclassData(
typename Bitfield::Type
Value) {
404 Instruction::setSubclassData<Bitfield>(
Value);
445 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
446 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
450 return getSubclassData<OrderingField>();
456 setSubclassData<OrderingField>(Ordering);
471 return I->getOpcode() == Instruction::Fence;
474 return isa<Instruction>(V) && classof(cast<Instruction>(V));
480 template <
typename Bitfield>
481 void setSubclassData(
typename Bitfield::Type
Value) {
482 Instruction::setSubclassData<Bitfield>(
Value);
506 template <
unsigned Offset>
507 using AtomicOrderingBitfieldElement =
526 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
527 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
540 "Bitfields must be contiguous");
545 return Align(1ULL << getSubclassData<AlignmentField>());
549 setSubclassData<AlignmentField>(
Log2(
Align));
555 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
562 bool isWeak()
const {
return getSubclassData<WeakField>(); }
564 void setWeak(
bool IsWeak) { setSubclassData<WeakField>(IsWeak); }
583 return getSubclassData<SuccessOrderingField>();
589 "invalid CmpXchg success ordering");
590 setSubclassData<SuccessOrderingField>(Ordering);
595 return getSubclassData<FailureOrderingField>();
601 "invalid CmpXchg failure ordering");
602 setSubclassData<FailureOrderingField>(Ordering);
653 switch (SuccessOrdering) {
669 return I->getOpcode() == Instruction::AtomicCmpXchg;
672 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
678 template <
typename Bitfield>
679 void setSubclassData(
typename Bitfield::Type
Value) {
680 Instruction::setSubclassData<Bitfield>(
Value);
771 LAST_BINOP = USubSat,
776 template <
unsigned Offset>
777 using AtomicOrderingBitfieldElement =
781 template <
unsigned Offset>
782 using BinOpBitfieldElement =
785 constexpr static IntrusiveOperandsAllocMarker AllocMarker{2};
790 InsertPosition InsertBefore =
nullptr);
793 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
794 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
803 "Bitfields must be contiguous");
822 setSubclassData<OperationField>(
Operation);
828 return Align(1ULL << getSubclassData<AlignmentField>());
832 setSubclassData<AlignmentField>(
Log2(
Align));
837 bool isVolatile()
const {
return getSubclassData<VolatileField>(); }
848 return getSubclassData<AtomicOrderingField>();
854 "atomicrmw instructions can only be atomic.");
856 "atomicrmw instructions cannot be unordered.");
857 setSubclassData<AtomicOrderingField>(Ordering);
883 return isFPOperation(getOperation());
888 return I->getOpcode() == Instruction::AtomicRMW;
891 return isa<Instruction>(V) && classof(cast<Instruction>(V));
900 template <
typename Bitfield>
901 void setSubclassData(
typename Bitfield::Type
Value) {
902 Instruction::setSubclassData<Bitfield>(
Value);
926 assert(Ty &&
"Invalid GetElementPtrInst indices for type!");
934 Type *SourceElementType;
935 Type *ResultElementType;
958 const Twine &NameStr =
"",
961 assert(PointeeType &&
"Must specify element type");
964 PointeeType,
Ptr, IdxList, AllocMarker, NameStr, InsertBefore);
969 const Twine &NameStr =
"",
972 Create(PointeeType,
Ptr, IdxList, NameStr, InsertBefore);
973 GEP->setNoWrapFlags(NW);
981 const Twine &NameStr =
"",
984 NameStr, InsertBefore);
996 return ResultElementType;
1066 if (
auto *IndexVTy = dyn_cast<VectorType>(
Index->getType())) {
1123 APInt &ConstantOffset)
const;
1126 return (
I->getOpcode() == Instruction::GetElementPtr);
1129 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1137GetElementPtrInst::GetElementPtrInst(
Type *PointeeType,
Value *
Ptr,
1143 SourceElementType(PointeeType),
1144 ResultElementType(getIndexedType(PointeeType, IdxList)) {
1145 init(
Ptr, IdxList, NameStr);
1160 assert(isIntPredicate() &&
1161 "Invalid ICmp predicate value");
1163 "Both operands to ICmp instruction are not of the same type!");
1166 getOperand(0)->
getType()->isPtrOrPtrVectorTy()) &&
1167 "Invalid operand types for ICmp instruction");
1170 enum { SameSign = (1 << 0) };
1185 const Twine &NameStr =
""
1188 RHS, NameStr, InsertBefore) {
1199 const Twine &NameStr =
""
1209 return {getPredicate(), hasSameSign()};
1215 return {getInversePredicate(Pred), Pred.
hasSameSign()};
1220 return getInverseCmpPredicate(getCmpPredicate());
1226 return {getSwappedPredicate(Pred), Pred.
hasSameSign()};
1231 return getSwappedCmpPredicate(getCmpPredicate());
1239 return getSignedPredicate(getPredicate());
1243 static Predicate getSignedPredicate(Predicate Pred);
1250 return getUnsignedPredicate(getPredicate());
1254 static Predicate getUnsignedPredicate(Predicate Pred);
1260 static Predicate getFlippedSignednessPredicate(Predicate Pred);
1266 return getFlippedSignednessPredicate(getPredicate());
1271 static std::optional<bool> isImpliedByMatchingCmp(
CmpPredicate Pred1,
1275 SubclassOptionalData = (SubclassOptionalData & ~SameSign) | (
B * SameSign);
1286 return P == ICMP_EQ ||
P == ICMP_NE;
1292 return isEquality(getPredicate());
1306 return !isEquality();
1312 return !isEquality(
P);
1318 return P == ICMP_SGT ||
P == ICMP_UGT;
1324 return P == ICMP_SLT ||
P == ICMP_ULT;
1330 return P == ICMP_SGE ||
P == ICMP_UGE;
1336 return P == ICMP_SLE ||
P == ICMP_ULE;
1349 setPredicate(getSwappedPredicate());
1364 return I->getOpcode() == Instruction::ICmp;
1367 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1383 "Both operands to FCmp instruction are not of the same type!");
1386 "Invalid operand types for FCmp instruction");
1402 const Twine &NameStr =
""
1405 RHS, NameStr, InsertBefore) {
1413 const Twine &NameStr =
"",
1416 RHS, NameStr, nullptr, FlagsSource) {
1466 return I->getOpcode() == Instruction::FCmp;
1469 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1500 static unsigned ComputeNumOperands(
unsigned NumArgs,
1501 unsigned NumBundleInputs = 0) {
1504 return 1 + NumArgs + NumBundleInputs;
1517 return new (AllocMarker)
1518 CallInst(Ty,
F, NameStr, AllocMarker, InsertBefore);
1522 const Twine &NameStr,
1525 return new (AllocMarker)
1526 CallInst(Ty, Func, Args, {}, NameStr, AllocMarker, InsertBefore);
1531 const Twine &NameStr =
"",
1533 IntrusiveOperandsAndDescriptorAllocMarker AllocMarker{
1537 return new (AllocMarker)
1538 CallInst(Ty, Func, Args, Bundles, NameStr, AllocMarker, InsertBefore);
1543 return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
1549 const Twine &NameStr =
"",
1551 return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
1552 NameStr, InsertBefore);
1556 const Twine &NameStr,
1558 return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
1582 Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
1583 "Bitfields must be contiguous");
1586 return getSubclassData<TailCallKindField>();
1599 setSubclassData<TailCallKindField>(TCK);
1613 case Intrinsic::trap:
1614 case Intrinsic::ubsantrap:
1623 return I->getOpcode() == Instruction::Call;
1626 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1635 template <
typename Bitfield>
1636 void setSubclassData(
typename Bitfield::Type
Value) {
1637 Instruction::setSubclassData<Bitfield>(
Value);
1641CallInst::CallInst(
FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1642 ArrayRef<OperandBundleDef> Bundles,
const Twine &NameStr,
1643 AllocInfo AllocInfo, InsertPosition InsertBefore)
1644 : CallBase(Ty->getReturnType(), Instruction::
Call, AllocInfo,
1646 assert(AllocInfo.NumOps ==
1648 init(Ty, Func, Args, Bundles, NameStr);
1662 :
Instruction(
S1->getType(), Instruction::Select, AllocMarker,
1683 const Twine &NameStr =
"",
1687 new (AllocMarker)
SelectInst(
C,
S1, S2, NameStr, InsertBefore);
1721 return I->getOpcode() == Instruction::Select;
1724 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1761 return I->getOpcode() == VAArg;
1764 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1789 const Twine &NameStr =
"",
1791 return new (AllocMarker)
1813 return I->getOpcode() == Instruction::ExtractElement;
1816 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
1838 const Twine &NameStr =
"",
1849 const Twine &NameStr =
"",
1851 return new (AllocMarker)
1857 static bool isValidOperands(
const Value *Vec,
const Value *NewElt,
1871 return I->getOpcode() == Instruction::InsertElement;
1874 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1919 const Twine &NameStr =
"",
1922 const Twine &NameStr =
"",
1925 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
1926 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
1934 static bool isValidOperands(
const Value *V1,
const Value *V2,
1936 static bool isValidOperands(
const Value *V1,
const Value *V2,
1954 static void getShuffleMask(
const Constant *Mask,
1960 Result.assign(ShuffleMask.
begin(), ShuffleMask.
end());
1981 unsigned NumSourceElts = cast<VectorType>(
Op<0>()->
getType())
1983 .getKnownMinValue();
1984 unsigned NumMaskElts = ShuffleMask.
size();
1985 return NumSourceElts != NumMaskElts;
1992 unsigned NumSourceElts = cast<VectorType>(
Op<0>()->
getType())
1994 .getKnownMinValue();
1995 unsigned NumMaskElts = ShuffleMask.
size();
1996 return NumSourceElts < NumMaskElts;
2004 static bool isSingleSourceMask(
ArrayRef<int> Mask,
int NumSrcElts);
2006 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2008 getShuffleMask(Mask, MaskAsInts);
2009 return isSingleSourceMask(MaskAsInts, NumSrcElts);
2017 return !changesLength() &&
2018 isSingleSourceMask(ShuffleMask, ShuffleMask.
size());
2026 static bool isIdentityMask(
ArrayRef<int> Mask,
int NumSrcElts);
2028 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2032 if (isa<ScalableVectorType>(Mask->getType()))
2036 getShuffleMask(Mask, MaskAsInts);
2037 return isIdentityMask(MaskAsInts, NumSrcElts);
2047 if (isa<ScalableVectorType>(
getType()))
2050 return !changesLength() && isIdentityMask(ShuffleMask, ShuffleMask.
size());
2055 bool isIdentityWithPadding()
const;
2059 bool isIdentityWithExtract()
const;
2064 bool isConcat()
const;
2074 static bool isSelectMask(
ArrayRef<int> Mask,
int NumSrcElts);
2076 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2078 getShuffleMask(Mask, MaskAsInts);
2079 return isSelectMask(MaskAsInts, NumSrcElts);
2091 return !changesLength() && isSelectMask(ShuffleMask, ShuffleMask.
size());
2101 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2103 getShuffleMask(Mask, MaskAsInts);
2120 static bool isZeroEltSplatMask(
ArrayRef<int> Mask,
int NumSrcElts);
2122 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2124 getShuffleMask(Mask, MaskAsInts);
2125 return isZeroEltSplatMask(MaskAsInts, NumSrcElts);
2135 return !changesLength() &&
2136 isZeroEltSplatMask(ShuffleMask, ShuffleMask.
size());
2171 static bool isTransposeMask(
ArrayRef<int> Mask,
int NumSrcElts);
2173 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2175 getShuffleMask(Mask, MaskAsInts);
2176 return isTransposeMask(MaskAsInts, NumSrcElts);
2185 return !changesLength() && isTransposeMask(ShuffleMask, ShuffleMask.
size());
2196 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2198 getShuffleMask(Mask, MaskAsInts);
2199 return isSpliceMask(MaskAsInts, NumSrcElts,
Index);
2207 return !changesLength() &&
2208 isSpliceMask(ShuffleMask, ShuffleMask.
size(),
Index);
2214 static bool isExtractSubvectorMask(
ArrayRef<int> Mask,
int NumSrcElts,
2218 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2221 if (isa<ScalableVectorType>(Mask->getType()))
2224 getShuffleMask(Mask, MaskAsInts);
2225 return isExtractSubvectorMask(MaskAsInts, NumSrcElts,
Index);
2232 if (isa<ScalableVectorType>(
getType()))
2236 cast<FixedVectorType>(
Op<0>()->
getType())->getNumElements();
2237 return isExtractSubvectorMask(ShuffleMask, NumSrcElts,
Index);
2244 static bool isInsertSubvectorMask(
ArrayRef<int> Mask,
int NumSrcElts,
2245 int &NumSubElts,
int &
Index);
2247 int &NumSubElts,
int &
Index) {
2248 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2251 if (isa<ScalableVectorType>(Mask->getType()))
2254 getShuffleMask(Mask, MaskAsInts);
2255 return isInsertSubvectorMask(MaskAsInts, NumSrcElts, NumSubElts,
Index);
2262 if (isa<ScalableVectorType>(
getType()))
2266 cast<FixedVectorType>(
Op<0>()->
getType())->getNumElements();
2267 return isInsertSubvectorMask(ShuffleMask, NumSrcElts, NumSubElts,
Index);
2274 static bool isReplicationMask(
ArrayRef<int> Mask,
int &ReplicationFactor,
2278 assert(Mask->getType()->isVectorTy() &&
"Shuffle needs vector constant.");
2281 if (isa<ScalableVectorType>(Mask->getType()))
2284 getShuffleMask(Mask, MaskAsInts);
2285 return isReplicationMask(MaskAsInts, ReplicationFactor, VF);
2289 bool isReplicationMask(
int &ReplicationFactor,
int &VF)
const;
2300 static bool isOneUseSingleSourceMask(
ArrayRef<int> Mask,
int VF);
2304 bool isOneUseSingleSourceMask(
int VF)
const;
2309 unsigned InVecNumElts) {
2310 for (
int &
Idx : Mask) {
2313 Idx =
Idx < (int)InVecNumElts ?
Idx + InVecNumElts :
Idx - InVecNumElts;
2315 "shufflevector mask index out of range");
2320 bool isInterleave(
unsigned Factor);
2341 static bool isInterleaveMask(
ArrayRef<int> Mask,
unsigned Factor,
2342 unsigned NumInputElts,
2345 unsigned NumInputElts) {
2347 return isInterleaveMask(Mask, Factor, NumInputElts, StartIndexes);
2353 static bool isDeInterleaveMaskOfFactor(
ArrayRef<int> Mask,
unsigned Factor,
2357 return isDeInterleaveMaskOfFactor(Mask, Factor, Unused);
2371 static bool isBitRotateMask(
ArrayRef<int> Mask,
unsigned EltSizeInBits,
2372 unsigned MinSubElts,
unsigned MaxSubElts,
2373 unsigned &NumSubElts,
unsigned &RotateAmt);
2377 return I->getOpcode() == Instruction::ShuffleVector;
2380 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2419 const Twine &NameStr =
"",
2440 return getOperand(0);
2443 return getOperand(0);
2454 return (
unsigned)Indices.
size();
2463 return I->getOpcode() == Instruction::ExtractValue;
2466 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2470ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
2471 const Twine &NameStr,
2472 InsertPosition InsertBefore)
2474 ExtractValue, Agg, InsertBefore) {
2475 init(Idxs, NameStr);
2502 const Twine &NameStr =
"",
2506 const Twine &NameStr);
2516 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
2517 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
2521 const Twine &NameStr =
"",
2562 return (
unsigned)Indices.
size();
2571 return I->getOpcode() == Instruction::InsertValue;
2574 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
2583InsertValueInst::InsertValueInst(
Value *Agg,
Value *Val,
2587 init(Agg, Val, Idxs, NameStr);
2605 unsigned ReservedSpace;
2609 explicit PHINode(
Type *Ty,
unsigned NumReservedValues,
2610 const Twine &NameStr =
"",
2612 :
Instruction(Ty, Instruction::PHI, AllocMarker, InsertBefore),
2613 ReservedSpace(NumReservedValues) {
2616 allocHungoffUses(ReservedSpace);
2636 const Twine &NameStr =
"",
2638 return new (AllocMarker)
2639 PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
2658 return block_begin() + getNumOperands();
2662 return make_range(block_begin(), block_end());
2676 return getOperand(i);
2679 assert(V &&
"PHI node got a null value!");
2681 "All operands to PHI node must be the same type as the PHI node!");
2696 return block_begin()[i];
2703 assert(
this == U.getUser() &&
"Iterator doesn't point to PHI's Uses?");
2704 return getIncomingBlock(
unsigned(&U - op_begin()));
2711 return getIncomingBlock(
I.getUse());
2727 assert(New && Old &&
"PHI node got a null basic block!");
2728 for (
unsigned Op = 0, NumOps = getNumOperands();
Op != NumOps; ++
Op)
2729 if (getIncomingBlock(
Op) == Old)
2730 setIncomingBlock(
Op, New);
2736 if (getNumOperands() == ReservedSpace)
2739 setNumHungOffUseOperands(getNumOperands() + 1);
2740 setIncomingValue(getNumOperands() - 1, V);
2741 setIncomingBlock(getNumOperands() - 1, BB);
2752 Value *removeIncomingValue(
unsigned Idx,
bool DeletePHIIfEmpty =
true);
2755 int Idx = getBasicBlockIndex(BB);
2756 assert(
Idx >= 0 &&
"Invalid basic block argument to remove!");
2757 return removeIncomingValue(
Idx, DeletePHIIfEmpty);
2762 void removeIncomingValueIf(
function_ref<
bool(
unsigned)> Predicate,
2763 bool DeletePHIIfEmpty =
true);
2769 for (
unsigned i = 0, e = getNumOperands(); i != e; ++i)
2770 if (block_begin()[i] == BB)
2776 int Idx = getBasicBlockIndex(BB);
2777 assert(
Idx >= 0 &&
"Invalid basic block argument!");
2778 return getIncomingValue(
Idx);
2783 assert(BB &&
"PHI node got a null basic block!");
2785 for (
unsigned Op = 0, NumOps = getNumOperands();
Op != NumOps; ++
Op)
2786 if (getIncomingBlock(
Op) == BB) {
2788 setIncomingValue(
Op, V);
2791 assert(Found &&
"Invalid basic block argument to set!");
2796 Value *hasConstantValue()
const;
2801 bool hasConstantOrUndefValue()
const;
2808 return getBasicBlockIndex(Pred) >= 0;
2814 return I->getOpcode() == Instruction::PHI;
2817 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2821 void growOperands();
2847 unsigned ReservedSpace;
2859 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
2861 void growOperands(
unsigned Size);
2862 void init(
unsigned NumReservedValues,
const Twine &NameStr);
2871 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
2876 const Twine &NameStr =
"",
2885 bool isCleanup()
const {
return getSubclassData<CleanupField>(); }
2896 return cast<Constant>(getOperandList()[
Idx]);
2901 return !isa<ArrayType>(getOperandList()[
Idx]->
getType());
2906 return isa<ArrayType>(getOperandList()[
Idx]->
getType());
2918 return I->getOpcode() == Instruction::LandingPad;
2921 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2968 return new (AllocMarker)
ReturnInst(
C, retVal, AllocMarker, InsertBefore);
2973 return new (AllocMarker)
ReturnInst(
C,
nullptr, AllocMarker, InsertAtEnd);
2981 return getNumOperands() != 0 ? getOperand(0) :
nullptr;
2988 return (
I->getOpcode() == Instruction::Ret);
2991 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2995 BasicBlock *getSuccessor(
unsigned idx)
const {
2999 void setSuccessor(
unsigned idx, BasicBlock *
B) {
3051 std::random_access_iterator_tag, BasicBlock *,
3052 ptrdiff_t, BasicBlock *, BasicBlock *> {
3062 std::random_access_iterator_tag,
3063 const BasicBlock *, ptrdiff_t, const BasicBlock *,
3064 const BasicBlock *> {
3075 return new (AllocMarker)
BranchInst(IfTrue, AllocMarker, InsertBefore);
3082 return new (AllocMarker)
3093 assert(isConditional() &&
"Cannot get condition of an uncond branch!");
3098 assert(isConditional() &&
"Cannot set condition of unconditional branch!");
3105 assert(i < getNumSuccessors() &&
"Successor # out of range for Branch!");
3106 return cast_or_null<BasicBlock>((&
Op<-1>() - i)->
get());
3110 assert(idx < getNumSuccessors() &&
"Successor # out of range for Branch!");
3111 *(&
Op<-1>() - idx) = NewSucc;
3119 void swapSuccessors();
3129 std::next(value_op_begin(), isConditional() ? 1 : 0)),
3135 return (
I->getOpcode() == Instruction::Br);
3138 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3157 unsigned ReservedSpace;
3173 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
3176 void growOperands();
3185 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
3188 static const unsigned DefaultPseudoIndex =
static_cast<unsigned>(~0L-1);
3197 template <
typename SwitchInstT,
typename ConstantIntT,
typename BasicBlockT>
3216 assert((
unsigned)Index < SI->getNumCases() &&
3217 "Index out the number of cases.");
3218 return reinterpret_cast<ConstantIntT *
>(
SI->getOperand(2 +
Index * 2));
3223 assert(((
unsigned)Index < SI->getNumCases() ||
3224 (
unsigned)
Index == DefaultPseudoIndex) &&
3225 "Index out the number of cases.");
3226 return SI->getSuccessor(getSuccessorIndex());
3235 (
unsigned)Index < SI->getNumCases()) &&
3236 "Index out the number of cases.");
3237 return (
unsigned)
Index != DefaultPseudoIndex ?
Index + 1 : 0;
3241 assert(
SI ==
RHS.SI &&
"Incompatible operators.");
3258 assert((
unsigned)Index < SI->getNumCases() &&
3259 "Index out the number of cases.");
3260 SI->setOperand(2 +
Index*2,
reinterpret_cast<Value*
>(V));
3265 SI->setSuccessor(getSuccessorIndex(), S);
3269 template <
typename CaseHandleT>
3272 std::random_access_iterator_tag,
3273 const CaseHandleT> {
3274 using SwitchInstT =
typename CaseHandleT::SwitchInstType;
3290 unsigned SuccessorIndex) {
3291 assert(SuccessorIndex < SI->getNumSuccessors() &&
3292 "Successor index # out of range!");
3307 (
unsigned)(Case.Index +
N) <= Case.SI->getNumCases() &&
3308 "Case.Index out the number of cases.");
3316 (
unsigned)(Case.Index -
N) <= Case.SI->getNumCases() &&
3317 "Case.Index out the number of cases.");
3322 assert(Case.SI ==
RHS.Case.SI &&
"Incompatible operators.");
3323 return Case.Index -
RHS.Case.Index;
3326 return Case ==
RHS.Case;
3329 assert(Case.SI ==
RHS.Case.SI &&
"Incompatible operators.");
3330 return Case.Index <
RHS.Case.Index;
3352 return cast<BasicBlock>(getOperand(1));
3358 return isa<UnreachableInst>(getDefaultDest()->getFirstNonPHIOrDbg());
3362 setOperand(1,
reinterpret_cast<Value*
>(DefaultCase));
3368 return getNumOperands()/2 - 1;
3386 return CaseIt(
this, getNumCases());
3411 return CaseIt(
this, DefaultPseudoIndex);
3424 const_cast<const SwitchInst *
>(
this)->findCaseValue(
C)->getCaseIndex());
3430 if (
I != case_end())
3433 return case_default();
3439 if (BB == getDefaultDest())
3443 for (
auto Case : cases()) {
3444 if (Case.getCaseSuccessor() != BB)
3450 CI = Case.getCaseValue();
3469 CaseIt removeCase(CaseIt
I);
3473 assert(idx < getNumSuccessors() &&
"Successor idx out of range for switch!");
3474 return cast<BasicBlock>(getOperand(idx*2+1));
3477 assert(idx < getNumSuccessors() &&
"Successor # out of range for switch!");
3478 setOperand(idx * 2 + 1, NewSucc);
3483 return I->getOpcode() == Instruction::Switch;
3486 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3494 std::optional<SmallVector<uint32_t, 8>> Weights;
3495 bool Changed =
false;
3547 unsigned ReservedSpace;
3561 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
3564 void growOperands();
3573 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
3581 std::random_access_iterator_tag, BasicBlock *,
3582 ptrdiff_t, BasicBlock *, BasicBlock *> {
3592 std::random_access_iterator_tag,
3593 const BasicBlock *, ptrdiff_t, const BasicBlock *,
3594 const BasicBlock *> {
3629 void removeDestination(
unsigned i);
3633 return cast<BasicBlock>(getOperand(i+1));
3636 setOperand(i + 1, NewSucc);
3651 return I->getOpcode() == Instruction::IndirectBr;
3654 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3673 static constexpr int NumExtraOperands = 2;
3676 static constexpr int NormalDestOpEndIdx = -3;
3679 static constexpr int UnwindDestOpEndIdx = -2;
3696 static unsigned ComputeNumOperands(
unsigned NumArgs,
3697 size_t NumBundleInputs = 0) {
3700 return 1 + NumExtraOperands + NumArgs +
unsigned(NumBundleInputs);
3712 const Twine &NameStr,
3715 ComputeNumOperands(
unsigned(Args.size()))};
3716 return new (AllocMarker)
InvokeInst(Ty, Func, IfNormal, IfException, Args,
3717 {}, AllocMarker, NameStr, InsertBefore);
3723 const Twine &NameStr =
"",
3725 IntrusiveOperandsAndDescriptorAllocMarker AllocMarker{
3726 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)),
3729 return new (AllocMarker)
3730 InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, AllocMarker,
3731 NameStr, InsertBefore);
3736 const Twine &NameStr,
3738 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3739 IfException, Args, {}, NameStr, InsertBefore);
3745 const Twine &NameStr =
"",
3747 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3748 IfException, Args, Bundles, NameStr, InsertBefore);
3757 static InvokeInst *Create(InvokeInst *
II, ArrayRef<OperandBundleDef> Bundles,
3758 InsertPosition InsertPt =
nullptr);
3779 assert(i < 2 &&
"Successor # out of range for invoke!");
3780 return i == 0 ? getNormalDest() : getUnwindDest();
3784 assert(i < 2 &&
"Successor # out of range for invoke!");
3786 setNormalDest(NewSucc);
3788 setUnwindDest(NewSucc);
3798 return (
I->getOpcode() == Instruction::Invoke);
3801 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3807 template <
typename Bitfield>
3808 void setSubclassData(
typename Bitfield::Type
Value) {
3809 Instruction::setSubclassData<Bitfield>(
Value);
3813InvokeInst::InvokeInst(
FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3814 BasicBlock *IfException, ArrayRef<Value *> Args,
3815 ArrayRef<OperandBundleDef> Bundles, AllocInfo AllocInfo,
3816 const Twine &NameStr, InsertPosition InsertBefore)
3817 : CallBase(Ty->getReturnType(), Instruction::Invoke, AllocInfo,
3819 init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
3832 unsigned NumIndirectDests;
3850 static unsigned ComputeNumOperands(
int NumArgs,
int NumIndirectDests,
3851 int NumBundleInputs = 0) {
3854 return unsigned(2 + NumIndirectDests + NumArgs + NumBundleInputs);
3870 ComputeNumOperands(Args.size(), IndirectDests.
size())};
3871 return new (AllocMarker)
3872 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, {}, AllocMarker,
3873 NameStr, InsertBefore);
3881 IntrusiveOperandsAndDescriptorAllocMarker AllocMarker{
3882 ComputeNumOperands(Args.size(), IndirectDests.
size(),
3886 return new (AllocMarker)
3887 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
3888 AllocMarker, NameStr, InsertBefore);
3895 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
3896 IndirectDests, Args, NameStr, InsertBefore);
3903 const Twine &NameStr =
"",
3905 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
3906 IndirectDests, Args, Bundles, NameStr, InsertBefore);
3915 static CallBrInst *
Create(CallBrInst *CBI, ArrayRef<OperandBundleDef> Bundles,
3916 InsertPosition InsertBefore =
nullptr);
3945 return IndirectDests;
3956 "Successor # out of range for callbr!");
3962 "Successor # out of range for callbr!");
3970 return (
I->getOpcode() == Instruction::CallBr);
3973 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
3979 template <
typename Bitfield>
3980 void setSubclassData(
typename Bitfield::Type
Value) {
3981 Instruction::setSubclassData<Bitfield>(
Value);
3985CallBrInst::CallBrInst(
FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
3986 ArrayRef<BasicBlock *> IndirectDests,
3987 ArrayRef<Value *> Args,
3988 ArrayRef<OperandBundleDef> Bundles, AllocInfo AllocInfo,
3989 const Twine &NameStr, InsertPosition InsertBefore)
3990 : CallBase(Ty->getReturnType(), Instruction::CallBr, AllocInfo,
3992 init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4017 return new (AllocMarker)
ResumeInst(Exn, InsertBefore);
4030 return I->getOpcode() == Instruction::Resume;
4033 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4037 BasicBlock *getSuccessor(
unsigned idx)
const {
4041 void setSuccessor(
unsigned idx,
BasicBlock *NewSucc) {
4063 unsigned ReservedSpace;
4075 unsigned NumHandlers,
const Twine &NameStr,
4079 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
4081 void init(
Value *ParentPad,
BasicBlock *UnwindDest,
unsigned NumReserved);
4082 void growOperands(
unsigned Size);
4091 void operator delete(
void *
Ptr) {
return User::operator
delete(
Ptr); }
4094 unsigned NumHandlers,
4095 const Twine &NameStr =
"",
4097 return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
4112 if (hasUnwindDest())
4113 return cast<BasicBlock>(getOperand(1));
4119 setOperand(1, UnwindDest);
4125 if (hasUnwindDest())
4126 return getNumOperands() - 2;
4127 return getNumOperands() - 1;
4131 static BasicBlock *handler_helper(
Value *V) {
return cast<BasicBlock>(V); }
4132 static const BasicBlock *handler_helper(
const Value *V) {
4133 return cast<BasicBlock>(V);
4148 if (hasUnwindDest())
4157 if (hasUnwindDest())
4176 return make_range(handler_begin(), handler_end());
4181 return make_range(handler_begin(), handler_end());
4190 void removeHandler(handler_iterator HI);
4195 "Successor # out of range for catchswitch!");
4196 return cast<BasicBlock>(getOperand(
Idx + 1));
4200 "Successor # out of range for catchswitch!");
4201 setOperand(
Idx + 1, NewSucc);
4206 return I->getOpcode() == Instruction::CatchSwitch;
4209 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4227 NameStr, InsertBefore) {}
4231 const Twine &NameStr =
"",
4233 IntrusiveOperandsAllocMarker AllocMarker{
unsigned(1 + Args.size())};
4234 return new (AllocMarker)
4235 CleanupPadInst(ParentPad, Args, AllocMarker, NameStr, InsertBefore);
4240 return I->getOpcode() == Instruction::CleanupPad;
4243 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4256 NameStr, InsertBefore) {}
4260 const Twine &NameStr =
"",
4263 return new (AllocMarker)
4264 CatchPadInst(CatchSwitch, Args, AllocMarker, NameStr, InsertBefore);
4269 return cast<CatchSwitchInst>(
Op<-1>());
4273 Op<-1>() = CatchSwitch;
4278 return I->getOpcode() == Instruction::CatchPad;
4281 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4336 return (
I->getOpcode() == Instruction::CatchRet);
4339 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4385 unsigned Values = 1;
4389 return new (AllocMarker)
4401 return cast<CleanupPadInst>(
Op<0>());
4405 Op<0>() = CleanupPad;
4411 return hasUnwindDest() ? cast<BasicBlock>(
Op<1>()) :
nullptr;
4421 return (
I->getOpcode() == Instruction::CleanupRet);
4424 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4430 return getUnwindDest();
4433 void setSuccessor(
unsigned Idx, BasicBlock *
B) {
4440 template <
typename Bitfield>
4441 void setSubclassData(
typename Bitfield::Type Value) {
4442 Instruction::setSubclassData<Bitfield>(Value);
4475 void *
operator new(
size_t S) {
return User::operator
new(S, AllocMarker); }
4476 void operator delete(
void *
Ptr) { User::operator
delete(
Ptr); }
4482 return I->getOpcode() == Instruction::Unreachable;
4485 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4489 BasicBlock *getSuccessor(
unsigned idx)
const {
4493 void setSuccessor(
unsigned idx, BasicBlock *
B) {
4517 const Twine &NameStr =
"",
4524 return I->getOpcode() == Trunc;
4527 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4553 unsigned NoWrapKind = 0;
4581 const Twine &NameStr =
"",
4588 return I->getOpcode() == ZExt;
4591 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4612 const Twine &NameStr =
"",
4619 return I->getOpcode() == SExt;
4622 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4642 const Twine &NameStr =
"",
4649 return I->getOpcode() == FPTrunc;
4652 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4673 const Twine &NameStr =
"",
4680 return I->getOpcode() == FPExt;
4683 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4704 const Twine &NameStr =
"",
4711 return I->getOpcode() == UIToFP;
4714 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4735 const Twine &NameStr =
"",
4742 return I->getOpcode() == SIToFP;
4745 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4766 const Twine &NameStr =
"",
4773 return I->getOpcode() == FPToUI;
4776 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4797 const Twine &NameStr =
"",
4804 return I->getOpcode() == FPToSI;
4807 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4824 const Twine &NameStr =
"",
4839 return I->getOpcode() == IntToPtr;
4842 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4863 const Twine &NameStr =
"",
4882 return I->getOpcode() == PtrToInt;
4885 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4906 const Twine &NameStr =
"",
4913 return I->getOpcode() == BitCast;
4916 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4939 const Twine &NameStr =
"",
4946 return I->getOpcode() == AddrSpaceCast;
4949 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
4985 if (
auto *Load = dyn_cast<LoadInst>(V))
4986 return Load->getPointerOperand();
4987 if (
auto *Store = dyn_cast<StoreInst>(V))
4988 return Store->getPointerOperand();
4992 return const_cast<Value *
>(
5001 if (
auto *Gep = dyn_cast<GetElementPtrInst>(V))
5002 return Gep->getPointerOperand();
5011 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
5012 "Expected Load or Store instruction");
5013 if (
auto *LI = dyn_cast<LoadInst>(
I))
5014 return LI->getAlign();
5015 return cast<StoreInst>(
I)->getAlign();
5020 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
5021 "Expected Load or Store instruction");
5022 if (
auto *LI = dyn_cast<LoadInst>(
I))
5023 LI->setAlignment(NewAlign);
5025 cast<StoreInst>(
I)->setAlignment(NewAlign);
5031 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
5032 "Expected Load or Store instruction");
5033 if (
auto *LI = dyn_cast<LoadInst>(
I))
5034 return LI->getPointerAddressSpace();
5035 return cast<StoreInst>(
I)->getPointerAddressSpace();
5040 assert((isa<LoadInst>(
I) || isa<StoreInst>(
I)) &&
5041 "Expected Load or Store instruction");
5042 if (
auto *LI = dyn_cast<LoadInst>(
I))
5043 return LI->getType();
5044 return cast<StoreInst>(
I)->getValueOperand()->getType();
5051 return std::nullopt;
5052 if (
auto *AI = dyn_cast<LoadInst>(
I))
5053 return AI->getSyncScopeID();
5054 if (
auto *AI = dyn_cast<StoreInst>(
I))
5055 return AI->getSyncScopeID();
5056 if (
auto *AI = dyn_cast<FenceInst>(
I))
5057 return AI->getSyncScopeID();
5058 if (
auto *AI = dyn_cast<AtomicCmpXchgInst>(
I))
5059 return AI->getSyncScopeID();
5060 if (
auto *AI = dyn_cast<AtomicRMWInst>(
I))
5061 return AI->getSyncScopeID();
5068 if (
auto *AI = dyn_cast<LoadInst>(
I))
5069 AI->setSyncScopeID(SSID);
5070 else if (
auto *AI = dyn_cast<StoreInst>(
I))
5071 AI->setSyncScopeID(SSID);
5072 else if (
auto *AI = dyn_cast<FenceInst>(
I))
5073 AI->setSyncScopeID(SSID);
5074 else if (
auto *AI = dyn_cast<AtomicCmpXchgInst>(
I))
5075 AI->setSyncScopeID(SSID);
5076 else if (
auto *AI = dyn_cast<AtomicRMWInst>(
I))
5077 AI->setSyncScopeID(SSID);
5102 return I->getOpcode() == Freeze;
5105 return isa<Instruction>(V) &&
classof(cast<Instruction>(V));
static bool isReverseMask(ArrayRef< int > M, EVT VT)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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 defines the Use class.
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)
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.
@ USubCond
Subtract only if no unsigned overflow.
@ Min
*p = old <signed v ? old : v
@ USubSat
*p = usub.sat(old, v) usub.sat matches the behavior of llvm.usub.sat.
@ 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.
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
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 CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static bool classof(const Instruction *I)
static CallBrInst * Create(FunctionCallee Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
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
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
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, ArrayRef< OperandBundleDef > Bundles={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
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)
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)
bool isNonContinuableTrap() const
Return true if the call is for a noreturn trap intrinsic.
static CallInst * Create(FunctionCallee Func, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CallInst * Create(FunctionCallee Func, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles={}, 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={}, 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.
An abstraction over a floating-point predicate, and a pack of an integer predicate with samesign info...
bool hasSameSign() const
Query samesign information, for optimizations.
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 isCommutative(Predicate Pred)
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
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
bool collectOffset(const DataLayout &DL, unsigned BitWidth, SmallMapVector< Value *, APInt, 4 > &VariableOffsets, APInt &ConstantOffset) 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.
bool hasSameSign() const
An icmp instruction, which can be marked as "samesign", indicating that the two operands have the sam...
static bool classof(const Value *V)
void setSameSign(bool B=true)
ICmpInst(InsertPosition InsertBefore, Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="")
Constructor with insertion semantics.
static bool isCommutative(Predicate P)
static CmpPredicate getSwappedCmpPredicate(CmpPredicate Pred)
CmpPredicate getCmpPredicate() const
bool isCommutative() const
static bool isGE(Predicate P)
Return true if the predicate is SGE or UGE.
CmpPredicate getSwappedCmpPredicate() const
static bool isLT(Predicate P)
Return true if the predicate is SLT or ULT.
CmpPredicate getInverseCmpPredicate() const
static bool isGT(Predicate P)
Return true if the predicate is SGT or UGT.
static bool classof(const Instruction *I)
Predicate getFlippedSignednessPredicate() const
For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->EQ.
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
static CmpPredicate getInverseCmpPredicate(CmpPredicate Pred)
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)
static InvokeInst * Create(FunctionCallee Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
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={}, 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.
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.
initializer< Ty > init(const Ty &Val)
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.
unsigned getLoadStoreAddressSpace(const Value *I)
A helper function that returns the address space of the pointer operand of load or store instruction.
APInt operator*(APInt a, uint64_t RHS)
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.
void setAtomicSyncScopeID(Instruction *I, SyncScope::ID SSID)
A helper function that sets an atomic operation's sync scope.
Align getLoadStoreAlignment(const Value *I)
A helper function that returns the alignment of load or store instruction.
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...
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)
Type * getLoadStoreType(const Value *I)
A helper function that returns the type of a load or store instruction.
void setLoadStoreAlignment(Value *I, Align NewAlign)
A helper function that set the alignment of load or store instruction.
unsigned Log2(Align A)
Returns the log2 of the alignment.
@ Default
The result values are uniform if and only if all operands are uniform.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Summary of memprof metadata on allocations.
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
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.
A MapVector that performs no allocations if smaller than a certain size.
Information about how a User object was allocated, to be passed into the User constructor.
Indicates this User has operands "hung off" in another allocation.
Indicates this User has operands co-allocated.
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...