Go to the documentation of this file.
51 #define DEBUG_TYPE "correlated-value-propagation"
55 cl::desc(
"Enables canonicalization of signed relational predicates to "
56 "unsigned (e.g. sgt => ugt)"));
58 STATISTIC(NumPhis,
"Number of phis propagated");
59 STATISTIC(NumPhiCommon,
"Number of phis deleted via common incoming value");
60 STATISTIC(NumSelects,
"Number of selects propagated");
61 STATISTIC(NumMemAccess,
"Number of memory access targets propagated");
62 STATISTIC(NumCmps,
"Number of comparisons propagated");
63 STATISTIC(NumReturns,
"Number of return values propagated");
64 STATISTIC(NumDeadCases,
"Number of switch cases removed");
66 "Number of sdivs/srems whose width was decreased");
67 STATISTIC(NumSDivs,
"Number of sdiv converted to udiv");
69 "Number of udivs/urems whose width was decreased");
70 STATISTIC(NumAShrsConverted,
"Number of ashr converted to lshr");
71 STATISTIC(NumAShrsRemoved,
"Number of ashr removed");
72 STATISTIC(NumSRems,
"Number of srem converted to urem");
73 STATISTIC(NumSExt,
"Number of sext converted to zext");
74 STATISTIC(NumSICmps,
"Number of signed icmp preds simplified to unsigned");
75 STATISTIC(NumAnd,
"Number of ands removed");
76 STATISTIC(NumNW,
"Number of no-wrap deductions");
77 STATISTIC(NumNSW,
"Number of no-signed-wrap deductions");
78 STATISTIC(NumNUW,
"Number of no-unsigned-wrap deductions");
79 STATISTIC(NumAddNW,
"Number of no-wrap deductions for add");
80 STATISTIC(NumAddNSW,
"Number of no-signed-wrap deductions for add");
81 STATISTIC(NumAddNUW,
"Number of no-unsigned-wrap deductions for add");
82 STATISTIC(NumSubNW,
"Number of no-wrap deductions for sub");
83 STATISTIC(NumSubNSW,
"Number of no-signed-wrap deductions for sub");
84 STATISTIC(NumSubNUW,
"Number of no-unsigned-wrap deductions for sub");
85 STATISTIC(NumMulNW,
"Number of no-wrap deductions for mul");
86 STATISTIC(NumMulNSW,
"Number of no-signed-wrap deductions for mul");
87 STATISTIC(NumMulNUW,
"Number of no-unsigned-wrap deductions for mul");
88 STATISTIC(NumShlNW,
"Number of no-wrap deductions for shl");
89 STATISTIC(NumShlNSW,
"Number of no-signed-wrap deductions for shl");
90 STATISTIC(NumShlNUW,
"Number of no-unsigned-wrap deductions for shl");
91 STATISTIC(NumAbs,
"Number of llvm.abs intrinsics removed");
92 STATISTIC(NumOverflows,
"Number of overflow checks removed");
94 "Number of saturating arithmetics converted to normal arithmetics");
95 STATISTIC(NumNonNull,
"Number of function pointer arguments marked non-null");
96 STATISTIC(NumMinMax,
"Number of llvm.[us]{min,max} intrinsics removed");
100 class CorrelatedValuePropagation :
public FunctionPass {
124 "Value Propagation",
false,
false)
132 return new CorrelatedValuePropagation();
136 if (
S->getType()->isVectorTy())
return false;
137 if (isa<Constant>(
S->getCondition()))
return false;
140 if (!
C)
return false;
143 if (!CI)
return false;
145 Value *ReplaceWith = CI->
isOne() ?
S->getTrueValue() :
S->getFalseValue();
146 S->replaceAllUsesWith(ReplaceWith);
147 S->eraseFromParent();
169 Value *CommonValue =
nullptr;
170 for (
unsigned i = 0,
e =
P->getNumIncomingValues();
i !=
e; ++
i) {
171 Value *Incoming =
P->getIncomingValue(
i);
172 if (
auto *IncomingConstant = dyn_cast<Constant>(Incoming)) {
173 IncomingConstants.push_back(std::make_pair(IncomingConstant,
i));
174 }
else if (!CommonValue) {
176 CommonValue = Incoming;
177 }
else if (Incoming != CommonValue) {
183 if (!CommonValue || IncomingConstants.empty())
188 if (
auto *CommonInst = dyn_cast<Instruction>(CommonValue))
195 for (
auto &IncomingConstant : IncomingConstants) {
197 BasicBlock *IncomingBB =
P->getIncomingBlock(IncomingConstant.second);
210 P->replaceAllUsesWith(CommonValue);
211 P->eraseFromParent();
226 auto *
SI = dyn_cast<SelectInst>(Incoming);
232 Value *Condition =
SI->getCondition();
236 return SI->getTrueValue();
237 if (
C->isZeroValue())
238 return SI->getFalseValue();
248 if (
auto *
C = dyn_cast<Constant>(
SI->getFalseValue()))
251 return SI->getTrueValue();
255 if (
auto *
C = dyn_cast<Constant>(
SI->getTrueValue()))
258 return SI->getFalseValue();
265 bool Changed =
false;
268 for (
unsigned i = 0,
e =
P->getNumIncomingValues();
i <
e; ++
i) {
269 Value *Incoming =
P->getIncomingValue(
i);
270 if (isa<Constant>(Incoming))
continue;
274 P->setIncomingValue(
i, V);
280 P->replaceAllUsesWith(V);
281 P->eraseFromParent();
295 Value *Pointer =
nullptr;
297 Pointer = L->getPointerOperand();
299 Pointer = cast<StoreInst>(
I)->getPointerOperand();
301 if (isa<Constant>(Pointer))
return false;
304 if (!
C)
return false;
307 I->replaceUsesOfWith(Pointer,
C);
316 if (Cmp->getType()->isVectorTy() ||
317 !Cmp->getOperand(0)->getType()->isIntegerTy())
320 if (!Cmp->isSigned())
328 if (UnsignedPred == ICmpInst::Predicate::BAD_ICMP_PREDICATE)
332 Cmp->setPredicate(UnsignedPred);
342 Value *Op0 = Cmp->getOperand(0);
343 auto *
C = dyn_cast<Constant>(Cmp->getOperand(1));
355 Cmp->replaceAllUsesWith(TorF);
356 Cmp->eraseFromParent();
364 if (
auto *ICmp = dyn_cast<ICmpInst>(Cmp))
385 bool Changed =
false;
388 SuccessorsCount[Succ]++;
394 for (
auto CI =
SI->case_begin(), CE =
SI->case_end(); CI != CE;) {
404 CI =
SI.removeCase(CI);
409 Cond =
SI->getCondition();
413 if (--SuccessorsCount[Succ] == 0)
421 SI->setCondition(Case);
422 NumDeadCases +=
SI->getNumCases();
450 bool NewNSW,
bool NewNUW) {
458 case Instruction::Sub:
468 case Instruction::Shl:
477 auto *Inst = dyn_cast<Instruction>(V);
484 Inst->setHasNoSignedWrap();
492 Inst->setHasNoUnsignedWrap();
503 bool IsIntMinPoison = cast<ConstantInt>(II->
getArgOperand(1))->isOne();
505 Type *Ty =
X->getType();
511 Result = LVI->
getPredicateAt(CmpInst::Predicate::ICMP_ULE,
X, IntMin, II,
522 Result = LVI->
getPredicateAt(CmpInst::Predicate::ICMP_SLE,
X, Zero, II,
528 bool Changed =
false;
529 if (!IsIntMinPoison) {
531 Result = LVI->
getPredicateAt(CmpInst::Predicate::ICMP_NE,
X, IntMin, II,
551 if (
auto *BO = dyn_cast<BinaryOperator>(NegX))
586 Value *NewI =
B.CreateInsertValue(Struct, NewOp, 0);
592 if (
auto *BO = dyn_cast<BinaryOperator>(NewOp))
600 bool NSW =
SI->isSigned();
601 bool NUW = !
SI->isSigned();
603 Opcode,
SI->getLHS(),
SI->getRHS(),
SI->getName(),
SI);
607 SI->replaceAllUsesWith(BinOp);
608 SI->eraseFromParent();
612 if (
auto *BO = dyn_cast<BinaryOperator>(BinOp))
625 if (
auto *MM = dyn_cast<MinMaxIntrinsic>(&CB)) {
629 if (
auto *WO = dyn_cast<WithOverflowInst>(&CB)) {
630 if (WO->getLHS()->getType()->isIntegerTy() &&
willNotOverflow(WO, LVI)) {
635 if (
auto *
SI = dyn_cast<SaturatingInst>(&CB)) {
641 bool Changed =
false;
651 for (
const Use &ConstU : DeoptBundle->Inputs) {
652 Use &U =
const_cast<Use&
>(ConstU);
655 if (isa<Constant>(V))
continue;
677 ArgNos.push_back(ArgNo);
681 assert(ArgNo == CB.
arg_size() &&
"Call arguments not processed correctly.");
686 NumNonNull += ArgNos.size();
724 Instr->
getOpcode() == Instruction::SRem);
734 std::array<Optional<ConstantRange>, 2> CRs;
735 unsigned MinSignedBits = 0;
738 MinSignedBits =
std::max(std::get<1>(
I)->getMinSignedBits(), MinSignedBits);
748 unsigned NewWidth = std::max<unsigned>(
PowerOf2Ceil(MinSignedBits), 8);
752 if (NewWidth >= OrigWidth)
755 ++NumSDivSRemsNarrowed;
759 Instr->
getName() +
".lhs.trunc");
761 Instr->
getName() +
".rhs.trunc");
763 auto *Sext =
B.CreateSExt(BO, Instr->
getType(), Instr->
getName() +
".sext");
764 if (
auto *BinOp = dyn_cast<BinaryOperator>(BO))
765 if (BinOp->getOpcode() == Instruction::SDiv)
766 BinOp->setIsExact(Instr->
isExact());
777 Instr->
getOpcode() == Instruction::URem);
786 unsigned MaxActiveBits = 0;
792 unsigned NewWidth = std::max<unsigned>(
PowerOf2Ceil(MaxActiveBits), 8);
799 ++NumUDivURemsNarrowed;
803 Instr->
getName() +
".lhs.trunc");
805 Instr->
getName() +
".rhs.trunc");
807 auto *Zext =
B.CreateZExt(BO, Instr->
getType(), Instr->
getName() +
".zext");
808 if (
auto *BinOp = dyn_cast<BinaryOperator>(BO))
809 if (BinOp->getOpcode() == Instruction::UDiv)
810 BinOp->setIsExact(Instr->
isExact());
826 std::array<Operand, 2> Ops;
829 Operand &
Op = std::get<0>(
I);
830 Op.V = std::get<1>(
I);
840 for (Operand &
Op : Ops) {
850 BinaryOperator::CreateURem(Ops[0].V, Ops[1].V, SDI->
getName(), SDI);
882 std::array<Operand, 2> Ops;
885 Operand &
Op = std::get<0>(
I);
886 Op.V = std::get<1>(
I);
896 for (Operand &
Op : Ops) {
906 BinaryOperator::CreateUDiv(Ops[0].V, Ops[1].V, SDI->
getName(), SDI);
908 UDiv->setIsExact(SDI->
isExact());
913 if (Ops[0].
D != Ops[1].
D)
927 Instr->
getOpcode() == Instruction::SRem);
931 if (Instr->
getOpcode() == Instruction::SDiv)
935 if (Instr->
getOpcode() == Instruction::SRem)
950 if (NegOneOrZero.
contains(LRange)) {
966 BO->setIsExact(SDI->
isExact());
1010 bool Changed =
false;
1011 bool NewNUW =
false, NewNSW =
false;
1014 Opcode, RRange, OBO::NoUnsignedWrap);
1015 NewNUW = NUWRange.
contains(LRange);
1020 Opcode, RRange, OBO::NoSignedWrap);
1021 NewNSW = NSWRange.
contains(LRange);
1038 if (!
RHS || !
RHS->getValue().isMask())
1061 auto *
C = dyn_cast<CmpInst>(V);
1062 if (!
C)
return nullptr;
1064 Value *Op0 =
C->getOperand(0);
1065 Constant *Op1 = dyn_cast<Constant>(
C->getOperand(1));
1066 if (!Op1)
return nullptr;
1069 C->getPredicate(), Op0, Op1, At,
false);
1080 bool FnChanged =
false;
1087 bool BBChanged =
false;
1089 switch (II.getOpcode()) {
1093 case Instruction::PHI:
1094 BBChanged |=
processPHI(cast<PHINode>(&II), LVI, DT, SQ);
1096 case Instruction::ICmp:
1097 case Instruction::FCmp:
1098 BBChanged |=
processCmp(cast<CmpInst>(&II), LVI);
1105 case Instruction::Invoke:
1108 case Instruction::SRem:
1109 case Instruction::SDiv:
1112 case Instruction::UDiv:
1113 case Instruction::URem:
1116 case Instruction::AShr:
1117 BBChanged |=
processAShr(cast<BinaryOperator>(&II), LVI);
1119 case Instruction::SExt:
1120 BBChanged |=
processSExt(cast<SExtInst>(&II), LVI);
1123 case Instruction::Sub:
1125 case Instruction::Shl:
1126 BBChanged |=
processBinOp(cast<BinaryOperator>(&II), LVI);
1128 case Instruction::And:
1129 BBChanged |=
processAnd(cast<BinaryOperator>(&II), LVI);
1135 switch (
Term->getOpcode()) {
1136 case Instruction::Switch:
1140 auto *RI = cast<ReturnInst>(
Term);
1144 auto *RetVal = RI->getReturnValue();
1146 if (isa<Constant>(RetVal))
break;
1149 RI->replaceUsesOfWith(RetVal,
C);
1155 FnChanged |= BBChanged;
1162 if (skipFunction(
F))
1165 LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
1166 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
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.
A set of analyses that are preserved following a run of a transformation pass.
Instruction::BinaryOps getBinaryOp() const
Returns the binary operation underlying the intrinsic.
This is an optimization pass for GlobalISel generic memory operations.
static IntegerType * getInt1Ty(LLVMContext &C)
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
A wrapper class to simplify modification of SwitchInst cases along with their prof branch_weights met...
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
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 ...
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
static Constant * get(StructType *T, ArrayRef< Constant * > V)
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
return AArch64::GPR64RegClass contains(Reg)
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Analysis to compute lazy value information.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
This class represents an intrinsic that is based on a binary operation.
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
void abandon()
Mark an analysis as abandoned.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Constant * getConstant(Value *V, Instruction *CxtI)
Determine whether the specified value is known to be a constant at the specified instruction.
The instances of the Type class are immutable: once they are created, they are never changed.
AttributeList getAttributes() const
Return the parameter attributes for this call.
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
void initializeCorrelatedValuePropagationPass(PassRegistry &)
auto successors(MachineBasicBlock *BB)
@ ICMP_SLE
signed less or equal
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
NUW NUW NUW NUW Exact static Exact BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
LLVM Basic Block Representation.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
This is the shared class of boolean and integer constants.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Predicate getNonStrictPredicate() const
For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
(vector float) vec_cmpeq(*A, *B) C
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Represent the analysis usage information of a pass.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
bool isVectorTy() const
True if this is an instance of VectorType.
unsigned getNoWrapKind() const
Returns one of OBO::NoSignedWrap or OBO::NoUnsignedWrap.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
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)...
Represents a saturating add/sub intrinsic.
BinaryOps getOpcode() const
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
Legacy analysis pass which computes a DominatorTree.
STATISTIC(NumFunctions, "Total number of functions")
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
unsigned getIntegerBitWidth() const
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
This class is the base class for the comparison instructions.
This is an important base class in LLVM.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
This instruction compares its operands according to the predicate given to the constructor.
bool isSigned() const
Whether the intrinsic is signed or unsigned.
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
ConstantRange getConstantRange(Value *V, Instruction *CxtI, bool UndefAllowed=true)
Return the ConstantRange constraint that is known to hold for the specified value at the specified in...
Wrapper around LazyValueInfo.
void preserve()
Mark an analysis as preserved.
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
This is an important class for using LLVM in a threaded context.
initializer< Ty > init(const Ty &Val)
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...
Class to represent pointers.
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q, OptimizationRemarkEmitter *ORE=nullptr)
See if we can compute a simplified version of this instruction.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Pass * createCorrelatedValuePropagationPass()
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...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StandardInstrumentations SI(Debug, VerifyEach)
This class represents the LLVM 'select' instruction.
This pass computes, caches, and vends lazy value constraint information.
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&... args)
zip iterator for two or more iteratable types.
Class for arbitrary precision integers.
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
Class to represent struct types.
SmallVector< MachineOperand, 4 > Cond
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Type * getType() const
All values are typed, get the type of this value.
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
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.
bool isExact() const
Determine whether the exact flag is set.
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
Represents an op.with.overflow intrinsic.
This class represents a sign extension of integer types.
StringRef getName() const
Return a constant reference to the value's name.
An instruction for reading from memory.
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
void setArgOperand(unsigned i, Value *v)
static ConstantInt * getFalse(LLVMContext &Context)
iterator_range< df_iterator< T > > depth_first(const T &G)
static bool runOnFunction(Function &F, bool PostInlining)
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...
static ConstantInt * getTrue(LLVMContext &Context)
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
const SimplifyQuery getBestSimplifyQuery(Pass &, Function &)
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
unsigned arg_size() const
unsigned getActiveBits() const
Compute the maximal number of active bits needed to represent every value in this range.
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
@ ICMP_SGE
signed greater or equal
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
This class represents a range of values.
A wrapper class for inspecting calls to intrinsic functions.
Analysis pass which computes a DominatorTree.
Pass interface - Implemented by all 'passes'.
This class represents min/max intrinsics.
Tristate
This is used to return true/false/dunno results.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
Value * getArgOperand(unsigned i) const
Legacy wrapper pass to provide the GlobalsAAResult object.
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
A container for analyses that lazily runs them and caches their results.
FunctionPass class - This class is used to implement most global optimizations.
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
bool isGuaranteedNotToBePoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
AnalysisUsage & addRequired()
BlockVerifier::State From
Value * getOperand(unsigned i) const
static CastInst * CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
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 ...
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
APFloat abs(APFloat X)
Returns the absolute value of the argument.
void applyUpdatesPermissive(ArrayRef< DominatorTree::UpdateType > Updates)
Submit updates to all available trees.
LLVM Value Representation.
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
static constexpr UpdateKind Delete
A Use represents the edge between a Value definition and its users.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.