15#ifndef LLVM_LIB_TRANSFORMS_INSTCOMBINE_INSTCOMBINEINTERNAL_H
16#define LLVM_LIB_TRANSFORMS_INSTCOMBINE_INSTCOMBINEINTERNAL_H
33#define DEBUG_TYPE "instcombine"
49class BlockFrequencyInfo;
55class OptimizationRemarkEmitter;
56class ProfileSummaryInfo;
57class TargetLibraryInfo;
62 public InstVisitor<InstCombinerImpl, Instruction *> {
70 :
InstCombiner(Worklist, Builder, MinimizeSize, AA, AC, TLI,
TTI, DT, ORE,
71 BFI, BPI, PSI,
DL, LI) {}
94 Value *OptimizePointerDifference(
118 Value *reassociateShiftAmtsOfTwoSameDirectionShifts(
120 bool AnalyzeForSignBitExtraction =
false);
121 Instruction *canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(
123 Instruction *foldVariableSignZeroExtensionOfVariableHighBitExtract(
195 const unsigned SIOpd);
198 const Twine &Suffix =
"");
203 unsigned Depth = 0)
const {
205 Val, FMF, Interested,
Depth,
206 getSimplifyQuery().getWithInstruction(CtxI));
212 unsigned Depth = 0)
const {
214 Val, Interested,
Depth, getSimplifyQuery().getWithInstruction(CtxI));
223 Constant *TruncC = ConstantExpr::getTrunc(
C, TruncTy);
226 if (ExtTruncC && ExtTruncC ==
C)
232 return getLosslessTrunc(
C, TruncTy, Instruction::ZExt);
236 return getLosslessTrunc(
C, TruncTy, Instruction::SExt);
239 std::optional<std::pair<Intrinsic::ID, SmallVector<Value *, 3>>>
244 bool isDesirableIntType(
unsigned BitWidth)
const;
245 bool shouldChangeType(
unsigned FromBitWidth,
unsigned ToBitWidth)
const;
258 bool shouldOptimizeCast(
CastInst *CI);
279 bool transformConstExprCastCall(
CallBase &Call);
289 std::optional<std::pair<Value *, Value *>> matchSymmetricPair(
Value *
LHS,
314 OverflowResult::NeverOverflows;
317 bool willNotOverflowUnsignedAdd(
const WithCache<const Value *> &
LHS,
318 const WithCache<const Value *> &
RHS,
319 const Instruction &CxtI)
const {
320 return computeOverflowForUnsignedAdd(
LHS,
RHS, &CxtI) ==
321 OverflowResult::NeverOverflows;
324 bool willNotOverflowAdd(
const Value *
LHS,
const Value *
RHS,
325 const Instruction &CxtI,
bool IsSigned)
const {
326 return IsSigned ? willNotOverflowSignedAdd(
LHS,
RHS, CxtI)
327 : willNotOverflowUnsignedAdd(
LHS,
RHS, CxtI);
330 bool willNotOverflowSignedSub(
const Value *
LHS,
const Value *
RHS,
331 const Instruction &CxtI)
const {
333 OverflowResult::NeverOverflows;
336 bool willNotOverflowUnsignedSub(
const Value *
LHS,
const Value *
RHS,
337 const Instruction &CxtI)
const {
339 OverflowResult::NeverOverflows;
342 bool willNotOverflowSub(
const Value *
LHS,
const Value *
RHS,
343 const Instruction &CxtI,
bool IsSigned)
const {
344 return IsSigned ? willNotOverflowSignedSub(
LHS,
RHS, CxtI)
345 : willNotOverflowUnsignedSub(
LHS,
RHS, CxtI);
348 bool willNotOverflowSignedMul(
const Value *
LHS,
const Value *
RHS,
349 const Instruction &CxtI)
const {
351 OverflowResult::NeverOverflows;
354 bool willNotOverflowUnsignedMul(
const Value *
LHS,
const Value *
RHS,
355 const Instruction &CxtI,
356 bool IsNSW =
false)
const {
358 OverflowResult::NeverOverflows;
361 bool willNotOverflowMul(
const Value *
LHS,
const Value *
RHS,
362 const Instruction &CxtI,
bool IsSigned)
const {
363 return IsSigned ? willNotOverflowSignedMul(
LHS,
RHS, CxtI)
364 : willNotOverflowUnsignedMul(
LHS,
RHS, CxtI);
368 const Value *
RHS,
const Instruction &CxtI,
369 bool IsSigned)
const {
371 case Instruction::Add:
return willNotOverflowAdd(
LHS,
RHS, CxtI, IsSigned);
372 case Instruction::Sub:
return willNotOverflowSub(
LHS,
RHS, CxtI, IsSigned);
373 case Instruction::Mul:
return willNotOverflowMul(
LHS,
RHS, CxtI, IsSigned);
378 Value *EmitGEPOffset(GEPOperator *
GEP,
bool RewriteGEP =
false);
379 Instruction *scalarizePHI(ExtractElementInst &EI, PHINode *PN);
380 Instruction *foldBitcastExtElt(ExtractElementInst &ExtElt);
381 Instruction *foldCastedBitwiseLogic(BinaryOperator &
I);
382 Instruction *foldFBinOpOfIntCasts(BinaryOperator &
I);
384 Instruction *foldFBinOpOfIntCastsFromSign(
385 BinaryOperator &BO,
bool OpsFromSigned, std::array<Value *, 2> IntOps,
386 Constant *Op1FpC, SmallVectorImpl<WithCache<const Value *>> &OpsKnown);
387 Instruction *foldBinopOfSextBoolToSelect(BinaryOperator &
I);
388 Instruction *narrowBinOp(TruncInst &Trunc);
389 Instruction *narrowMaskedBinOp(BinaryOperator &And);
390 Instruction *narrowMathIfNoOverflow(BinaryOperator &
I);
391 Instruction *narrowFunnelShift(TruncInst &Trunc);
392 Instruction *optimizeBitCastFromPhi(CastInst &CI, PHINode *PN);
393 Instruction *matchSAddSubSat(IntrinsicInst &MinMax1);
394 Instruction *foldNot(BinaryOperator &
I);
395 Instruction *foldBinOpOfDisplacedShifts(BinaryOperator &
I);
407 Instruction::CastOps isEliminableCastPair(
const CastInst *CI1,
408 const CastInst *CI2);
409 Value *simplifyIntToPtrRoundTripCast(Value *Val);
411 Value *foldAndOrOfICmps(ICmpInst *
LHS, ICmpInst *
RHS, Instruction &
I,
412 bool IsAnd,
bool IsLogical =
false);
413 Value *foldXorOfICmps(ICmpInst *
LHS, ICmpInst *
RHS, BinaryOperator &Xor);
415 Value *foldEqOfParts(ICmpInst *Cmp0, ICmpInst *Cmp1,
bool IsAnd);
417 Value *foldAndOrOfICmpsUsingRanges(ICmpInst *ICmp1, ICmpInst *ICmp2,
423 Value *foldLogicOfFCmps(FCmpInst *
LHS, FCmpInst *
RHS,
bool IsAnd,
424 bool IsLogicalSelect =
false);
426 Instruction *foldLogicOfIsFPClass(BinaryOperator &Operator, Value *
LHS,
430 canonicalizeConditionalNegationViaMathToSelect(BinaryOperator &i);
432 Value *foldAndOrOfICmpsOfAndWithPow2(ICmpInst *
LHS, ICmpInst *
RHS,
433 Instruction *CxtI,
bool IsAnd,
434 bool IsLogical =
false);
435 Value *matchSelectFromAndOr(Value *
A, Value *
B, Value *
C, Value *
D,
436 bool InvertFalseVal =
false);
437 Value *getSelectCondition(Value *
A, Value *
B,
bool ABIsTheSame);
439 Instruction *foldLShrOverflowBit(BinaryOperator &
I);
440 Instruction *foldExtractOfOverflowIntrinsic(ExtractValueInst &EV);
441 Instruction *foldIntrinsicWithOverflowCommon(IntrinsicInst *
II);
442 Instruction *foldIntrinsicIsFPClass(IntrinsicInst &
II);
443 Instruction *foldFPSignBitOps(BinaryOperator &
I);
444 Instruction *foldFDivConstantDivisor(BinaryOperator &
I);
450 Instruction *foldAndOrOfSelectUsingImpliedCond(Value *Op, SelectInst &
SI,
453 Instruction *hoistFNegAboveFMulFDiv(Value *FNegOp, Instruction &FMFSource);
460 auto *
SI =
new StoreInst(ConstantInt::getTrue(Ctx),
461 PoisonValue::get(PointerType::getUnqual(Ctx)),
473 assert(
I.use_empty() &&
"Cannot erase instruction that is used!");
483 Worklist.handleUseCountDecrement(
Op);
551 using InstCombiner::SimplifyDemandedBits;
560 const APInt &DemandedMask,
566 Value *simplifyShrShlDemandedBits(
572 bool SimplifyDemandedInstructionBits(
Instruction &Inst);
576 APInt &PoisonElts,
unsigned Depth = 0,
577 bool AllowMultipleUsers =
false)
override;
613 bool FoldWithMultiUse =
false);
637 bool foldIntegerTypedPHI(
PHINode &PN);
751 bool MatchBitReversals);
759 void tryToSinkInstructionDbgValues(
762 void tryToSinkInstructionDbgVariableRecords(
766 bool removeInstructionsBeforeUnreachable(
Instruction &
I);
773 void freelyInvertAllUsersOf(
Value *V,
Value *IgnoredUser =
nullptr);
783 const bool IsTrulyNegation;
790 unsigned NumValuesVisitedInThisNegator = 0;
794 using Result = std::pair<ArrayRef<Instruction *> ,
797 std::array<Value *, 2> getSortedOperandsOfBinOp(
Instruction *
I);
805 [[nodiscard]] std::optional<Result> run(
Value *Root,
bool IsNSW);
amdgpu AMDGPU Register Bank Select
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static bool foldICmpWithDominatingICmp(CmpInst *Cmp, const TargetLowering &TLI)
For pattern like:
#define LLVM_LIBRARY_VISIBILITY
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static bool isSigned(unsigned int Opcode)
static constexpr unsigned NegatorMaxNodesSSO
static constexpr unsigned NegatorDefaultMaxDepth
This file provides the interface for the instcombine pass implementation.
uint64_t IntrinsicInst * II
StandardInstrumentations SI(Mod->getContext(), Debug, VerifyEach)
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
static OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const AddOperator *Add, const SimplifyQuery &SQ)
support::ulittle16_t & Lo
support::ulittle16_t & Hi
static const uint32_t IV[8]
Class for arbitrary precision integers.
This class represents a conversion between pointers from one address space to another.
an instruction to allocate memory on the stack
This class represents any memset intrinsic.
A cache of @llvm.assume calls within a function.
an instruction that atomically reads a memory location, combines it with another value,...
LLVM Basic Block Representation.
InstListType::iterator iterator
Instruction iterators...
This class represents a no-op cast from one type to another.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Conditional or Unconditional Branch instruction.
Analysis providing branch probability information.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
This class represents a function call, abstracting a target machine's calling convention.
This is the base class for all instructions that perform data casts.
This class is the base class for the comparison instructions.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
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.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
This instruction compares its operands according to the predicate given to the constructor.
This class represents a cast from floating point to signed integer.
This class represents a cast from floating point to unsigned integer.
This class represents a truncation of floating point types.
Convenience struct for specifying and reasoning about fast-math flags.
An instruction for ordering other memory operations.
This class represents a freeze function that returns random concrete value if an operand is either a ...
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
This instruction compares its operands according to the predicate given to the constructor.
This instruction inserts a single (scalar) element into a VectorType value.
This instruction inserts a struct field of array element value into an aggregate value.
bool fmulByZeroIsZero(Value *MulVal, FastMathFlags FMF, const Instruction *CtxI) const
Check if fmul MulVal, +0.0 will yield +0.0 (or signed zero is ignorable).
virtual ~InstCombinerImpl()=default
KnownFPClass computeKnownFPClass(Value *Val, FastMathFlags FMF, FPClassTest Interested=fcAllFlags, const Instruction *CtxI=nullptr, unsigned Depth=0) const
Instruction * foldVectorSelect(SelectInst &Sel)
Instruction * foldSelectValueEquivalence(SelectInst &SI, ICmpInst &ICI)
Instruction * foldSPFofSPF(Instruction *Inner, SelectPatternFlavor SPF1, Value *A, Value *B, Instruction &Outer, SelectPatternFlavor SPF2, Value *C)
Constant * getLosslessUnsignedTrunc(Constant *C, Type *TruncTy)
bool replaceInInstruction(Value *V, Value *Old, Value *New, unsigned Depth=0)
Instruction * eraseInstFromFunction(Instruction &I) override
Combiner aware instruction erasure.
Instruction * foldSelectInstWithICmp(SelectInst &SI, ICmpInst *ICI)
Constant * getLosslessTrunc(Constant *C, Type *TruncTy, unsigned ExtOp)
Instruction * visitInstruction(Instruction &I)
Specify what to return for unhandled instructions.
KnownFPClass computeKnownFPClass(Value *Val, FPClassTest Interested=fcAllFlags, const Instruction *CtxI=nullptr, unsigned Depth=0) const
Constant * getLosslessSignedTrunc(Constant *C, Type *TruncTy)
void CreateNonTerminatorUnreachable(Instruction *InsertAt)
Create and insert the idiom we use to indicate a block is unreachable without having to rewrite the C...
Instruction * visitSelectInst(SelectInst &SI)
Instruction * foldSelectOfBools(SelectInst &SI)
Instruction * foldSelectExtConst(SelectInst &Sel)
InstCombinerImpl(InstructionWorklist &Worklist, BuilderTy &Builder, bool MinimizeSize, AAResults *AA, AssumptionCache &AC, TargetLibraryInfo &TLI, TargetTransformInfo &TTI, DominatorTree &DT, OptimizationRemarkEmitter &ORE, BlockFrequencyInfo *BFI, BranchProbabilityInfo *BPI, ProfileSummaryInfo *PSI, const DataLayout &DL, LoopInfo *LI)
The core instruction combiner logic.
Base class for instruction visitors.
InstructionWorklist - This is the worklist management logic for InstCombine and other simplification ...
This class represents a cast from an integer to a pointer.
A wrapper class for inspecting calls to intrinsic functions.
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...
An instruction for reading from memory.
This class represents min/max intrinsics.
static Value * Negate(bool LHSIsZero, bool IsNSW, Value *Root, InstCombinerImpl &IC)
Attempt to negate Root.
Analysis providing profile information.
This class represents a cast from a pointer to an integer.
Return a value (possibly void), from a function.
This class represents a sign extension of integer types.
This class represents the LLVM 'select' instruction.
This instruction constructs a fixed permutation of two input vectors.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
Provides information about what library functions are available for the current target.
This class represents a truncation of integer types.
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.
This function has undefined behavior.
This represents the llvm.va_end intrinsic.
LLVM Value Representation.
LLVMContext & getContext() const
All values hold a context through their type.
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.
void salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI)
Assuming the instruction MI is going to be deleted, attempt to salvage debug users of MI by writing t...
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ, bool IsNSW=false)
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
SelectPatternFlavor
Specific patterns of select instructions we can match.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
OverflowResult computeOverflowForSignedMul(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
OverflowResult computeOverflowForUnsignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, unsigned Depth, const SimplifyQuery &SQ)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.