LLVM  6.0.0svn
Classes | Functions
llvm::PatternMatch Namespace Reference

Classes

struct  AnyBinaryOp_match
 
struct  apfloat_match
 
struct  api_pred_ty
 This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APInt. More...
 
struct  apint_match
 
struct  Argument_match
 
struct  BinaryOp_match
 
struct  bind_const_intval_ty
 
struct  bind_ty
 
struct  BinOpPred_match
 
struct  br_match
 
struct  brc_match
 
struct  CastClass_match
 
struct  class_match
 
struct  CmpClass_match
 
struct  constantint_match
 
struct  cst_pred_ty
 This helper class is used to match scalar and vector constants that satisfy a specified predicate. More...
 
struct  Exact_match
 
struct  fneg_match
 
struct  IntrinsicID_match
 Intrinsic matchers. More...
 
struct  is_bitwiselogic_op
 
struct  is_idiv_op
 
struct  is_logical_shift_op
 
struct  is_maxsignedvalue
 
struct  is_power2
 
struct  is_right_shift_op
 
struct  is_shift_op
 
struct  LoadClass_match
 
struct  m_Intrinsic_Ty
 Intrinsic matches are combinations of ID matchers, and argument matchers. More...
 
struct  m_Intrinsic_Ty< T0 >
 
struct  m_Intrinsic_Ty< T0, T1 >
 
struct  m_Intrinsic_Ty< T0, T1, T2 >
 
struct  m_Intrinsic_Ty< T0, T1, T2, T3 >
 
struct  match_all_ones
 
struct  match_any_zero
 
struct  match_combine_and
 
struct  match_combine_or
 Matching combinators. More...
 
struct  match_nan
 
struct  match_neg_zero
 
struct  match_one
 
struct  match_sign_mask
 
struct  match_zero
 
struct  MaxMin_match
 
struct  neg_match
 
struct  not_match
 
struct  ofmax_pred_ty
 Helper class for identifying ordered max predicates. More...
 
struct  ofmin_pred_ty
 Helper class for identifying ordered min predicates. More...
 
struct  OneUse_match
 
struct  OverflowingBinaryOp_match
 
struct  SelectClass_match
 
struct  Signum_match
 
struct  smax_pred_ty
 Helper class for identifying signed max predicates. More...
 
struct  smin_pred_ty
 Helper class for identifying signed min predicates. More...
 
struct  specific_fpval
 Match a specified floating point value or vector of all elements of that value. More...
 
struct  specific_intval
 Match a specified integer value or vector of all elements of that. More...
 
struct  specificval_ty
 Match a specified Value*. More...
 
struct  UAddWithOverflow_match
 
struct  ufmax_pred_ty
 Helper class for identifying unordered max predicates. More...
 
struct  ufmin_pred_ty
 Helper class for identifying unordered min predicates. More...
 
struct  umax_pred_ty
 Helper class for identifying unsigned max predicates. More...
 
struct  umin_pred_ty
 Helper class for identifying unsigned min predicates. More...
 

Functions

template<typename Val , typename Pattern >
bool match (Val *V, const Pattern &P)
 
template<typename T >
OneUse_match< Tm_OneUse (const T &SubPattern)
 
class_match< Valuem_Value ()
 Match an arbitrary value and ignore it. More...
 
class_match< BinaryOperatorm_BinOp ()
 Match an arbitrary binary operation and ignore it. More...
 
class_match< CmpInstm_Cmp ()
 Matches any compare instruction and ignore it. More...
 
class_match< ConstantIntm_ConstantInt ()
 Match an arbitrary ConstantInt and ignore it. More...
 
class_match< UndefValuem_Undef ()
 Match an arbitrary undef constant. More...
 
class_match< Constantm_Constant ()
 Match an arbitrary Constant and ignore it. More...
 
template<typename LTy , typename RTy >
match_combine_or< LTy, RTy > m_CombineOr (const LTy &L, const RTy &R)
 Combine two pattern matchers matching L || R. More...
 
template<typename LTy , typename RTy >
match_combine_and< LTy, RTy > m_CombineAnd (const LTy &L, const RTy &R)
 Combine two pattern matchers matching L && R. More...
 
match_zero m_Zero ()
 Match an arbitrary zero/null constant. More...
 
match_neg_zero m_NegZero ()
 Match an arbitrary zero/null constant. More...
 
match_any_zero m_AnyZero ()
 
  • Match an arbitrary zero/null constant.
More...
 
match_nan m_NaN ()
 Match an arbitrary NaN constant. This includes quiet and signalling nans. More...
 
match_one m_One ()
 Match an integer 1 or a vector with all elements equal to 1. More...
 
match_all_ones m_AllOnes ()
 Match an integer or vector with all bits set to true. More...
 
match_sign_mask m_SignMask ()
 Match an integer or vector with only the sign bit(s) set. More...
 
apint_match m_APInt (const APInt *&Res)
 Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt. More...
 
apfloat_match m_APFloat (const APFloat *&Res)
 Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat. More...
 
cst_pred_ty< is_power2m_Power2 ()
 Match an integer or vector power of 2. More...
 
api_pred_ty< is_power2m_Power2 (const APInt *&V)
 
cst_pred_ty< is_maxsignedvaluem_MaxSignedValue ()
 
api_pred_ty< is_maxsignedvaluem_MaxSignedValue (const APInt *&V)
 
bind_ty< Valuem_Value (Value *&V)
 Match a value, capturing it if we match. More...
 
bind_ty< const Valuem_Value (const Value *&V)
 
bind_ty< Instructionm_Instruction (Instruction *&I)
 Match an instruction, capturing it if we match. More...
 
bind_ty< BinaryOperatorm_BinOp (BinaryOperator *&I)
 Match a binary operator, capturing it if we match. More...
 
bind_ty< ConstantIntm_ConstantInt (ConstantInt *&CI)
 Match a ConstantInt, capturing the value if we match. More...
 
bind_ty< Constantm_Constant (Constant *&C)
 Match a Constant, capturing the value if we match. More...
 
bind_ty< ConstantFPm_ConstantFP (ConstantFP *&C)
 Match a ConstantFP, capturing the value if we match. More...
 
specificval_ty m_Specific (const Value *V)
 Match if we have a specific specified value. More...
 
specific_fpval m_SpecificFP (double V)
 Match a specific floating point value or vector with all elements equal to the value. More...
 
specific_fpval m_FPOne ()
 Match a float 1.0 or vector with all elements equal to 1.0. More...
 
specific_intval m_SpecificInt (uint64_t V)
 Match a specific integer value or vector with all elements equal to the value. More...
 
bind_const_intval_ty m_ConstantInt (uint64_t &V)
 Match a ConstantInt and bind to its value. More...
 
