48#define DEBUG_TYPE "correlated-value-propagation"
51STATISTIC(NumPhiCommon,
"Number of phis deleted via common incoming value");
52STATISTIC(NumSelects,
"Number of selects propagated");
53STATISTIC(NumCmps,
"Number of comparisons propagated");
54STATISTIC(NumReturns,
"Number of return values propagated");
55STATISTIC(NumDeadCases,
"Number of switch cases removed");
57 "Number of sdivs/srems whose width was decreased");
58STATISTIC(NumSDivs,
"Number of sdiv converted to udiv");
60 "Number of udivs/urems whose width was decreased");
61STATISTIC(NumAShrsConverted,
"Number of ashr converted to lshr");
62STATISTIC(NumAShrsRemoved,
"Number of ashr removed");
63STATISTIC(NumSRems,
"Number of srem converted to urem");
64STATISTIC(NumSExt,
"Number of sext converted to zext");
65STATISTIC(NumSIToFP,
"Number of sitofp converted to uitofp");
66STATISTIC(NumSICmps,
"Number of signed icmp preds simplified to unsigned");
69STATISTIC(NumNSW,
"Number of no-signed-wrap deductions");
70STATISTIC(NumNUW,
"Number of no-unsigned-wrap deductions");
71STATISTIC(NumAddNW,
"Number of no-wrap deductions for add");
72STATISTIC(NumAddNSW,
"Number of no-signed-wrap deductions for add");
73STATISTIC(NumAddNUW,
"Number of no-unsigned-wrap deductions for add");
74STATISTIC(NumSubNW,
"Number of no-wrap deductions for sub");
75STATISTIC(NumSubNSW,
"Number of no-signed-wrap deductions for sub");
76STATISTIC(NumSubNUW,
"Number of no-unsigned-wrap deductions for sub");
77STATISTIC(NumMulNW,
"Number of no-wrap deductions for mul");
78STATISTIC(NumMulNSW,
"Number of no-signed-wrap deductions for mul");
79STATISTIC(NumMulNUW,
"Number of no-unsigned-wrap deductions for mul");
80STATISTIC(NumShlNW,
"Number of no-wrap deductions for shl");
81STATISTIC(NumShlNSW,
"Number of no-signed-wrap deductions for shl");
82STATISTIC(NumShlNUW,
"Number of no-unsigned-wrap deductions for shl");
83STATISTIC(NumAbs,
"Number of llvm.abs intrinsics removed");
84STATISTIC(NumOverflows,
"Number of overflow checks removed");
86 "Number of saturating arithmetics converted to normal arithmetics");
87STATISTIC(NumNonNull,
"Number of function pointer arguments marked non-null");
88STATISTIC(NumMinMax,
"Number of llvm.[us]{min,max} intrinsics removed");
90 "Number of llvm.s{min,max} intrinsics simplified to unsigned");
92 "Number of bound udiv's/urem's expanded");
93STATISTIC(NumNNeg,
"Number of zext/uitofp non-negative deductions");
101 auto *
C = dyn_cast<CmpInst>(V);
105 Value *Op0 =
C->getOperand(0);
106 Constant *Op1 = dyn_cast<Constant>(
C->getOperand(1));
111 C->getPredicate(), Op0, Op1, At,
false);
124 bool Changed =
false;
126 auto *
I = cast<Instruction>(U.getUser());
128 if (
auto *PN = dyn_cast<PHINode>(
I))
134 auto *CI = dyn_cast_or_null<ConstantInt>(
C);
164 Value *CommonValue =
nullptr;
165 for (
unsigned i = 0, e =
P->getNumIncomingValues(); i != e; ++i) {
167 if (
auto *IncomingConstant = dyn_cast<Constant>(
Incoming)) {
168 IncomingConstants.
push_back(std::make_pair(IncomingConstant, i));
169 }
else if (!CommonValue) {
172 }
else if (
Incoming != CommonValue) {
178 if (!CommonValue || IncomingConstants.
empty())
183 if (
auto *CommonInst = dyn_cast<Instruction>(CommonValue))
190 for (
auto &IncomingConstant : IncomingConstants) {
192 BasicBlock *IncomingBB =
P->getIncomingBlock(IncomingConstant.second);
205 P->replaceAllUsesWith(CommonValue);
206 P->eraseFromParent();
221 auto *SI = dyn_cast<SelectInst>(
Incoming);
227 Value *Condition = SI->getCondition();
231 return SI->getTrueValue();
232 if (
C->isZeroValue())
233 return SI->getFalseValue();
243 if (
auto *
C = dyn_cast<Constant>(SI->getFalseValue()))
246 return SI->getTrueValue();
250 if (
auto *
C = dyn_cast<Constant>(SI->getTrueValue()))
253 return SI->getFalseValue();
260 bool Changed =
false;
263 for (
unsigned i = 0, e =
P->getNumIncomingValues(); i < e; ++i) {
265 if (isa<Constant>(
Incoming))
continue;
269 P->setIncomingValue(i, V);
275 P->replaceAllUsesWith(V);
276 P->eraseFromParent();
291 if (Cmp->getType()->isVectorTy() ||
292 !Cmp->getOperand(0)->getType()->isIntegerTy())
295 if (!Cmp->isSigned())
306 if (UnsignedPred == ICmpInst::Predicate::BAD_ICMP_PREDICATE)
310 Cmp->setPredicate(UnsignedPred);
320 Value *Op0 = Cmp->getOperand(0);
321 Value *Op1 = Cmp->getOperand(1);
331 Cmp->replaceAllUsesWith(TorF);
332 Cmp->eraseFromParent();
340 if (
auto *ICmp = dyn_cast<ICmpInst>(Cmp))
361 bool Changed =
false;
364 SuccessorsCount[Succ]++;
369 unsigned ReachableCaseCount = 0;
371 for (
auto CI = SI->case_begin(), CE = SI->case_end(); CI != CE;) {
381 CI = SI.removeCase(CI);
386 Cond = SI->getCondition();
390 if (--SuccessorsCount[Succ] == 0)
398 SI->setCondition(Case);
399 NumDeadCases += SI->getNumCases();
406 ++ReachableCaseCount;
409 BasicBlock *DefaultDest = SI->getDefaultDest();
410 if (ReachableCaseCount > 1 &&
422 SI->setDefaultDest(NewUnreachableBB);
424 if (SuccessorsCount[DefaultDest] == 1)
425 DTU.
applyUpdates({{DominatorTree::Delete, BB, DefaultDest}});
426 DTU.
applyUpdates({{DominatorTree::Insert, BB, NewUnreachableBB}});
454 bool NewNSW,
bool NewNUW) {
457 case Instruction::Add:
462 case Instruction::Sub:
467 case Instruction::Mul:
472 case Instruction::Shl:
481 auto *Inst = dyn_cast<Instruction>(V);
488 Inst->setHasNoSignedWrap();
496 Inst->setHasNoUnsignedWrap();
507 Type *Ty =
X->getType();
511 bool IsIntMinPoison = cast<ConstantInt>(
II->getArgOperand(1))->isOne();
514 II->getOperandUse(0), IsIntMinPoison);
519 II->replaceAllUsesWith(
X);
520 II->eraseFromParent();
527 Value *NegX =
B.CreateNeg(
X,
II->getName(),
530 II->replaceAllUsesWith(NegX);
531 II->eraseFromParent();
534 if (
auto *BO = dyn_cast<BinaryOperator>(NegX))
559 if (LHS_CR.
icmp(Pred, RHS_CR)) {
565 if (RHS_CR.
icmp(Pred, LHS_CR)) {
609 if (
auto *BO = dyn_cast<BinaryOperator>(NewOp))
617 bool NSW = SI->isSigned();
618 bool NUW = !SI->isSigned();
620 Opcode, SI->getLHS(), SI->getRHS(), SI->getName(), SI->getIterator());
624 SI->replaceAllUsesWith(BinOp);
625 SI->eraseFromParent();
629 if (
auto *BO = dyn_cast<BinaryOperator>(BinOp))
642 if (
auto *MM = dyn_cast<MinMaxIntrinsic>(&CB)) {
646 if (
auto *WO = dyn_cast<WithOverflowInst>(&CB)) {
647 if (WO->getLHS()->getType()->isIntegerTy() &&
willNotOverflow(WO, LVI)) {
652 if (
auto *SI = dyn_cast<SaturatingInst>(&CB)) {
658 bool Changed =
false;
668 for (
const Use &ConstU : DeoptBundle->Inputs) {
669 Use &U =
const_cast<Use&
>(ConstU);
671 if (V->getType()->isVectorTy())
continue;
672 if (isa<Constant>(V))
continue;
698 assert(ArgNo == CB.
arg_size() &&
"Call arguments not processed correctly.");
703 NumNonNull += ArgNos.
size();
727 assert(Instr->getOpcode() == Instruction::SDiv ||
728 Instr->getOpcode() == Instruction::SRem);
729 assert(!Instr->getType()->isVectorTy());
733 unsigned OrigWidth = Instr->getType()->getIntegerBitWidth();
737 unsigned MinSignedBits =
747 unsigned NewWidth = std::max<unsigned>(
PowerOf2Ceil(MinSignedBits), 8);
751 if (NewWidth >= OrigWidth)
754 ++NumSDivSRemsNarrowed;
757 auto *
LHS =
B.CreateTruncOrBitCast(Instr->getOperand(0), TruncTy,
758 Instr->getName() +
".lhs.trunc");
759 auto *
RHS =
B.CreateTruncOrBitCast(Instr->getOperand(1), TruncTy,
760 Instr->getName() +
".rhs.trunc");
761 auto *BO =
B.CreateBinOp(Instr->getOpcode(),
LHS,
RHS, Instr->getName());
762 auto *Sext =
B.CreateSExt(BO, Instr->getType(), Instr->getName() +
".sext");
763 if (
auto *BinOp = dyn_cast<BinaryOperator>(BO))
764 if (BinOp->getOpcode() == Instruction::SDiv)
765 BinOp->setIsExact(Instr->isExact());
767 Instr->replaceAllUsesWith(Sext);
768 Instr->eraseFromParent();
774 Type *Ty = Instr->getType();
775 assert(Instr->getOpcode() == Instruction::UDiv ||
776 Instr->getOpcode() == Instruction::URem);
778 bool IsRem = Instr->getOpcode() == Instruction::URem;
780 Value *
X = Instr->getOperand(0);
781 Value *
Y = Instr->getOperand(1);
785 if (XCR.
icmp(ICmpInst::ICMP_ULT, YCR)) {
787 Instr->eraseFromParent();
788 ++NumUDivURemsNarrowedExpanded;
816 if (!XCR.
icmp(ICmpInst::ICMP_ULT,
823 if (XCR.
icmp(ICmpInst::ICMP_UGE, YCR)) {
826 ExpandedOp =
B.CreateNUWSub(
X,
Y);
828 ExpandedOp = ConstantInt::get(Instr->getType(), 1);
834 FrozenX =
B.CreateFreeze(
X,
X->getName() +
".frozen");
837 FrozenY =
B.CreateFreeze(
Y,
Y->getName() +
".frozen");
838 auto *AdjX =
B.CreateNUWSub(FrozenX, FrozenY, Instr->getName() +
".urem");
839 auto *Cmp =
B.CreateICmp(ICmpInst::ICMP_ULT, FrozenX, FrozenY,
840 Instr->getName() +
".cmp");
841 ExpandedOp =
B.CreateSelect(Cmp, FrozenX, AdjX);
844 B.CreateICmp(ICmpInst::ICMP_UGE,
X,
Y, Instr->getName() +
".cmp");
845 ExpandedOp =
B.CreateZExt(Cmp, Ty, Instr->getName() +
".udiv");
848 Instr->replaceAllUsesWith(ExpandedOp);
849 Instr->eraseFromParent();
850 ++NumUDivURemsNarrowedExpanded;
858 assert(Instr->getOpcode() == Instruction::UDiv ||
859 Instr->getOpcode() == Instruction::URem);
860 assert(!Instr->getType()->isVectorTy());
869 unsigned NewWidth = std::max<unsigned>(
PowerOf2Ceil(MaxActiveBits), 8);
873 if (NewWidth >= Instr->getType()->getIntegerBitWidth())
876 ++NumUDivURemsNarrowed;
879 auto *
LHS =
B.CreateTruncOrBitCast(Instr->getOperand(0), TruncTy,
880 Instr->getName() +
".lhs.trunc");
881 auto *
RHS =
B.CreateTruncOrBitCast(Instr->getOperand(1), TruncTy,
882 Instr->getName() +
".rhs.trunc");
883 auto *BO =
B.CreateBinOp(Instr->getOpcode(),
LHS,
RHS, Instr->getName());
884 auto *Zext =
B.CreateZExt(BO, Instr->getType(), Instr->getName() +
".zext");
885 if (
auto *BinOp = dyn_cast<BinaryOperator>(BO))
886 if (BinOp->getOpcode() == Instruction::UDiv)
887 BinOp->setIsExact(Instr->isExact());
889 Instr->replaceAllUsesWith(Zext);
890 Instr->eraseFromParent();
895 assert(Instr->getOpcode() == Instruction::UDiv ||
896 Instr->getOpcode() == Instruction::URem);
897 if (Instr->getType()->isVectorTy())
935 for (Operand &
Op : Ops) {
944 auto *URem = BinaryOperator::CreateURem(Ops[0].V, Ops[1].V, SDI->
getName(),
997 for (Operand &
Op : Ops) {
1006 auto *UDiv = BinaryOperator::CreateUDiv(Ops[0].V, Ops[1].V, SDI->
getName(),
1009 UDiv->setIsExact(SDI->
isExact());
1014 if (Ops[0].
D != Ops[1].
D) {
1030 assert(Instr->getOpcode() == Instruction::SDiv ||
1031 Instr->getOpcode() == Instruction::SRem);
1032 if (Instr->getType()->isVectorTy())
1040 if (Instr->getOpcode() == Instruction::SDiv)
1044 if (Instr->getOpcode() == Instruction::SRem) {
1061 if (NegOneOrZero.
contains(LRange)) {
1072 ++NumAShrsConverted;
1077 BO->setIsExact(SDI->
isExact());
1096 ZExt->takeName(SDI);
1106 if (
I->getType()->isVectorTy())
1112 const Use &
Base =
I->getOperandUse(0);
1143 UIToFP->takeName(SIToFP);
1145 UIToFP->setNonNeg();
1169 bool Changed =
false;
1170 bool NewNUW =
false, NewNSW =
false;
1173 Opcode, RRange, OBO::NoUnsignedWrap);
1174 NewNUW = NUWRange.
contains(LRange);
1179 Opcode, RRange, OBO::NoSignedWrap);
1180 NewNSW = NSWRange.
contains(LRange);
1197 if (!
RHS || !
RHS->getValue().isMask())
1215 bool FnChanged =
false;
1222 bool BBChanged =
false;
1224 switch (
II.getOpcode()) {
1225 case Instruction::Select:
1228 case Instruction::PHI:
1229 BBChanged |=
processPHI(cast<PHINode>(&
II), LVI, DT, SQ);
1231 case Instruction::ICmp:
1232 case Instruction::FCmp:
1235 case Instruction::Call:
1236 case Instruction::Invoke:
1239 case Instruction::SRem:
1240 case Instruction::SDiv:
1243 case Instruction::UDiv:
1244 case Instruction::URem:
1247 case Instruction::AShr:
1250 case Instruction::SExt:
1253 case Instruction::ZExt:
1256 case Instruction::UIToFP:
1259 case Instruction::SIToFP:
1262 case Instruction::Add:
1263 case Instruction::Sub:
1264 case Instruction::Mul:
1265 case Instruction::Shl:
1268 case Instruction::And:
1269 BBChanged |=
processAnd(cast<BinaryOperator>(&
II), LVI);
1275 switch (Term->getOpcode()) {
1276 case Instruction::Switch:
1277 BBChanged |=
processSwitch(cast<SwitchInst>(Term), LVI, DT);
1279 case Instruction::Ret: {
1280 auto *RI = cast<ReturnInst>(Term);
1284 auto *RetVal = RI->getReturnValue();
1286 if (isa<Constant>(RetVal))
break;
1289 RI->replaceUsesOfWith(RetVal,
C);
1295 FnChanged |= BBChanged;
1312#if defined(EXPENSIVE_CHECKS)
1313 assert(DT->verify(DominatorTree::VerificationLevel::Full));
1315 assert(DT->verify(DominatorTree::VerificationLevel::Fast));
This file contains the simple types necessary to represent the attributes associated with functions a...
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file builds on the ADT/GraphTraits.h file to build generic depth first graph iterator.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static bool runImpl(Function &F, const TargetLowering &TLI)
This is the interface for a simple mod/ref and alias analysis over globals.
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
This header defines various interfaces for pass management in LLVM.
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
bool isNonPositive() const
Determine if this APInt Value is non-positive (<= 0).
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
APInt sext(unsigned width) const
Sign extend to a new width.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
LLVM Basic Block Representation.
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
const Function * getParent() const
Return the enclosing method, or null if none.
const Instruction * getFirstNonPHIOrDbg(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic,...
LLVMContext & getContext() const
Get the context in which this basic block lives.
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
This class represents an intrinsic that is based on a binary operation.
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
bool isSigned() const
Whether the intrinsic is signed or unsigned.
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
static BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
BinaryOps getOpcode() const
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
std::optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
unsigned arg_size() const
AttributeList getAttributes() const
Return the parameter attributes for this call.
static CastInst * CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
This class is the base class for the comparison instructions.
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_ULT
unsigned less than
@ ICMP_ULE
unsigned less or equal
Predicate getNonStrictPredicate() const
For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
This class represents a range of values.
unsigned getActiveBits() const
Compute the maximal number of active bits needed to represent every value in this range.
ConstantRange umul_sat(const ConstantRange &Other) const
Perform an unsigned saturating multiplication of two constant ranges.
static CmpInst::Predicate getEquivalentPredWithFlippedSignedness(CmpInst::Predicate Pred, const ConstantRange &CR1, const ConstantRange &CR2)
If the comparison between constant ranges this and Other is insensitive to the signedness of the comp...
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
bool isAllNegative() const
Return true if all values in this range are negative.
bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const
Does the predicate Pred hold between ranges this and Other? NOTE: false does not mean that inverse pr...
bool isSizeLargerThan(uint64_t MaxSize) const
Compare set size of this range with Value.
ConstantRange abs(bool IntMinIsPoison=false) const
Calculate absolute value range.
bool isAllNonNegative() const
Return true if all values in this range are non-negative.
ConstantRange sdiv(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a signed division of a value in th...
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
APInt getSignedMax() const
Return the largest signed value contained in the ConstantRange.
static bool areInsensitiveToSignednessOfICmpPredicate(const ConstantRange &CR1, const ConstantRange &CR2)
Return true iff CR1 ult CR2 is equivalent to CR1 slt CR2.
static ConstantRange makeGuaranteedNoWrapRegion(Instruction::BinaryOps BinOp, const ConstantRange &Other, unsigned NoWrapKind)
Produce the largest range containing all X such that "X BinOp Y" is guaranteed not to wrap (overflow)...
unsigned getMinSignedBits() const
Compute the maximal number of bits needed to represent every value in this signed range.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
static Constant * get(StructType *T, ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
This class represents an Operation in the Expression.
Analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
void applyUpdatesPermissive(ArrayRef< typename DomTreeT::UpdateType > Updates)
Submit updates to all available trees.
void applyUpdates(ArrayRef< typename DomTreeT::UpdateType > Updates)
Submit updates to all available trees.
This instruction compares its operands according to the predicate given to the constructor.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
bool hasNoUnsignedWrap() const LLVM_READONLY
Determine whether the no unsigned wrap flag is set.
bool hasNoSignedWrap() const LLVM_READONLY
Determine whether the no signed wrap flag is set.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
This is an important class for using LLVM in a threaded context.
Analysis to compute lazy value information.
This pass computes, caches, and vends lazy value constraint information.
ConstantRange getConstantRangeAtUse(const Use &U, bool UndefAllowed)
Return the ConstantRange constraint that is known to hold for the value at a specific use-site.
Tristate
This is used to return true/false/dunno results.
Constant * getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Determine whether the specified value is known to be a constant on the specified edge.
Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Determine whether the specified value comparison with a constant is known to be true or false on the ...
Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C, Instruction *CxtI, bool UseBlockValue)
Determine whether the specified value comparison with a constant is known to be true or false at the ...
Constant * getConstant(Value *V, Instruction *CxtI)
Determine whether the specified value is known to be a constant at the specified instruction.
This class represents min/max intrinsics.
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
static bool isSigned(Intrinsic::ID ID)
Whether the intrinsic is signed or unsigned.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Instruction that can have a nneg flag (zext/uitofp).
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void abandon()
Mark an analysis as abandoned.
void preserve()
Mark an analysis as preserved.
This class represents a sign extension of integer types.
This class represents a cast from signed integer to floating point.
Represents a saturating add/sub intrinsic.
This class represents the LLVM 'select' instruction.
const Value * getFalseValue() const
const Value * getCondition() const
const Value * getTrueValue() const
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Class to represent struct types.
A wrapper class to simplify modification of SwitchInst cases along with their prof branch_weights met...
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getIntegerBitWidth() const
bool isVectorTy() const
True if this is an instance of VectorType.
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
This class represents a cast unsigned integer to floating point.
This function has undefined behavior.
A Use represents the edge between a Value definition and its users.
const Use & getOperandUse(unsigned i) const
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
LLVMContext & getContext() const
All values hold a context through their type.
iterator_range< use_iterator > uses()
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
Represents an op.with.overflow intrinsic.
This class represents zero extension of integer types.
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr, DomTreeUpdater *DTU=nullptr)
If a terminator instruction is predicated on a constant value, convert it into an unconditional branc...
auto successors(const MachineBasicBlock *BB)
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
bool isGuaranteedNotToBeUndef(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be undef, but may be poison.
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
iterator_range< df_iterator< T > > depth_first(const T &G)
bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Returns true if V cannot be poison, but may be undef.
const SimplifyQuery getBestSimplifyQuery(Pass &, Function &)
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...