15#ifndef LLVM_LIB_TRANSFORMS_INSTCOMBINE_INSTCOMBINEINTERNAL_H
16#define LLVM_LIB_TRANSFORMS_INSTCOMBINE_INSTCOMBINEINTERNAL_H
33#define DEBUG_TYPE "instcombine"
64 public InstVisitor<InstCombinerImpl, Instruction *> {
72 :
InstCombiner(Worklist, Builder, MinimizeSize, AA, AC, TLI,
TTI, DT, ORE,
96 Value *OptimizePointerDifference(
120 Value *reassociateShiftAmtsOfTwoSameDirectionShifts(
122 bool AnalyzeForSignBitExtraction =
false);
123 Instruction *canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(
125 Instruction *foldVariableSignZeroExtensionOfVariableHighBitExtract(
197 const unsigned SIOpd);
200 const Twine &Suffix =
"");
205 unsigned Depth = 0)
const {
207 Val, FMF, Interested,
Depth,
208 getSimplifyQuery().getWithInstruction(CtxI));
214 unsigned Depth = 0)
const {
216 Val, Interested,
Depth, getSimplifyQuery().getWithInstruction(CtxI));
225 Constant *TruncC = ConstantExpr::getTrunc(
C, TruncTy);
228 if (ExtTruncC && ExtTruncC ==
C)
234 return getLosslessTrunc(
C, TruncTy, Instruction::ZExt);
238 return getLosslessTrunc(
C, TruncTy, Instruction::SExt);
241 std::optional<std::pair<Intrinsic::ID, SmallVector<Value *, 3>>>
246 bool isDesirableIntType(
unsigned BitWidth)
const;
247 bool shouldChangeType(
unsigned FromBitWidth,
unsigned ToBitWidth)
const;
260 bool shouldOptimizeCast(
CastInst *CI);
281 bool transformConstExprCastCall(
CallBase &Call);
291 std::optional<std::pair<Value *, Value *>> matchSymmetricPair(
Value *
LHS,
316 OverflowResult::NeverOverflows;
322 return computeOverflowForUnsignedAdd(
LHS,
RHS, &CxtI) ==
323 OverflowResult::NeverOverflows;
328 return IsSigned ? willNotOverflowSignedAdd(
LHS,
RHS, CxtI)
329 : willNotOverflowUnsignedAdd(
LHS,
RHS, CxtI);
335 OverflowResult::NeverOverflows;
341 OverflowResult::NeverOverflows;
346 return IsSigned ? willNotOverflowSignedSub(
LHS,
RHS, CxtI)
347 : willNotOverflowUnsignedSub(
LHS,
RHS, CxtI);
353 OverflowResult::NeverOverflows;
359 OverflowResult::NeverOverflows;
364 return IsSigned ? willNotOverflowSignedMul(
LHS,
RHS, CxtI)
365 : willNotOverflowUnsignedMul(
LHS,
RHS, CxtI);
370 bool IsSigned)
const {
372 case Instruction::Add:
return willNotOverflowAdd(
LHS,
RHS, CxtI, IsSigned);
373 case Instruction::Sub:
return willNotOverflowSub(
LHS,
RHS, CxtI, IsSigned);
374 case Instruction::Mul:
return willNotOverflowMul(
LHS,
RHS, CxtI, IsSigned);
386 BinaryOperator &BO,
bool OpsFromSigned, std::array<Value *, 2> IntOps,
410 Value *simplifyIntToPtrRoundTripCast(
Value *Val);
413 bool IsAnd,
bool IsLogical =
false);
425 bool IsLogicalSelect =
false);
431 canonicalizeConditionalNegationViaMathToSelect(
BinaryOperator &i);
435 bool IsLogical =
false);
437 bool InvertFalseVal =
false);
461 auto *
SI =
new StoreInst(ConstantInt::getTrue(Ctx),
462 PoisonValue::get(PointerType::getUnqual(Ctx)),
474 assert(
I.use_empty() &&
"Cannot erase instruction that is used!");
484 Worklist.handleUseCountDecrement(
Op);
553 unsigned Depth = 0)
override;
559 const APInt &DemandedMask,
565 Value *simplifyShrShlDemandedBits(
571 bool SimplifyDemandedInstructionBits(
Instruction &Inst);
575 APInt &PoisonElts,
unsigned Depth = 0,
576 bool AllowMultipleUsers =
false)
override;
612 bool FoldWithMultiUse =
false);
636 bool foldIntegerTypedPHI(
PHINode &PN);
750 bool MatchBitReversals);
758 void tryToSinkInstructionDbgValues(
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);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu AMDGPU Register Bank Select
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.
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.
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)
InstCombinerImpl(InstructionWorklist &Worklist, BuilderTy &Builder, bool MinimizeSize, AAResults *AA, AssumptionCache &AC, TargetLibraryInfo &TLI, TargetTransformInfo &TTI, DominatorTree &DT, OptimizationRemarkEmitter &ORE, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, const DataLayout &DL, LoopInfo *LI)
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)
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.
This is a utility class that provides an abstraction for the common functionality between Instruction...
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)
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.