template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS > m_BinOp (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FRem > m_FRem (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::And > m_And (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrapm_NSWAdd (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrapm_NSWSub (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrapm_NSWMul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrapm_NSWShl (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrapm_NUWAdd (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrapm_NUWSub (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrapm_NUWMul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrapm_NUWShl (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_shift_opm_Shift (const LHS &L, const RHS &R)
 Matches shift operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_right_shift_opm_Shr (const LHS &L, const RHS &R)
 Matches logical shift operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_logical_shift_opm_LogicalShift (const LHS &L, const RHS &R)
 Matches logical shift operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_bitwiselogic_opm_BitwiseLogic (const LHS &L, const RHS &R)
 Matches bitwise logic operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_idiv_opm_IDiv (const LHS &L, const RHS &R)
 Matches integer division operations. More...
 
template<typename T >
Exact_match< Tm_Exact (const T &SubPattern)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, CmpInst, CmpInst::Predicatem_Cmp (CmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicatem_ICmp (ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicatem_FCmp (FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 
template<typename Cond , typename LHS , typename RHS >
SelectClass_match< Cond, LHS, RHS > m_Select (const Cond &C, const LHS &L, const RHS &R)
 
template<int64_t L, int64_t R, typename Cond >
SelectClass_match< Cond, constantint_match< L >, constantint_match< R > > m_SelectCst (const Cond &C)
 This matches a select of two constants, e.g. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::BitCast > m_BitCast (const OpTy &Op)
 Matches BitCast. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt (const OpTy &Op)
 Matches PtrToInt. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::Trunc > m_Trunc (const OpTy &Op)
 Matches Trunc. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::SExt > m_SExt (const OpTy &Op)
 Matches SExt. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::ZExt > m_ZExt (const OpTy &Op)
 Matches ZExt. More...
 
template<typename OpTy >
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > m_ZExtOrSExt (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::UIToFP > m_UIToFP (const OpTy &Op)
 Matches UIToFP. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::SIToFP > m_SIToFP (const OpTy &Op)
 Matches SIToFP. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPTrunc > m_FPTrunc (const OpTy &Op)
 Matches FPTrunc. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPExt > m_FPExt (const OpTy &Op)
 Matches FPExt. More...
 
template<typename OpTy >
LoadClass_match< OpTy > m_Load (const OpTy &Op)
 Matches LoadInst. More...
 
template<typename LHS >
not_match< LHS > m_Not (const LHS &L)
 
template<typename LHS >
neg_match< LHS > m_Neg (const LHS &L)
 Match an integer negate. More...
 
template<typename LHS >
fneg_match< LHS > m_FNeg (const LHS &L)
 Match a floating point negate. More...
 
br_match m_UnconditionalBr (BasicBlock *&Succ)
 
template<typename Cond_t >
brc_match< Cond_t > m_Br (const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_tym_SMax (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_tym_SMin (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_tym_UMax (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_tym_UMin (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_tym_OrdFMax (const LHS &L, const RHS &R)
 Match an 'ordered' floating point maximum function. More...
 
template<typename LHS , typename RHS >
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_tym_OrdFMin (const LHS &L, const RHS &R)
 Match an 'ordered' floating point minimum function. More...
 
template<typename LHS , typename RHS >
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_tym_UnordFMax (const LHS &L, const RHS &R)
 Match an 'unordered' floating point maximum function. More...
 
template<typename LHS , typename RHS >
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_tym_UnordFMin (const LHS &L, const RHS &R)
 Match an 'unordered' floating point minimum function. More...
 
template<typename LHS_t , typename RHS_t , typename Sum_t >
UAddWithOverflow_match< LHS_t, RHS_t, Sum_t > m_UAddWithOverflow (const LHS_t &L, const RHS_t &R, const Sum_t &S)
 Match an icmp instruction checking for unsigned overflow on addition. More...
 
template<unsigned OpI, typename Opnd_t >
Argument_match< Opnd_t > m_Argument (const Opnd_t &Op)
 Match an argument. More...
 
template<Intrinsic::ID IntrID>
IntrinsicID_match m_Intrinsic ()
 Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X)) More...
 
template<Intrinsic::ID IntrID, typename T0 >
m_Intrinsic_Ty< T0 >::Ty m_Intrinsic (const T0 &Op0)
 
template<Intrinsic::ID IntrID, typename T0 , typename T1 >
m_Intrinsic_Ty< T0, T1 >::Ty m_Intrinsic (const T0 &Op0, const T1 &Op1)
 
template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 >
m_Intrinsic_Ty< T0, T1, T2 >::Ty m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2)
 
template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 , typename T3 >
m_Intrinsic_Ty< T0, T1, T2, T3 >::Ty m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3)
 
template<typename Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse (const Opnd0 &Op0)
 
template<typename Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap (const Opnd0 &Op0)
 
template<typename Opnd0 , typename Opnd1 >
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMin (const Opnd0 &Op0, const Opnd1 &Op1)
 
template<typename Opnd0 , typename Opnd1 >
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax (const Opnd0 &Op0, const Opnd1 &Op1)
 
template<typename Val_t >
Signum_match< Val_t > m_Signum (const Val_t &V)
 Matches a signum pattern. More...
 
template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS, truem_c_BinOp (const LHS &L, const RHS &R)
 Matches a BinaryOperator with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, truem_c_ICmp (ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 Matches an ICmp with a predicate over LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Add, truem_c_Add (const LHS &L, const RHS &R)
 Matches a Add with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Mul, truem_c_Mul (const LHS &L, const RHS &R)
 Matches a Mul with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::And, truem_c_And (const LHS &L, const RHS &R)
 Matches an And with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Or, truem_c_Or (const LHS &L, const RHS &R)
 Matches an Or with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Xor, truem_c_Xor (const LHS &L, const RHS &R)
 Matches an Xor with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, truem_c_SMin (const LHS &L, const RHS &R)
 Matches an SMin with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, truem_c_SMax (const LHS &L, const RHS &R)
 Matches an SMax with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, truem_c_UMin (const LHS &L, const RHS &R)
 Matches a UMin with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, truem_c_UMax (const LHS &L, const RHS &R)
 Matches a UMax with LHS and RHS in either order. More...
 

Function Documentation

◆ m_Add()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Add> llvm::PatternMatch::m_Add ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_AllOnes()

match_all_ones llvm::PatternMatch::m_AllOnes ( )
inline

◆ m_And()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::And> llvm::PatternMatch::m_And ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_AnyZero()

match_any_zero llvm::PatternMatch::m_AnyZero ( )
inline

  • Match an arbitrary zero/null constant.

This includes zero_initializer for vectors and ConstantPointerNull for pointers. For floating point constants, this will match negative zero and positive zero

Definition at line 172 of file PatternMatch.h.

Referenced by SimplifyFAddInst(), SimplifyFDivInst(), SimplifyFMulInst(), SimplifyFRemInst(), and SimplifyFSubInst().

◆ m_APFloat()

apfloat_match llvm::PatternMatch::m_APFloat ( const APFloat *&  Res)
inline

Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat.

Definition at line 264 of file PatternMatch.h.

Referenced by getPow(), matchFastFloatClamp(), and SimplifyFCmpInst().

◆ m_APInt()

apint_match llvm::PatternMatch::m_APInt ( const APInt *&  Res)
inline

Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.

Definition at line 260 of file PatternMatch.h.

Referenced by canEvaluateShiftedShift(), canEvaluateTruncated(), canEvaluateZExtd(), checkForNegativeOperand(), llvm::InstCombiner::commonIDivTransforms(), llvm::InstCombiner::commonIRemTransforms(), computeKnownBits(), ComputeNumSignBitsImpl(), llvm::ConstantFoldBinaryInstruction(), createAndInstr(), llvm::decomposeBitTestICmp(), foldAndOrOfEqualityCmpsWithConstants(), foldICmpShlOne(), foldSelectICmpAndOr(), llvm::InstCombiner::FoldShiftByConstant(), foldShiftedShift(), foldUDivShl(), getBinOpsForFactorization(), GetConstantInt(), getDemandedBitsLHSMask(), getLogBase2Vector(), GetLoopInvariantInsertPosition(), getRangeForAffineARHelper(), isDivZero(), isKnownToBeAPowerOfTwo(), llvm::isSafeToSpeculativelyExecute(), isSelect01(), isTruePredicate(), llvm::RecurrenceDescriptor::lookThroughAnd(), MaintainNoSignedWrap(), matchClamp(), matchMinMax(), matchSelectPattern(), processUGT_ADDCST_ADD(), llvm::InstCombiner::replacedSelectWithOperand(), setLimitsForBinOp(), ShrinkDemandedConstant(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOrOfICmpsWithConstants(), SimplifyBSwap(), simplifyICmpWithBinOp(), simplifyICmpWithConstant(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifySelectBitTest(), simplifySelectWithICmpCond(), truncateIVUse(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitAShr(), llvm::InstCombiner::visitICmpInst(), llvm::InstCombiner::visitLShr(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitSDiv(), llvm::InstCombiner::visitShl(), llvm::InstCombiner::visitSRem(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitTrunc(), llvm::InstCombiner::visitUDiv(), llvm::InstCombiner::visitURem(), llvm::InstCombiner::visitXor(), and llvm::reassociate::XorOpnd::XorOpnd().

◆ m_Argument()

template<unsigned OpI, typename Opnd_t >
Argument_match<Opnd_t> llvm::PatternMatch::m_Argument ( const Opnd_t &  Op)
inline

Match an argument.

Definition at line 1339 of file PatternMatch.h.

◆ m_AShr()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::AShr> llvm::PatternMatch::m_AShr ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_BinOp() [1/3]

class_match<BinaryOperator> llvm::PatternMatch::m_BinOp ( )
inline

◆ m_BinOp() [2/3]

bind_ty<BinaryOperator> llvm::PatternMatch::m_BinOp ( BinaryOperator *&  I)
inline

Match a binary operator, capturing it if we match.

Definition at line 361 of file PatternMatch.h.

References I.

◆ m_BinOp() [3/3]

template<typename LHS , typename RHS >
AnyBinaryOp_match<LHS, RHS> llvm::PatternMatch::m_BinOp ( const LHS &  L,
const RHS &  R 
)
inline

Definition at line 469 of file PatternMatch.h.

References llvm::MCID::Commutable.

◆ m_BitCast()

template<typename OpTy >
CastClass_match<OpTy, Instruction::BitCast> llvm::PatternMatch::m_BitCast ( const OpTy &  Op)
inline

◆ m_BitReverse()

template<typename Opnd0 >
m_Intrinsic_Ty<Opnd0>::Ty llvm::PatternMatch::m_BitReverse ( const Opnd0 &  Op0)
inline

Definition at line 1418 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), and llvm::InstCombiner::visitCallInst().

◆ m_BitwiseLogic()

template<typename LHS , typename RHS >
BinOpPred_match<LHS, RHS, is_bitwiselogic_op> llvm::PatternMatch::m_BitwiseLogic ( const LHS &  L,
const RHS &  R 
)
inline

Matches bitwise logic operations.

Definition at line 773 of file PatternMatch.h.

Referenced by llvm::AssumptionCache::updateAffectedValues().

◆ m_Br()

template<typename Cond_t >
brc_match<Cond_t> llvm::PatternMatch::m_Br ( const Cond_t &  C,
BasicBlock *&  T,
BasicBlock *&  F 
)
inline

◆ m_BSwap()

template<typename Opnd0 >
m_Intrinsic_Ty<Opnd0>::Ty llvm::PatternMatch::m_BSwap ( const Opnd0 &  Op0)
inline

◆ m_c_Add()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Add, true> llvm::PatternMatch::m_c_Add ( const LHS &  L,
const RHS &  R 
)
inline

Matches a Add with LHS and RHS in either order.

Definition at line 1500 of file PatternMatch.h.

Referenced by SimplifyOrInst(), and llvm::InstCombiner::visitSub().

◆ m_c_And()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::And, true> llvm::PatternMatch::m_c_And ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_c_BinOp()

template<typename LHS , typename RHS >
AnyBinaryOp_match<LHS, RHS, true> llvm::PatternMatch::m_c_BinOp ( const LHS &  L,
const RHS &  R 
)
inline

Matches a BinaryOperator with LHS and RHS in either order.

Definition at line 1485 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitAnd().

◆ m_c_ICmp()

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true> llvm::PatternMatch::m_c_ICmp ( ICmpInst::Predicate Pred,
const LHS &  L,
const RHS &  R 
)
inline

Matches an ICmp with a predicate over LHS and RHS in either order.

Does not swap the predicate.

Definition at line 1493 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), and isKnownNonNullFromDominatingCondition().

◆ m_c_Mul()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Mul, true> llvm::PatternMatch::m_c_Mul ( const LHS &  L,
const RHS &  R 
)
inline

Matches a Mul with LHS and RHS in either order.

Definition at line 1507 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitSub().

◆ m_c_Or()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Or, true> llvm::PatternMatch::m_c_Or ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_c_SMax()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true> llvm::PatternMatch::m_c_SMax ( const LHS &  L,
const RHS &  R 
)
inline

Matches an SMax with LHS and RHS in either order.

Definition at line 1542 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_SMin()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true> llvm::PatternMatch::m_c_SMin ( const LHS &  L,
const RHS &  R 
)
inline

Matches an SMin with LHS and RHS in either order.

Definition at line 1536 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_UMax()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true> llvm::PatternMatch::m_c_UMax ( const LHS &  L,
const RHS &  R 
)
inline

Matches a UMax with LHS and RHS in either order.

Definition at line 1554 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_UMin()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true> llvm::PatternMatch::m_c_UMin ( const LHS &  L,
const RHS &  R 
)
inline

Matches a UMin with LHS and RHS in either order.

Definition at line 1548 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_Xor()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Xor, true> llvm::PatternMatch::m_c_Xor ( const LHS &  L,
const RHS &  R 
)
inline

Matches an Xor with LHS and RHS in either order.

Definition at line 1528 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), SimplifyOrInst(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitOr(), and llvm::InstCombiner::visitXor().

◆ m_Cmp() [1/2]

class_match<CmpInst> llvm::PatternMatch::m_Cmp ( )
inline

◆ m_Cmp() [2/2]

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate> llvm::PatternMatch::m_Cmp ( CmpInst::Predicate Pred,
const LHS &  L,
const RHS &  R 
)
inline

Definition at line 831 of file PatternMatch.h.

◆ m_CombineAnd()

template<typename LTy , typename RTy >
match_combine_and<LTy, RTy> llvm::PatternMatch::m_CombineAnd ( const LTy &  L,
const RTy &  R 
)
inline

Combine two pattern matchers matching L && R.

Definition at line 131 of file PatternMatch.h.

Referenced by m_Intrinsic().

◆ m_CombineOr()

template<typename LTy , typename RTy >
match_combine_or<LTy, RTy> llvm::PatternMatch::m_CombineOr ( const LTy &  L,
const RTy &  R 
)
inline

Combine two pattern matchers matching L || R.

Definition at line 125 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), foldVecTruncToExtElt(), m_ZExtOrSExt(), markAliveBlocks(), matchFastFloatClamp(), and scaleWeights().

◆ m_Constant() [1/2]

class_match<Constant> llvm::PatternMatch::m_Constant ( )
inline

◆ m_Constant() [2/2]

bind_ty<Constant> llvm::PatternMatch::m_Constant ( Constant *&  C)
inline

Match a Constant, capturing the value if we match.

Definition at line 367 of file PatternMatch.h.

References C.

◆ m_ConstantFP()

bind_ty<ConstantFP> llvm::PatternMatch::m_ConstantFP ( ConstantFP *&  C)
inline

Match a ConstantFP, capturing the value if we match.

Definition at line 370 of file PatternMatch.h.

References C.

◆ m_ConstantInt() [1/3]

constantint_match< Val > llvm::PatternMatch::m_ConstantInt ( )
inline

◆ m_ConstantInt() [2/3]

bind_ty<ConstantInt> llvm::PatternMatch::m_ConstantInt ( ConstantInt *&  CI)
inline

Match a ConstantInt, capturing the value if we match.

Definition at line 364 of file PatternMatch.h.

◆ m_ConstantInt() [3/3]

bind_const_intval_ty llvm::PatternMatch::m_ConstantInt ( uint64_t &  V)
inline

Match a ConstantInt and bind to its value.

This does not match ConstantInts wider than 64-bits.

Definition at line 447 of file PatternMatch.h.

◆ m_Exact()

template<typename T >
Exact_match<T> llvm::PatternMatch::m_Exact ( const T SubPattern)
inline

◆ m_FAdd()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::FAdd> llvm::PatternMatch::m_FAdd ( const LHS &  L,
const RHS &  R 
)
inline

Definition at line 508 of file PatternMatch.h.

Referenced by llvm::CannotBeNegativeZero().

◆ m_FCmp()

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate> llvm::PatternMatch::m_FCmp ( FCmpInst::Predicate Pred,
const LHS &  L,
const RHS &  R 
)
inline

Definition at line 843 of file PatternMatch.h.

◆ m_FDiv()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::FDiv> llvm::PatternMatch::m_FDiv ( const LHS &  L,
const RHS &  R 
)
inline

Definition at line 550 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitFDiv().

◆ m_FMax()

template<typename Opnd0 , typename Opnd1 >
m_Intrinsic_Ty<Opnd0, Opnd1>::Ty llvm::PatternMatch::m_FMax ( const Opnd0 &  Op0,
const Opnd1 &  Op1 
)
inline

Definition at line 1434 of file PatternMatch.h.

Referenced by simplifyMinnumMaxnum().

◆ m_FMin()

template<typename Opnd0 , typename Opnd1 >
m_Intrinsic_Ty<Opnd0, Opnd1>::Ty llvm::PatternMatch::m_FMin ( const Opnd0 &  Op0,
const Opnd1 &  Op1 
)
inline

Definition at line 1428 of file PatternMatch.h.

Referenced by simplifyMinnumMaxnum().

◆ m_FMul()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::FMul> llvm::PatternMatch::m_FMul ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_FNeg()

template<typename LHS >
fneg_match<LHS> llvm::PatternMatch::m_FNeg ( const LHS &  L)
inline

Match a floating point negate.

Definition at line 1051 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitFCmpInst(), and llvm::InstCombiner::visitFDiv().

◆ m_FPExt()

template<typename OpTy >
CastClass_match<OpTy, Instruction::FPExt> llvm::PatternMatch::m_FPExt ( const OpTy &  Op)
inline

Matches FPExt.

Definition at line 955 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitCallInst().

◆ m_FPOne()

specific_fpval llvm::PatternMatch::m_FPOne ( )
inline

Match a float 1.0 or vector with all elements equal to 1.0.

Definition at line 407 of file PatternMatch.h.

References m_SpecificFP().

Referenced by llvm::AMDGPUTTIImpl::getArithmeticInstrCost(), SimplifyFDivInst(), SimplifyFMulInst(), and llvm::InstCombiner::visitCallInst().

◆ m_FPTrunc()

template<typename OpTy >
CastClass_match<OpTy, Instruction::FPTrunc> llvm::PatternMatch::m_FPTrunc ( const OpTy &  Op)
inline

Matches FPTrunc.

Definition at line 949 of file PatternMatch.h.

◆ m_FRem()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::FRem> llvm::PatternMatch::m_FRem ( const LHS &  L,
const RHS &  R 
)
inline

Definition at line 568 of file PatternMatch.h.

◆ m_FSub()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::FSub> llvm::PatternMatch::m_FSub ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_ICmp()

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate> llvm::PatternMatch::m_ICmp ( ICmpInst::Predicate Pred,
const LHS &  L,
const RHS &  R 
)
inline

◆ m_IDiv()

template<typename LHS , typename RHS >
BinOpPred_match<LHS, RHS, is_idiv_op> llvm::PatternMatch::m_IDiv ( const LHS &  L,
const RHS &  R 
)
inline

Matches integer division operations.

Definition at line 779 of file PatternMatch.h.

Referenced by isKnownNonZero(), and SimplifyMulInst().

◆ m_Instruction()

bind_ty<Instruction> llvm::PatternMatch::m_Instruction ( Instruction *&  I)
inline

◆ m_Intrinsic() [1/5]

template<Intrinsic::ID IntrID>
IntrinsicID_match llvm::PatternMatch::m_Intrinsic ( )
inline

Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))

Definition at line 1388 of file PatternMatch.h.

◆ m_Intrinsic() [2/5]

template<Intrinsic::ID IntrID, typename T0 >
m_Intrinsic_Ty<T0>::Ty llvm::PatternMatch::m_Intrinsic ( const T0 &  Op0)
inline

Definition at line 1393 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [3/5]

template<Intrinsic::ID IntrID, typename T0 , typename T1 >
m_Intrinsic_Ty<T0, T1>::Ty llvm::PatternMatch::m_Intrinsic ( const T0 &  Op0,
const T1 Op1 
)
inline

Definition at line 1398 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [4/5]

template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 >
m_Intrinsic_Ty<T0, T1, T2>::Ty llvm::PatternMatch::m_Intrinsic ( const T0 &  Op0,
const T1 Op1,
const T2 &  Op2 
)
inline

Definition at line 1405 of file PatternMatch.h.

References m_CombineAnd(), and T1.

◆ m_Intrinsic() [5/5]

template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 , typename T3 >
m_Intrinsic_Ty<T0, T1, T2, T3>::Ty llvm::PatternMatch::m_Intrinsic ( const T0 &  Op0,
const T1 Op1,
const T2 &  Op2,
const T3 &  Op3 
)
inline

Definition at line 1412 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Load()

template<typename OpTy >
LoadClass_match<OpTy> llvm::PatternMatch::m_Load ( const OpTy &  Op)
inline

Matches LoadInst.

Definition at line 976 of file PatternMatch.h.

Referenced by isMinMaxWithLoads(), and removeBitcastsFromLoadStoreOnMinMax().

◆ m_LogicalShift()

template<typename LHS , typename RHS >
BinOpPred_match<LHS, RHS, is_logical_shift_op> llvm::PatternMatch::m_LogicalShift ( const LHS &  L,
const RHS &  R 
)
inline

Matches logical shift operations.

Definition at line 766 of file PatternMatch.h.

Referenced by foldVecTruncToExtElt(), and llvm::InstCombiner::visitAnd().

◆ m_LShr()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::LShr> llvm::PatternMatch::m_LShr ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_MaxSignedValue() [1/2]

cst_pred_ty<is_maxsignedvalue> llvm::PatternMatch::m_MaxSignedValue ( )
inline

Definition at line 337 of file PatternMatch.h.

◆ m_MaxSignedValue() [2/2]

api_pred_ty<is_maxsignedvalue> llvm::PatternMatch::m_MaxSignedValue ( const APInt *&  V)
inline

Definition at line 338 of file PatternMatch.h.

◆ m_Mul()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Mul> llvm::PatternMatch::m_Mul ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NaN()

match_nan llvm::PatternMatch::m_NaN ( )
inline

Match an arbitrary NaN constant. This includes quiet and signalling nans.

Definition at line 183 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitCallInst().

◆ m_Neg()

template<typename LHS >
neg_match<LHS> llvm::PatternMatch::m_Neg ( const LHS &  L)
inline

◆ m_NegZero()

match_neg_zero llvm::PatternMatch::m_NegZero ( )
inline

Match an arbitrary zero/null constant.

This includes zero_initializer for vectors and ConstantPointerNull for pointers. For floating point constants, this will match negative zero but not positive zero

Definition at line 159 of file PatternMatch.h.

Referenced by SimplifyFAddInst(), and SimplifyFSubInst().

◆ m_Not()

template<typename LHS >
not_match<LHS> llvm::PatternMatch::m_Not ( const LHS &  L)
inline

◆ m_NSWAdd()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap> llvm::PatternMatch::m_NSWAdd ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NSWMul()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap> llvm::PatternMatch::m_NSWMul ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NSWShl()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap> llvm::PatternMatch::m_NSWShl ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NSWSub()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap> llvm::PatternMatch::m_NSWSub ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NUWAdd()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap> llvm::PatternMatch::m_NUWAdd ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NUWMul()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap> llvm::PatternMatch::m_NUWMul ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NUWShl()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap> llvm::PatternMatch::m_NUWShl ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_NUWSub()

template<typename LHS , typename RHS >
OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap> llvm::PatternMatch::m_NUWSub ( const LHS &  L,
const RHS &  R 
)
inline

Definition at line 678 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoUnsignedWrap.

◆ m_One()

match_one llvm::PatternMatch::m_One ( )
inline

◆ m_OneUse()

template<typename T >
OneUse_match<T> llvm::PatternMatch::m_OneUse ( const T SubPattern)
inline

◆ m_Or()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Or> llvm::PatternMatch::m_Or ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_OrdFMax()

template<typename LHS , typename RHS >
MaxMin_match<FCmpInst, LHS, RHS, ofmax_pred_ty> llvm::PatternMatch::m_OrdFMax ( const LHS &  L,
const RHS &  R 
)
inline

Match an 'ordered' floating point maximum function.

Floating point has one special value 'NaN'. Therefore, there is no total order. However, if we can ignore the 'NaN' value (for example, because of a 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum' semantics. In the presence of 'NaN' we have to preserve the original select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.

                    max(L, R)  iff L and R are not NaN

m_OrdFMax(L, R) = R iff L or R are NaN

Definition at line 1229 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), and matchFastFloatClamp().

◆ m_OrdFMin()

template<typename LHS , typename RHS >
MaxMin_match<FCmpInst, LHS, RHS, ofmin_pred_ty> llvm::PatternMatch::m_OrdFMin ( const LHS &  L,
const RHS &  R 
)
inline

Match an 'ordered' floating point minimum function.

Floating point has one special value 'NaN'. Therefore, there is no total order. However, if we can ignore the 'NaN' value (for example, because of a 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum' semantics. In the presence of 'NaN' we have to preserve the original select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.

                    min(L, R)  iff L and R are not NaN

m_OrdFMin(L, R) = R iff L or R are NaN

Definition at line 1244 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), and matchFastFloatClamp().

◆ m_Power2() [1/2]

cst_pred_ty<is_power2> llvm::PatternMatch::m_Power2 ( )
inline

◆ m_Power2() [2/2]

api_pred_ty<is_power2> llvm::PatternMatch::m_Power2 ( const APInt *&  V)
inline

Definition at line 331 of file PatternMatch.h.

◆ m_PtrToInt()

template<typename OpTy >
CastClass_match<OpTy, Instruction::PtrToInt> llvm::PatternMatch::m_PtrToInt ( const OpTy &  Op)
inline

◆ m_SDiv()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::SDiv> llvm::PatternMatch::m_SDiv ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Select()

template<typename Cond , typename LHS , typename RHS >
SelectClass_match<Cond, LHS, RHS> llvm::PatternMatch::m_Select ( const Cond &  C,
const LHS &  L,
const RHS &  R 
)
inline

◆ m_SelectCst()

template<int64_t L, int64_t R, typename Cond >
SelectClass_match<Cond, constantint_match<L>, constantint_match<R> > llvm::PatternMatch::m_SelectCst ( const Cond &  C)
inline

This matches a select of two constants, e.g.

: m_SelectCst<-1, 0>(m_Value(V))

Definition at line 878 of file PatternMatch.h.

References m_Select().

◆ m_SExt()

template<typename OpTy >
CastClass_match<OpTy, Instruction::SExt> llvm::PatternMatch::m_SExt ( const OpTy &  Op)
inline

◆ m_Shift()

template<typename LHS , typename RHS >
BinOpPred_match<LHS, RHS, is_shift_op> llvm::PatternMatch::m_Shift ( const LHS &  L,
const RHS &  R 
)
inline

Matches shift operations.

Definition at line 751 of file PatternMatch.h.

Referenced by llvm::AssumptionCache::updateAffectedValues().

◆ m_Shl()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Shl> llvm::PatternMatch::m_Shl ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Shr()

template<typename LHS , typename RHS >
BinOpPred_match<LHS, RHS, is_right_shift_op> llvm::PatternMatch::m_Shr ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_SignMask()

match_sign_mask llvm::PatternMatch::m_SignMask ( )
inline

Match an integer or vector with only the sign bit(s) set.

Definition at line 216 of file PatternMatch.h.

Referenced by isKnownToBeAPowerOfTwo(), and SimplifyAddInst().

◆ m_Signum()

template<typename Val_t >
Signum_match<Val_t> llvm::PatternMatch::m_Signum ( const Val_t &  V)
inline

Matches a signum pattern.

signum(x) = x > 0 -> 1 x == 0 -> 0 x < 0 -> -1

Definition at line 1475 of file PatternMatch.h.

Referenced by processUGT_ADDCST_ADD().

◆ m_SIToFP()

template<typename OpTy >
CastClass_match<OpTy, Instruction::SIToFP> llvm::PatternMatch::m_SIToFP ( const OpTy &  Op)
inline

Matches SIToFP.

Definition at line 943 of file PatternMatch.h.

◆ m_SMax()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty> llvm::PatternMatch::m_SMax ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_SMin()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty> llvm::PatternMatch::m_SMin ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Specific()

specificval_ty llvm::PatternMatch::m_Specific ( const Value V)
inline

Match if we have a specific specified value.

Definition at line 382 of file PatternMatch.h.

Referenced by llvm::InstCombiner::commonIDivTransforms(), computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), foldAndOrOfEqualityCmpsWithConstants(), foldAndToXor(), foldICmpShlOne(), foldICmpWithMinMax(), foldOrToXor(), foldSelectICmpAndOr(), llvm::InstCombiner::FoldShiftByConstant(), foldVecTruncToExtElt(), foldXorToXor(), getBinOpsForFactorization(), GetLoopInvariantInsertPosition(), getSelectCondition(), getValueFromICmpCondition(), isKnownNonNullFromDominatingCondition(), isKnownNonZero(), isKnownToBeAPowerOfTwo(), isMinMaxWithLoads(), isObjectDereferencedInBlock(), isTruePredicate(), matchClamp(), matchFastFloatClamp(), matchMinMax(), matchSelectFromAndOr(), matchSelectPattern(), processUGT_ADDCST_ADD(), replaceAllUsesOfWithIn(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOfICmpsWithSameOperands(), SimplifyAShrInst(), simplifyDiv(), SimplifyFAddInst(), SimplifyGEPInst(), simplifyICmpWithBinOp(), SimplifyLShrInst(), SimplifyMulInst(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifyOrOfICmpsWithSameOperands(), simplifyRem(), simplifySelectBitTest(), SimplifyShlInst(), simplifyUnsignedRangeCheck(), SimplifyXorInst(), truncateIVUse(), tryToMoveFreeBeforeNullTest(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitAShr(), llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitGetElementPtrInst(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitShl(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitXor(), and llvm::InstCombiner::visitZExt().

◆ m_SpecificFP()

specific_fpval llvm::PatternMatch::m_SpecificFP ( double  V)
inline

Match a specific floating point value or vector with all elements equal to the value.

Definition at line 404 of file PatternMatch.h.

Referenced by detectLog2OfHalf(), getPow(), m_FPOne(), and llvm::InstCombiner::visitFMul().

◆ m_SpecificInt()

specific_intval llvm::PatternMatch::m_SpecificInt ( uint64_t  V)
inline

Match a specific integer value or vector with all elements equal to the value.

Definition at line 443 of file PatternMatch.h.

Referenced by foldSelectICmpAndOr(), foldVecTruncToExtElt(), llvm::PatternMatch::Signum_match< Opnd_t >::match(), SimplifyGEPInst(), and splitMergedValStore().

◆ m_SRem()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::SRem> llvm::PatternMatch::m_SRem ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Sub()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Sub> llvm::PatternMatch::m_Sub ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Trunc()

template<typename OpTy >
CastClass_match<OpTy, Instruction::Trunc> llvm::PatternMatch::m_Trunc ( const OpTy &  Op)
inline

◆ m_UAddWithOverflow()

template<typename LHS_t , typename RHS_t , typename Sum_t >
UAddWithOverflow_match<LHS_t, RHS_t, Sum_t> llvm::PatternMatch::m_UAddWithOverflow ( const LHS_t &  L,
const RHS_t &  R,
const Sum_t &  S 
)

Match an icmp instruction checking for unsigned overflow on addition.

S is matched to the addition whose result is being checked for overflow, and L and R are matched to the LHS and RHS of S.

Definition at line 1321 of file PatternMatch.h.

Referenced by CombineUAddWithOverflow(), and llvm::InstCombiner::visitICmpInst().

◆ m_UDiv()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::UDiv> llvm::PatternMatch::m_UDiv ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_UIToFP()

template<typename OpTy >
CastClass_match<OpTy, Instruction::UIToFP> llvm::PatternMatch::m_UIToFP ( const OpTy &  Op)
inline

Matches UIToFP.

Definition at line 937 of file PatternMatch.h.

◆ m_UMax()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty> llvm::PatternMatch::m_UMax ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_UMin()

template<typename LHS , typename RHS >
MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty> llvm::PatternMatch::m_UMin ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_UnconditionalBr()

br_match llvm::PatternMatch::m_UnconditionalBr ( BasicBlock *&  Succ)
inline

Definition at line 1074 of file PatternMatch.h.

Referenced by tryToMoveFreeBeforeNullTest().

◆ m_Undef()

class_match<UndefValue> llvm::PatternMatch::m_Undef ( )
inline

◆ m_UnordFMax()

template<typename LHS , typename RHS >
MaxMin_match<FCmpInst, LHS, RHS, ufmax_pred_ty> llvm::PatternMatch::m_UnordFMax ( const LHS &  L,
const RHS &  R 
)
inline

Match an 'unordered' floating point maximum function.

Floating point has one special value 'NaN'. Therefore, there is no total order. However, if we can ignore the 'NaN' value (for example, because of a 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum' semantics. In the presence of 'NaN' we have to preserve the original select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.

                    max(L, R)  iff L and R are not NaN

m_UnordFMax(L, R) = L iff L or R are NaN

Definition at line 1260 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), and matchFastFloatClamp().

◆ m_UnordFMin()

template<typename LHS , typename RHS >
MaxMin_match<FCmpInst, LHS, RHS, ufmin_pred_ty> llvm::PatternMatch::m_UnordFMin ( const LHS &  L,
const RHS &  R 
)
inline

Match an 'unordered' floating point minimum function.

Floating point has one special value 'NaN'. Therefore, there is no total order. However, if we can ignore the 'NaN' value (for example, because of a 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum' semantics. In the presence of 'NaN' we have to preserve the original select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.

                     min(L, R)  iff L and R are not NaN

m_UnordFMin(L, R) = L iff L or R are NaN

Definition at line 1275 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), and matchFastFloatClamp().

◆ m_URem()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::URem> llvm::PatternMatch::m_URem ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Value() [1/3]

class_match<Value> llvm::PatternMatch::m_Value ( )
inline

Match an arbitrary value and ignore it.

Definition at line 72 of file PatternMatch.h.

Referenced by canEvaluateShifted(), llvm::CannotBeNegativeZero(), checkForNegativeOperand(), llvm::collectCmpOps(), CombineUAddWithOverflow(), llvm::InstCombiner::commonIDivTransforms(), llvm::InstCombiner::commonShiftTransforms(), computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), llvm::JumpThreadingPass::ComputeValueKnownInPredecessors(), createRdxShuffleMask(), llvm::createSeparateConstOffsetFromGEPPass(), llvm::decomposeBitTestICmp(), EvaluateConstantChrecAtConstant(), llvm::findScalarElement(), foldAndOrOfEqualityCmpsWithConstants(), foldAndToXor(), foldBitCastBitwiseLogic(), foldBitCastSelect(), foldICmpShlOne(), foldICmpWithMinMax(), foldLogicCastConstant(), foldOrToXor(), foldSelectICmpAnd(), foldSelectICmpAndOr(), llvm::InstCombiner::FoldShiftByConstant(), foldUDivShl(), foldVecTruncToExtElt(), foldXorToXor(), getBinOpsForFactorization(), GetConstantInt(), GetLoopInvariantInsertPosition(), getMaskedTypeForICmpPair(), getPow(), getRangeForAffineARHelper(), getReductionData(), getSelectCondition(), getSelectFoldableConstant(), hasOnlyOneNonZeroIndex(), hoistInsEltConst(), isGEPFoldable(), isImpliedCondAndOr(), isKnownNonZero(), IsKnownPredicateViaMinOrMax(), isKnownToBeAPowerOfTwo(), llvm::ScalarEvolution::isLoopInvariantPredicate(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), isMinMaxWithLoads(), isObjectDereferencedInBlock(), isOnlyReachableViaThisEdge(), isTruePredicate(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), llvm::PatternMatch::Signum_match< Opnd_t >::match(), matchDeMorgansLaws(), matchesAdd(), matchesOr(), matchSelectFromAndOr(), narrowUDivURem(), operator<<(), processUGT_ADDCST_ADD(), processUMulZExtIdiom(), recordCondition(), removeBitcastsFromLoadStoreOnMinMax(), replaceAllUsesOfWithIn(), llvm::InstCombiner::replacedSelectWithOperand(), llvm::LoopPredicationPass::run(), scaleWeights(), ShrinkDemandedConstant(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOfICmpsWithSameOperands(), SimplifyAShrInst(), SimplifyBSwap(), simplifyDiv(), SimplifyFSubInst(), SimplifyGEPInst(), simplifyICmpWithBinOp(), simplifyICmpWithMinMax(), SimplifyLShrInst(), simplifyMinnumMaxnum(), SimplifyMulInst(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifyOrOfICmpsWithSameOperands(), simplifyRem(), simplifySelectWithICmpCond(), SimplifyShlInst(), SimplifySubInst(), simplifyUnsignedRangeCheck(), simplifyValueKnownNonZero(), splitMergedValStore(), truncateIVUse(), llvm::AssumptionCache::updateAffectedValues(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitAShr(), llvm::InstCombiner::visitBranchInst(), llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitFCmpInst(), llvm::InstCombiner::visitFDiv(), llvm::InstCombiner::visitFMul(), llvm::InstCombiner::visitGetElementPtrInst(), llvm::InstCombiner::visitICmpInst(), llvm::InstCombiner::visitLShr(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitSDiv(), llvm::InstCombiner::visitSExt(), llvm::InstCombiner::visitShl(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitSwitchInst(), llvm::InstCombiner::visitTrunc(), llvm::InstCombiner::visitUDiv(), visitUDivOperand(), llvm::InstCombiner::visitXor(), and llvm::InstCombiner::visitZExt().

◆ m_Value() [2/3]

bind_ty<Value> llvm::PatternMatch::m_Value ( Value *&  V)
inline

Match a value, capturing it if we match.

Definition at line 355 of file PatternMatch.h.

◆ m_Value() [3/3]

bind_ty<const Value> llvm::PatternMatch::m_Value ( const Value *&  V)
inline

Definition at line 356 of file PatternMatch.h.

◆ m_Xor()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, Instruction::Xor> llvm::PatternMatch::m_Xor ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_Zero()

match_zero llvm::PatternMatch::m_Zero ( )
inline

◆ m_ZExt()

template<typename OpTy >
CastClass_match<OpTy, Instruction::ZExt> llvm::PatternMatch::m_ZExt ( const OpTy &  Op)
inline

◆ m_ZExtOrSExt()

template<typename OpTy >
match_combine_or<CastClass_match<OpTy, Instruction::ZExt>, CastClass_match<OpTy, Instruction::SExt> > llvm::PatternMatch::m_ZExtOrSExt ( const OpTy &  Op)
inline

Definition at line 931 of file PatternMatch.h.

References m_CombineOr(), m_SExt(), and m_ZExt().

Referenced by foldVecTruncToExtElt(), and llvm::InstCombiner::visitCallInst().

◆ match()

template<typename Val , typename Pattern >
bool llvm::PatternMatch::match ( Val *  V,
const Pattern &  P 
)

Definition at line 49 of file PatternMatch.h.

References P.

Referenced by areInverseVectorBitmasks(), canEvaluateShifted(), canEvaluateShiftedShift(), canEvaluateTruncated(), canEvaluateZExtd(), llvm::CannotBeNegativeZero(), canonicalizeICmpBool(), checkForNegativeOperand(), llvm::collectCmpOps(), combineInstructionsOverFunction(), CombineUAddWithOverflow(), llvm::InstCombiner::commonIDivTransforms(), llvm::InstCombiner::commonIRemTransforms(), llvm::InstCombiner::commonShiftTransforms(), computeKnownBits(), computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), ComputeNumSignBitsImpl(), llvm::JumpThreadingPass::ComputeValueKnownInPredecessors(), llvm::ConstantFoldBinaryInstruction(), createAndInstr(), createRdxShuffleMask(), llvm::createSeparateConstOffsetFromGEPPass(), llvm::decomposeBitTestICmp(), despeculateCountZeros(), detectLog2OfHalf(), EvaluateConstantChrecAtConstant(), llvm::findScalarElement(), foldAndOrOfEqualityCmpsWithConstants(), foldAndToXor(), foldBitCastBitwiseLogic(), foldBitCastSelect(), foldConstantInsEltIntoShuffle(), foldCttzCtlz(), foldICmpShlOne(), foldICmpWithMinMax(), foldLogicCastConstant(), foldOrToXor(), foldSelectICmpAnd(), foldSelectICmpAndOr(), llvm::InstCombiner::FoldShiftByConstant(), foldShiftedShift(), foldUDivShl(), foldVecTruncToExtElt(), foldXorToXor(), llvm::AMDGPUTTIImpl::getArithmeticInstrCost(), getBinOpsForFactorization(), GetConstantInt(), getDemandedBitsLHSMask(), llvm::getGEPInductionOperand(), getLogBase2Vector(), GetLoopInvariantInsertPosition(), getMaskedTypeForICmpPair(), getPow(), getRangeForAffineARHelper(), getReductionData(), llvm::SCEVExpander::getRelatedExistingExpansion(), getSelectCondition(), getSelectFoldableConstant(), llvm::DenseMapInfo< CallValue >::getTombstoneKey(), getValueFromICmpCondition(), hasOnlyOneNonZeroIndex(), hoistInsEltConst(), isDivZero(), isGEPFoldable(), llvm::isGuaranteedToTransferExecutionToSuccessor(), isImpliedCondAndOr(), isKnownNonNullFromDominatingCondition(), isKnownNonZero(), IsKnownPredicateViaMinOrMax(), isKnownToBeAPowerOfTwo(), llvm::ScalarEvolution::isLoopInvariantPredicate(), isLoopNeverExecuted(), isMinMaxWithLoads(), isObjectDereferencedInBlock(), isOnlyReachableViaThisEdge(), llvm::isSafeToSpeculativelyExecute(), isSelect01(), isTruePredicate(), llvm::RecurrenceDescriptor::lookThroughAnd(), lookThroughCast(), MaintainNoSignedWrap(), markAliveBlocks(), llvm::PatternMatch::MaxMin_match< CmpInst_t, LHS_t, RHS_t, Pred_t, Commutable >::match(), matchClamp(), matchDeMorgansLaws(), matchesAdd(), matchesOr(), matchFastFloatClamp(), matchMinMax(), matchSelectFromAndOr(), matchSelectPattern(), narrowUDivURem(), operator<<(), PickMostRelevantLoop(), llvm::JumpThreadingPass::ProcessGuards(), processUGT_ADDCST_ADD(), processUMulZExtIdiom(), recordCondition(), llvm::AssumptionCache::registerAssumption(), removeBitcastsFromLoadStoreOnMinMax(), replaceAllUsesOfWithIn(), llvm::InstCombiner::replacedSelectWithOperand(), llvm::LoopPredicationPass::run(), scaleWeights(), setLimitsForBinOp(), shouldMergeGEPs(), ShrinkDemandedConstant(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOfICmpsWithSameOperands(), simplifyAndOrOfICmpsWithConstants(), SimplifyAShrInst(), simplifyAssocCastAssoc(), SimplifyBSwap(), simplifyDiv(), simplifyDivRem(), llvm::InstCombiner::simplifyDivRemOfSelectWithZeroOp(), SimplifyFAddInst(), SimplifyFCmpInst(), SimplifyFDivInst(), SimplifyFMulInst(), SimplifyFRemInst(), SimplifyFSubInst(), SimplifyGEPInst(), simplifyICmpOfBools(), simplifyICmpWithBinOp(), simplifyICmpWithConstant(), simplifyICmpWithMinMax(), simplifyICmpWithZero(), SimplifyInsertValueInst(), SimplifyIntrinsic(), SimplifyLShrInst(), simplifyMinnumMaxnum(), SimplifyMulInst(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifyOrOfICmpsWithSameOperands(), simplifyRem(), SimplifyRightShift(), simplifySelectBitTest(), simplifySelectWithICmpCond(), SimplifyShift(), SimplifyShlInst(), SimplifySubInst(), simplifyUnsignedRangeCheck(), simplifyValueKnownNonZero(), SimplifyXorInst(), splitMergedValStore(), ThreadCmpOverSelect(), truncateIVUse(), tryToMoveFreeBeforeNullTest(), llvm::AssumptionCache::updateAffectedValues(), llvm::AssumptionCacheTracker::verifyAnalysis(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitAShr(), llvm::InstCombiner::visitBranchInst(), llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitFCmpInst(), llvm::InstCombiner::visitFDiv(), llvm::InstCombiner::visitFMul(), llvm::InstCombiner::visitFSub(), llvm::InstCombiner::visitGetElementPtrInst(), llvm::InstCombiner::visitICmpInst(), llvm::InstCombiner::visitLShr(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitPHINode(), llvm::InstCombiner::visitSDiv(), llvm::InstCombiner::visitSExt(), llvm::InstCombiner::visitShl(), llvm::InstCombiner::visitSRem(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitSwitchInst(), llvm::InstCombiner::visitTrunc(), llvm::InstCombiner::visitUDiv(), visitUDivOperand(), llvm::InstCombiner::visitURem(), llvm::InstCombiner::visitXor(), llvm::InstCombiner::visitZExt(), and llvm::reassociate::XorOpnd::XorOpnd().