51#define DEBUG_TYPE "correlated-value-propagation"
55 cl::desc(
"Enables canonicalization of signed relational predicates to "
56 "unsigned (e.g. sgt => ugt)"));
59STATISTIC(NumPhiCommon,
"Number of phis deleted via common incoming value");
60STATISTIC(NumSelects,
"Number of selects propagated");
61STATISTIC(NumMemAccess,
"Number of memory access targets propagated");
62STATISTIC(NumCmps,
"Number of comparisons propagated");
63STATISTIC(NumReturns,
"Number of return values propagated");
64STATISTIC(NumDeadCases,
"Number of switch cases removed");
66 "Number of sdivs/srems whose width was decreased");
67STATISTIC(NumSDivs,
"Number of sdiv converted to udiv");
69 "Number of udivs/urems whose width was decreased");
70STATISTIC(NumAShrsConverted,
"Number of ashr converted to lshr");
71STATISTIC(NumAShrsRemoved,
"Number of ashr removed");
72STATISTIC(NumSRems,
"Number of srem converted to urem");
73STATISTIC(NumSExt,
"Number of sext converted to zext");
74STATISTIC(NumSICmps,
"Number of signed icmp preds simplified to unsigned");
77STATISTIC(NumNSW,
"Number of no-signed-wrap deductions");
78STATISTIC(NumNUW,
"Number of no-unsigned-wrap deductions");
79STATISTIC(NumAddNW,
"Number of no-wrap deductions for add");
80STATISTIC(NumAddNSW,
"Number of no-signed-wrap deductions for add");
81STATISTIC(NumAddNUW,
"Number of no-unsigned-wrap deductions for add");
82STATISTIC(NumSubNW,
"Number of no-wrap deductions for sub");
83STATISTIC(NumSubNSW,
"Number of no-signed-wrap deductions for sub");
84STATISTIC(NumSubNUW,
"Number of no-unsigned-wrap deductions for sub");
85STATISTIC(NumMulNW,
"Number of no-wrap deductions for mul");
86STATISTIC(NumMulNSW,
"Number of no-signed-wrap deductions for mul");
87STATISTIC(NumMulNUW,
"Number of no-unsigned-wrap deductions for mul");
88STATISTIC(NumShlNW,
"Number of no-wrap deductions for shl");
89STATISTIC(NumShlNSW,
"Number of no-signed-wrap deductions for shl");
90STATISTIC(NumShlNUW,
"Number of no-unsigned-wrap deductions for shl");
91STATISTIC(NumAbs,
"Number of llvm.abs intrinsics removed");
92STATISTIC(NumOverflows,
"Number of overflow checks removed");
94 "Number of saturating arithmetics converted to normal arithmetics");
95STATISTIC(NumNonNull,
"Number of function pointer arguments marked non-null");
96STATISTIC(NumMinMax,
"Number of llvm.[us]{min,max} intrinsics removed");
98 "Number of bound udiv's/urem's expanded");
102 class CorrelatedValuePropagation :
public FunctionPass {
123char CorrelatedValuePropagation::ID = 0;
126 "Value Propagation",
false,
false)
134 return new CorrelatedValuePropagation();
142 if (!
C)
return false;
145 if (!CI)
return false;
171 Value *CommonValue =
nullptr;
172 for (
unsigned i = 0, e =
P->getNumIncomingValues(); i != e; ++i) {
173 Value *Incoming =
P->getIncomingValue(i);
174 if (
auto *IncomingConstant = dyn_cast<Constant>(Incoming)) {
175 IncomingConstants.
push_back(std::make_pair(IncomingConstant, i));
176 }
else if (!CommonValue) {
178 CommonValue = Incoming;
179 }
else if (Incoming != CommonValue) {
185 if (!CommonValue || IncomingConstants.
empty())
190 if (
auto *CommonInst = dyn_cast<Instruction>(CommonValue))
197 for (
auto &IncomingConstant : IncomingConstants) {
199 BasicBlock *IncomingBB =
P->getIncomingBlock(IncomingConstant.second);
212 P->replaceAllUsesWith(CommonValue);
213 P->eraseFromParent();
228 auto *
SI = dyn_cast<SelectInst>(Incoming);
234 Value *Condition =
SI->getCondition();
238 return SI->getTrueValue();
239 if (
C->isZeroValue())
240 return SI->getFalseValue();
250 if (
auto *
C = dyn_cast<Constant>(
SI->getFalseValue()))
253 return SI->getTrueValue();
257 if (
auto *
C = dyn_cast<Constant>(
SI->getTrueValue()))
260 return SI->getFalseValue();
267 bool Changed =
false;
270 for (
unsigned i = 0, e =
P->getNumIncomingValues(); i < e; ++i) {
271 Value *Incoming =
P->getIncomingValue(i);
272 if (isa<Constant>(Incoming))
continue;
276 P->setIncomingValue(i, V);
282 P->replaceAllUsesWith(V);
283 P->eraseFromParent();
297 Value *Pointer =
nullptr;
299 Pointer = L->getPointerOperand();
301 Pointer = cast<StoreInst>(
I)->getPointerOperand();
303 if (isa<Constant>(Pointer))
return false;
306 if (!
C)
return false;
309 I->replaceUsesOfWith(Pointer,
C);
318 if (Cmp->getType()->isVectorTy() ||
319 !Cmp->getOperand(0)->getType()->isIntegerTy())
322 if (!Cmp->isSigned())
330 if (UnsignedPred == ICmpInst::Predicate::BAD_ICMP_PREDICATE)
334 Cmp->setPredicate(UnsignedPred);
344 Value *Op0 = Cmp->getOperand(0);
345 Value *Op1 = 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) {
453 case Instruction::Add:
458 case Instruction::Sub:
463 case Instruction::Mul:
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,
521 Constant *Zero = ConstantInt::getNullValue(Ty);
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))
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;
681 assert(ArgNo == CB.
arg_size() &&
"Call arguments not processed correctly.");
686 NumNonNull += ArgNos.
size();
711 Instr->
getOpcode() == Instruction::SRem);
720 unsigned MinSignedBits =
730 unsigned NewWidth = std::max<unsigned>(
PowerOf2Ceil(MinSignedBits), 8);
734 if (NewWidth >= OrigWidth)
737 ++NumSDivSRemsNarrowed;
741 Instr->
getName() +
".lhs.trunc");
743 Instr->
getName() +
".rhs.trunc");
745 auto *Sext =
B.CreateSExt(BO, Instr->
getType(), Instr->
getName() +
".sext");
746 if (
auto *BinOp = dyn_cast<BinaryOperator>(BO))
747 if (BinOp->getOpcode() == Instruction::SDiv)
748 BinOp->setIsExact(Instr->
isExact());
759 Instr->
getOpcode() == Instruction::URem);
761 bool IsRem = Instr->
getOpcode() == Instruction::URem;
768 if (XCR.
icmp(ICmpInst::ICMP_ULT, YCR)) {
771 ++NumUDivURemsNarrowedExpanded;
799 if (!XCR.
icmp(ICmpInst::ICMP_ULT,
809 Value *FrozenX =
B.CreateFreeze(
X,
X->getName() +
".frozen");
810 auto *AdjX =
B.CreateNUWSub(FrozenX,
Y, Instr->
getName() +
".urem");
812 B.CreateICmp(ICmpInst::ICMP_ULT, FrozenX,
Y, Instr->
getName() +
".cmp");
813 ExpandedOp =
B.CreateSelect(Cmp, FrozenX, AdjX);
816 B.CreateICmp(ICmpInst::ICMP_UGE,
X,
Y, Instr->
getName() +
".cmp");
817 ExpandedOp =
B.CreateZExt(Cmp, Ty, Instr->
getName() +
".udiv");
822 ++NumUDivURemsNarrowedExpanded;
831 Instr->
getOpcode() == Instruction::URem);
841 unsigned NewWidth = std::max<unsigned>(
PowerOf2Ceil(MaxActiveBits), 8);
848 ++NumUDivURemsNarrowed;
852 Instr->
getName() +
".lhs.trunc");
854 Instr->
getName() +
".rhs.trunc");
856 auto *Zext =
B.CreateZExt(BO, Instr->
getType(), Instr->
getName() +
".zext");
857 if (
auto *BinOp = dyn_cast<BinaryOperator>(BO))
858 if (BinOp->getOpcode() == Instruction::UDiv)
859 BinOp->setIsExact(Instr->
isExact());
868 Instr->
getOpcode() == Instruction::URem);
904 for (Operand &Op : Ops) {
914 BinaryOperator::CreateURem(Ops[0].V, Ops[1].V, SDI->
getName(), SDI);
957 for (Operand &Op : Ops) {
967 BinaryOperator::CreateUDiv(Ops[0].V, Ops[1].V, SDI->
getName(), SDI);
969 UDiv->setIsExact(SDI->
isExact());
974 if (Ops[0].
D != Ops[1].
D)
988 Instr->
getOpcode() == Instruction::SRem);
994 if (Instr->
getOpcode() == Instruction::SDiv)
998 if (Instr->
getOpcode() == Instruction::SRem) {
1014 if (NegOneOrZero.
contains(LRange)) {
1025 ++NumAShrsConverted;
1030 BO->setIsExact(SDI->
isExact());
1047 ZExt->takeName(SDI);
1073 bool Changed =
false;
1074 bool NewNUW =
false, NewNSW =
false;
1077 Opcode, RRange, OBO::NoUnsignedWrap);
1078 NewNUW = NUWRange.
contains(LRange);
1083 Opcode, RRange, OBO::NoSignedWrap);
1084 NewNSW = NSWRange.
contains(LRange);
1101 if (!
RHS || !
RHS->getValue().isMask())
1124 auto *
C = dyn_cast<CmpInst>(V);
1125 if (!
C)
return nullptr;
1127 Value *Op0 =
C->getOperand(0);
1128 Constant *Op1 = dyn_cast<Constant>(
C->getOperand(1));
1129 if (!Op1)
return nullptr;
1132 C->getPredicate(), Op0, Op1, At,
false);
1143 bool FnChanged =
false;
1150 bool BBChanged =
false;
1152 switch (II.getOpcode()) {
1153 case Instruction::Select:
1156 case Instruction::PHI:
1157 BBChanged |=
processPHI(cast<PHINode>(&II), LVI, DT, SQ);
1159 case Instruction::ICmp:
1160 case Instruction::FCmp:
1161 BBChanged |=
processCmp(cast<CmpInst>(&II), LVI);
1163 case Instruction::Load:
1164 case Instruction::Store:
1167 case Instruction::Call:
1168 case Instruction::Invoke:
1171 case Instruction::SRem:
1172 case Instruction::SDiv:
1175 case Instruction::UDiv:
1176 case Instruction::URem:
1179 case Instruction::AShr:
1180 BBChanged |=
processAShr(cast<BinaryOperator>(&II), LVI);
1182 case Instruction::SExt:
1183 BBChanged |=
processSExt(cast<SExtInst>(&II), LVI);
1185 case Instruction::Add:
1186 case Instruction::Sub:
1187 case Instruction::Mul:
1188 case Instruction::Shl:
1189 BBChanged |=
processBinOp(cast<BinaryOperator>(&II), LVI);
1191 case Instruction::And:
1192 BBChanged |=
processAnd(cast<BinaryOperator>(&II), LVI);
1198 switch (Term->getOpcode()) {
1199 case Instruction::Switch:
1200 BBChanged |=
processSwitch(cast<SwitchInst>(Term), LVI, DT);
1202 case Instruction::Ret: {
1203 auto *RI = cast<ReturnInst>(Term);
1207 auto *RetVal = RI->getReturnValue();
1209 if (isa<Constant>(RetVal))
break;
1212 RI->replaceUsesOfWith(RetVal,
C);
1218 FnChanged |= BBChanged;
1224bool CorrelatedValuePropagation::runOnFunction(
Function &
F) {
1225 if (skipFunction(
F))
1228 LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
1229 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
This file contains the simple types necessary to represent the attributes associated with functions a...
SmallVector< MachineOperand, 4 > Cond
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...
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
This header defines various interfaces for pass management in LLVM.
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
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 getNullValue(unsigned numBits)
NOTE: This is soft-deprecated. Please use getZero() instead.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
APInt sext(unsigned width) const
Sign extend to a new 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.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
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.
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 * 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.
static 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...
BinaryOps getOpcode() const
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.
Value * getArgOperand(unsigned i) const
void setArgOperand(unsigned i, Value *v)
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="", Instruction *InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
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
Predicate getNonStrictPredicate() const
For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
This is the shared class of boolean and integer constants.
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
static ConstantInt * getTrue(LLVMContext &Context)
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.
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...
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...
ConstantRange abs(bool IntMinIsPoison=false) const
Calculate absolute value range.
bool isAllNonNegative() const
Return true if all values in this range are non-negative.
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.
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.
void applyUpdatesPermissive(ArrayRef< DominatorTree::UpdateType > Updates)
Submit updates to all available trees.
Analysis pass which computes a DominatorTree.
Legacy 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.
FunctionPass class - This class is used to implement most global optimizations.
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
Legacy wrapper pass to provide the GlobalsAAResult object.
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.
bool isExact() const LLVM_READONLY
Determine whether the exact flag is set.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
Analysis to compute lazy value information.
Wrapper around LazyValueInfo.
This pass computes, caches, and vends lazy value constraint information.
ConstantRange getConstantRangeAtUse(const Use &U, bool UndefAllowed=true)
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.
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...
An instruction for reading from memory.
This class represents min/max intrinsics.
static ICmpInst::Predicate getPredicate(Intrinsic::ID ID)
Returns the comparison predicate underlying the intrinsic.
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Pass interface - Implemented by all 'passes'.
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
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.
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.
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.
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.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
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...
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
Pass * createCorrelatedValuePropagationPass()
void initializeCorrelatedValuePropagationPass(PassRegistry &)
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q, OptimizationRemarkEmitter *ORE=nullptr)
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)
const SimplifyQuery getBestSimplifyQuery(Pass &, Function &)