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(
119 Value *reassociateShiftAmtsOfTwoSameDirectionShifts(
121 bool AnalyzeForSignBitExtraction =
false);
122 Instruction *canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(
124 Instruction *foldVariableSignZeroExtensionOfVariableHighBitExtract(
196 const unsigned SIOpd);
199 const Twine &Suffix =
"");
204 unsigned Depth = 0)
const {
212 unsigned Depth = 0)
const {
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);
241 bool isDesirableIntType(
unsigned BitWidth)
const;
242 bool shouldChangeType(
unsigned FromBitWidth,
unsigned ToBitWidth)
const;
255 bool shouldOptimizeCast(
CastInst *CI);
276 bool transformConstExprCastCall(
CallBase &Call);
302 OverflowResult::NeverOverflows;
308 return computeOverflowForUnsignedAdd(
LHS,
RHS, &CxtI) ==
309 OverflowResult::NeverOverflows;
314 return IsSigned ? willNotOverflowSignedAdd(
LHS,
RHS, CxtI)
315 : willNotOverflowUnsignedAdd(
LHS,
RHS, CxtI);
321 OverflowResult::NeverOverflows;
327 OverflowResult::NeverOverflows;
332 return IsSigned ? willNotOverflowSignedSub(
LHS,
RHS, CxtI)
333 : willNotOverflowUnsignedSub(
LHS,
RHS, CxtI);
339 OverflowResult::NeverOverflows;
345 OverflowResult::NeverOverflows;
350 return IsSigned ? willNotOverflowSignedMul(
LHS,
RHS, CxtI)
351 : willNotOverflowUnsignedMul(
LHS,
RHS, CxtI);
356 bool IsSigned)
const {
358 case Instruction::Add:
return willNotOverflowAdd(
LHS,
RHS, CxtI, IsSigned);
359 case Instruction::Sub:
return willNotOverflowSub(
LHS,
RHS, CxtI, IsSigned);
360 case Instruction::Mul:
return willNotOverflowMul(
LHS,
RHS, CxtI, IsSigned);
391 Value *simplifyIntToPtrRoundTripCast(
Value *Val);
394 bool IsAnd,
bool IsLogical =
false);
406 bool IsLogicalSelect =
false);
412 canonicalizeConditionalNegationViaMathToSelect(
BinaryOperator &i);
416 bool IsLogical =
false);
418 bool InvertFalseVal =
false);
442 auto *
SI =
new StoreInst(ConstantInt::getTrue(Ctx),
443 PoisonValue::get(PointerType::getUnqual(Ctx)),
455 assert(
I.use_empty() &&
"Cannot erase instruction that is used!");
464 Worklist.handleUseCountDecrement(
Op);
529 unsigned Depth = 0)
override;
535 const APInt &DemandedMask,
541 Value *simplifyShrShlDemandedBits(
547 bool SimplifyDemandedInstructionBits(
Instruction &Inst);
551 APInt &UndefElts,
unsigned Depth = 0,
552 bool AllowMultipleUsers =
false)
override;
579 bool FoldWithMultiUse =
false);
603 bool foldIntegerTypedPHI(
PHINode &PN);
716 bool MatchBitReversals);
725 bool removeInstructionsBeforeUnreachable(
Instruction &
I);
732 void freelyInvertAllUsersOf(
Value *V,
Value *IgnoredUser =
nullptr);
744 const bool IsTrulyNegation;
751 unsigned NumValuesVisitedInThisNegator = 0;
755 using Result = std::pair<ArrayRef<Instruction *> ,
758 std::array<Value *, 2> getSortedOperandsOfBinOp(
Instruction *
I);
766 [[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 constexpr uint32_t Opcode
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.
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, const DataLayout &DL, FPClassTest InterestedClasses=fcAllFlags, unsigned Depth=0, const TargetLibraryInfo *TLI=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.