LLVM  14.0.0git
Classes | Typedefs | Functions
llvm::PatternMatch Namespace Reference

Classes

struct  AnyBinaryOp_match
 
struct  AnyUnaryOp_match
 
struct  apf_pred_ty
 This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APFloat. More...
 
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  cstval_pred_ty
 This helper class is used to match constant scalars, vector splats, and fixed width vectors that satisfy a specified predicate. More...
 
struct  deferredval_ty
 Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers. More...
 
struct  Exact_match
 
struct  ExtractValue_match
 
struct  FNeg_match
 
struct  icmp_pred_with_threshold
 
struct  InsertValue_match
 Matcher for a single index InsertValue instruction. More...
 
struct  IntrinsicID_match
 Intrinsic matchers. More...
 
struct  is_all_ones
 
struct  is_any_apint
 
struct  is_any_zero_fp
 
struct  is_bitwiselogic_op
 
struct  is_finite
 
struct  is_finitenonzero
 
struct  is_idiv_op
 
struct  is_inf
 
struct  is_irem_op
 
struct  is_logical_shift_op
 
struct  is_lowbit_mask
 
struct  is_maxsignedvalue
 
struct  is_nan
 
struct  is_neg_zero_fp
 
struct  is_negated_power2
 
struct  is_negative
 
struct  is_non_zero_fp
 
struct  is_noninf
 
struct  is_nonnan
 
struct  is_nonnegative
 
struct  is_nonpositive
 
struct  is_one
 
struct  is_pos_zero_fp
 
struct  is_power2
 
struct  is_power2_or_zero
 
struct  is_right_shift_op
 
struct  is_shift_op
 
struct  is_sign_mask
 
struct  is_strictlypositive
 
struct  is_zero
 
struct  is_zero_int
 
struct  LogicalOp_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  m_Intrinsic_Ty< T0, T1, T2, T3, T4 >
 
struct  m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >
 
struct  m_Mask
 
struct  m_SpecificMask
 
struct  m_SplatOrUndefMask
 
struct  m_ZeroMask
 
struct  match_combine_and
 
struct  match_combine_or
 Matching combinators. More...
 
struct  match_unless
 Inverting matcher. More...
 
struct  MaxMin_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  OneOps_match
 Matches instructions with Opcode and three operands. More...
 
struct  OneUse_match
 
struct  OverflowingBinaryOp_match
 
struct  Shuffle_match
 Matches shuffle. More...
 
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_bbval
 Match a specified basic block value. 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 value. More...
 
struct  specificval_ty
 Match a specified Value*. More...
 
struct  ThreeOps_match
 Matches instructions with Opcode and three operands. More...
 
struct  TwoOps_match
 Matches instructions with Opcode and three operands. 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...
 
struct  undef_match
 
struct  VScaleVal_match
 Matches patterns for vscale. More...
 

Typedefs

template<typename Predicate >
using cst_pred_ty = cstval_pred_ty< Predicate, ConstantInt >
 specialization of cstval_pred_ty for ConstantInt More...
 
template<typename Predicate >
using cstfp_pred_ty = cstval_pred_ty< Predicate, ConstantFP >
 specialization of cstval_pred_ty for ConstantFP More...
 

Functions

template<typename Val , typename Pattern >
bool match (Val *V, const Pattern &P)
 
template<typename Pattern >
bool match (ArrayRef< int > Mask, 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< UnaryOperatorm_UnOp ()
 Match an arbitrary unary operation 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...
 
auto m_Undef ()
 Match an arbitrary undef constant. More...
 
class_match< PoisonValuem_Poison ()
 Match an arbitrary poison constant. More...
 
class_match< Constantm_Constant ()
 Match an arbitrary Constant and ignore it. More...
 
class_match< ConstantIntm_ConstantInt ()
 Match an arbitrary ConstantInt and ignore it. More...
 
class_match< ConstantFPm_ConstantFP ()
 Match an arbitrary ConstantFP and ignore it. More...
 
class_match< ConstantExprm_ConstantExpr ()
 Match an arbitrary ConstantExpr and ignore it. More...
 
class_match< BasicBlockm_BasicBlock ()
 Match an arbitrary basic block value and ignore it. More...
 
template<typename Ty >
match_unless< Ty > m_Unless (const Ty &M)
 Match if the inner matcher does NOT match. 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...
 
apint_match m_APInt (const APInt *&Res)
 Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt. More...
 
apint_match m_APIntAllowUndef (const APInt *&Res)
 Match APInt while allowing undefs in splat vector constants. More...
 
apint_match m_APIntForbidUndef (const APInt *&Res)
 Match APInt while forbidding undefs in splat vector constants. More...
 
apfloat_match m_APFloat (const APFloat *&Res)
 Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat. More...
 
apfloat_match m_APFloatAllowUndef (const APFloat *&Res)
 Match APFloat while allowing undefs in splat vector constants. More...
 
apfloat_match m_APFloatForbidUndef (const APFloat *&Res)
 Match APFloat while forbidding undefs in splat vector constants. More...
 
cst_pred_ty< is_any_apintm_AnyIntegralConstant ()
 Match an integer or vector with any integral constant. More...
 
cst_pred_ty< is_all_onesm_AllOnes ()
 Match an integer or vector with all bits set. More...
 
cst_pred_ty< is_maxsignedvaluem_MaxSignedValue ()
 Match an integer or vector with values having all bits except for the high bit set (0x7f...). More...
 
api_pred_ty< is_maxsignedvaluem_MaxSignedValue (const APInt *&V)
 
cst_pred_ty< is_negativem_Negative ()
 Match an integer or vector of negative values. More...
 
api_pred_ty< is_negativem_Negative (const APInt *&V)
 
cst_pred_ty< is_nonnegativem_NonNegative ()
 Match an integer or vector of non-negative values. More...
 
api_pred_ty< is_nonnegativem_NonNegative (const APInt *&V)
 
cst_pred_ty< is_strictlypositivem_StrictlyPositive ()
 Match an integer or vector of strictly positive values. More...
 
api_pred_ty< is_strictlypositivem_StrictlyPositive (const APInt *&V)
 
cst_pred_ty< is_nonpositivem_NonPositive ()
 Match an integer or vector of non-positive values. More...
 
api_pred_ty< is_nonpositivem_NonPositive (const APInt *&V)
 
cst_pred_ty< is_onem_One ()
 Match an integer 1 or a vector with all elements equal to 1. More...
 
cst_pred_ty< is_zero_intm_ZeroInt ()
 Match an integer 0 or a vector with all elements equal to 0. More...
 
is_zero m_Zero ()
 Match any null constant or a vector with all elements equal to 0. 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_negated_power2m_NegatedPower2 ()
 Match a integer or vector negated power-of-2. More...
 
api_pred_ty< is_negated_power2m_NegatedPower2 (const APInt *&V)
 
cst_pred_ty< is_power2_or_zerom_Power2OrZero ()
 Match an integer or vector of 0 or power-of-2 values. More...
 
api_pred_ty< is_power2_or_zerom_Power2OrZero (const APInt *&V)
 
cst_pred_ty< is_sign_maskm_SignMask ()
 Match an integer or vector with only the sign bit(s) set. More...
 
cst_pred_ty< is_lowbit_maskm_LowBitMask ()
 Match an integer or vector with only the low bit(s) set. More...
 
cst_pred_ty< icmp_pred_with_thresholdm_SpecificInt_ICMP (ICmpInst::Predicate Predicate, const APInt &Threshold)
 Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold. More...
 
cstfp_pred_ty< is_nanm_NaN ()
 Match an arbitrary NaN constant. More...
 
cstfp_pred_ty< is_nonnanm_NonNaN ()
 Match a non-NaN FP constant. More...
 
cstfp_pred_ty< is_infm_Inf ()
 Match a positive or negative infinity FP constant. More...
 
cstfp_pred_ty< is_noninfm_NonInf ()
 Match a non-infinity FP constant, i.e. More...
 
cstfp_pred_ty< is_finitem_Finite ()
 Match a finite FP constant, i.e. More...
 
apf_pred_ty< is_finitem_Finite (const APFloat *&V)
 
cstfp_pred_ty< is_finitenonzerom_FiniteNonZero ()
 Match a finite non-zero FP constant. More...
 
apf_pred_ty< is_finitenonzerom_FiniteNonZero (const APFloat *&V)
 
cstfp_pred_ty< is_any_zero_fpm_AnyZeroFP ()
 Match a floating-point negative zero or positive zero. More...
 
cstfp_pred_ty< is_pos_zero_fpm_PosZeroFP ()
 Match a floating-point positive zero. More...
 
cstfp_pred_ty< is_neg_zero_fpm_NegZeroFP ()
 Match a floating-point negative zero. More...
 
cstfp_pred_ty< is_non_zero_fpm_NonZeroFP ()
 Match a floating-point non-zero. More...
 
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< UnaryOperatorm_UnOp (UnaryOperator *&I)
 Match a unary operator, capturing it if we match. More...
 
bind_ty< BinaryOperatorm_BinOp (BinaryOperator *&I)
 Match a binary operator, capturing it if we match. More...
 
bind_ty< WithOverflowInstm_WithOverflowInst (WithOverflowInst *&I)
 Match a with overflow intrinsic, capturing it if we match. More...
 
bind_ty< const WithOverflowInstm_WithOverflowInst (const WithOverflowInst *&I)
 
bind_ty< Constantm_Constant (Constant *&C)
 Match a Constant, capturing the value if we match. More...
 
bind_ty< ConstantIntm_ConstantInt (ConstantInt *&CI)
 Match a ConstantInt, capturing the value if we match. More...
 
bind_ty< ConstantFPm_ConstantFP (ConstantFP *&C)
 Match a ConstantFP, capturing the value if we match. More...
 
bind_ty< ConstantExprm_ConstantExpr (ConstantExpr *&C)
 Match a ConstantExpr, capturing the value if we match. More...
 
bind_ty< BasicBlockm_BasicBlock (BasicBlock *&V)
 Match a basic block value, capturing it if we match. More...
 
bind_ty< const BasicBlockm_BasicBlock (const BasicBlock *&V)
 
match_combine_and< class_match< Constant >, match_unless< class_match< ConstantExpr > > > m_ImmConstant ()
 Match an arbitrary immediate Constant and ignore it. More...
 
match_combine_and< bind_ty< Constant >, match_unless< class_match< ConstantExpr > > > m_ImmConstant (Constant *&C)
 Match an immediate Constant, capturing the value if we match. More...
 
specificval_ty m_Specific (const Value *V)
 Match if we have a specific specified value. More...
 
deferredval_ty< Valuem_Deferred (Value *const &V)
 Like m_Specific(), but works if the specific value to match is determined as part of the same match() expression. More...
 
deferredval_ty< const Valuem_Deferred (const Value *const &V)
 
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< falsem_SpecificInt (APInt V)
 Match a specific integer value or vector with all elements equal to the value. More...
 
specific_intval< falsem_SpecificInt (uint64_t V)
 
specific_intval< truem_SpecificIntAllowUndef (APInt V)
 
specific_intval< truem_SpecificIntAllowUndef (uint64_t V)
 
bind_const_intval_ty m_ConstantInt (uint64_t &V)
 Match a ConstantInt and bind to its value. More...
 
specific_bbval m_SpecificBB (BasicBlock *BB)
 Match a specific basic block value. More...
 
deferredval_ty< BasicBlockm_Deferred (BasicBlock *const &BB)
 A commutative-friendly version of m_Specific(). More...
 
deferredval_ty< const BasicBlockm_Deferred (const BasicBlock *const &BB)
 
template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS > m_BinOp (const LHS &L, const RHS &R)
 
template<typename OP_t >
AnyUnaryOp_match< OP_t > m_UnOp (const OP_t &X)
 
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 OpTy >
FNeg_match< OpTy > m_FNeg (const OpTy &X)
 Match 'fneg X' as 'fsub -0.0, X'. More...
 
template<typename RHS >
BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub > m_FNegNSZ (const RHS &X)
 Match 'fneg X' as 'fsub +-0.0, X'. More...
 
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 LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_irem_opm_IRem (const LHS &L, const RHS &R)
 Matches integer remainder 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 >
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select (const Cond &C, const LHS &L, const RHS &R)
 Matches SelectInst. More...
 
template<int64_t L, int64_t R, typename Cond >
ThreeOps_match< Cond, constantint_match< L >, constantint_match< R >, Instruction::Select > m_SelectCst (const Cond &C)
 This matches a select of two constants, e.g. More...
 
template<typename OpTy >
OneOps_match< OpTy, Instruction::Freeze > m_Freeze (const OpTy &Op)
 Matches FreezeInst. More...
 
template<typename Val_t , typename Elt_t , typename Idx_t >
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt (const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
 Matches InsertElementInst. More...
 
template<typename Val_t , typename Idx_t >
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > m_ExtractElt (const Val_t &Val, const Idx_t &Idx)
 Matches ExtractElementInst. More...
 
template<typename V1_t , typename V2_t >
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle (const V1_t &v1, const V2_t &v2)
 Matches ShuffleVectorInst independently of mask value. More...
 
template<typename V1_t , typename V2_t , typename Mask_t >
Shuffle_match< V1_t, V2_t, Mask_t > m_Shuffle (const V1_t &v1, const V2_t &v2, const Mask_t &mask)
 
template<typename OpTy >
OneOps_match< OpTy, Instruction::Load > m_Load (const OpTy &Op)
 Matches LoadInst. More...
 
template<typename ValueOpTy , typename PointerOpTy >
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store > m_Store (const ValueOpTy &ValueOp, const PointerOpTy &PointerOp)
 Matches StoreInst. 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::IntToPtr > m_IntToPtr (const OpTy &Op)
 Matches IntToPtr. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::Trunc > m_Trunc (const OpTy &Op)
 Matches Trunc. More...
 
template<typename OpTy >
match_combine_or< CastClass_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf (const OpTy &Op)
 
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 >, OpTy > m_ZExtOrSelf (const OpTy &Op)
 
template<typename OpTy >
match_combine_or< CastClass_match< OpTy, Instruction::SExt >, OpTy > m_SExtOrSelf (const OpTy &Op)
 
template<typename OpTy >
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > m_ZExtOrSExt (const OpTy &Op)
 
template<typename OpTy >
match_combine_or< match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > >, OpTy > m_ZExtOrSExtOrSelf (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::UIToFP > m_UIToFP (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::SIToFP > m_SIToFP (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPToUI > m_FPToUI (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPToSI > m_FPToSI (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPTrunc > m_FPTrunc (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPExt > m_FPExt (const OpTy &Op)
 
br_match m_UnconditionalBr (BasicBlock *&Succ)
 
template<typename Cond_t >
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br (const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
 
template<typename Cond_t , typename TrueBlock_t , typename FalseBlock_t >
brc_match< Cond_t, TrueBlock_t, FalseBlock_t > m_Br (const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &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 >
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > > m_MaxOrMin (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<typename Opnd0 , typename Opnd1 , typename Opnd2 , typename Opnd3 >
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedLoad (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
 Matches MaskedLoad Intrinsic. 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<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
m_Intrinsic_Ty< T0, T1, T2, T3, T4 >::Ty m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3, const T4 &Op4)
 
template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >::Ty m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3, const T4 &Op4, const T5 &Op5)
 
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 >
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs (const Opnd0 &Op0)
 
template<typename Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty m_FCanonicalize (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 Opnd0 , typename Opnd1 , typename Opnd2 >
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
 
template<typename Opnd0 , typename Opnd1 , typename Opnd2 >
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
 
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 ValTy >
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg (const ValTy &V)
 Matches a 'Neg' as 'sub 0, V'. More...
 
template<typename ValTy >
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrapm_NSWNeg (const ValTy &V)
 Matches a 'Neg' as 'sub nsw 0, V'. More...
 
template<typename ValTy >
BinaryOp_match< ValTy, cst_pred_ty< is_all_ones >, Instruction::Xor, truem_Not (const ValTy &V)
 Matches a 'Not' as 'xor V, -1' or 'xor -1, V'. 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...
 
template<typename LHS , typename RHS >
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FAdd, truem_c_FAdd (const LHS &L, const RHS &R)
 Matches FAdd with LHS and RHS in either order. More...
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FMul, truem_c_FMul (const LHS &L, const RHS &R)
 Matches FMul with LHS and RHS in either order. More...
 
template<typename Val_t >
Signum_match< Val_t > m_Signum (const Val_t &V)
 Matches a signum pattern. More...
 
template<int Ind, typename Val_t >
ExtractValue_match< Ind, Val_t > m_ExtractValue (const Val_t &V)
 Match a single index ExtractValue instruction. More...
 
template<typename Val_t >
ExtractValue_match<-1, Val_t > m_ExtractValue (const Val_t &V)
 Match an ExtractValue instruction with any index. More...
 
template<int Ind, typename Val_t , typename Elt_t >
InsertValue_match< Ind, Val_t, Elt_t > m_InsertValue (const Val_t &Val, const Elt_t &Elt)
 Matches a single index InsertValue instruction. More...
 
VScaleVal_match m_VScale (const DataLayout &DL)
 
template<typename LHS , typename RHS >
LogicalOp_match< LHS, RHS, Instruction::And > m_LogicalAnd (const LHS &L, const RHS &R)
 Matches L && R either in the form of L & R or L ? R : false. More...
 
auto m_LogicalAnd ()
 Matches L && R where L and R are arbitrary values. More...
 
template<typename LHS , typename RHS >
LogicalOp_match< LHS, RHS, Instruction::Or > m_LogicalOr (const LHS &L, const RHS &R)
 Matches L || R either in the form of L | R or L ? true : R. More...
 
auto m_LogicalOr ()
 Matches L || R where L and R are arbitrary values. More...
 

Typedef Documentation

◆ cst_pred_ty

template<typename Predicate >
using llvm::PatternMatch::cst_pred_ty = typedef cstval_pred_ty<Predicate, ConstantInt>

specialization of cstval_pred_ty for ConstantInt

Definition at line 364 of file PatternMatch.h.

◆ cstfp_pred_ty

template<typename Predicate >
using llvm::PatternMatch::cstfp_pred_ty = typedef cstval_pred_ty<Predicate, ConstantFP>

specialization of cstval_pred_ty for ConstantFP

Definition at line 368 of file PatternMatch.h.

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()

cst_pred_ty<is_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_AnyIntegralConstant()

cst_pred_ty<is_any_apint> llvm::PatternMatch::m_AnyIntegralConstant ( )
inline

Match an integer or vector with any integral constant.

For vectors, this includes constants with undefined elements.

Definition at line 436 of file PatternMatch.h.

Referenced by FoldTwoEntryPHINode(), and llvm::InstCombiner::isFreeToInvert().

◆ m_AnyZeroFP()

cstfp_pred_ty<is_any_zero_fp> llvm::PatternMatch::m_AnyZeroFP ( )
inline

◆ m_APFloat()

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

◆ m_APFloatAllowUndef()

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

Match APFloat while allowing undefs in splat vector constants.

Definition at line 293 of file PatternMatch.h.

◆ m_APFloatForbidUndef()

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

Match APFloat while forbidding undefs in splat vector constants.

Definition at line 298 of file PatternMatch.h.

◆ 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 270 of file PatternMatch.h.

Referenced by annotateNonNullAndDereferenceable(), canEvaluateShiftedShift(), canEvaluateZExtd(), canonicalizeAbs(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeSaturatedAdd(), canonicalizeSaturatedSubtract(), checkForNegativeOperand(), cmpExcludesZero(), collectBitParts(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::commonIRemTransforms(), llvm::computeConstantRange(), computeKnownBits(), computeKnownBitsFromOperator(), ComputeNumSignBitsImpl(), llvm::ConstantFoldBinaryInstruction(), llvm::decomposeBitTestICmp(), llvm::InstCombinerImpl::foldAddWithConstant(), foldAndOrOfEqualityCmpsWithConstants(), foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldICmpAddConstant(), llvm::InstCombinerImpl::foldICmpAndConstant(), llvm::InstCombinerImpl::foldICmpAndConstConst(), llvm::InstCombinerImpl::foldICmpAndShift(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpBinOpEqualityWithConstant(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::InstCombinerImpl::foldICmpDivConstant(), llvm::InstCombinerImpl::foldICmpEqIntrinsicWithConstant(), llvm::InstCombinerImpl::foldICmpInstWithConstant(), llvm::InstCombinerImpl::foldICmpMulConstant(), llvm::InstCombinerImpl::foldICmpOrConstant(), llvm::InstCombinerImpl::foldICmpShlConstant(), llvm::InstCombinerImpl::foldICmpShrConstant(), llvm::InstCombinerImpl::foldICmpSubConstant(), llvm::InstCombinerImpl::foldICmpTruncConstant(), llvm::InstCombinerImpl::foldICmpUDivConstant(), llvm::InstCombinerImpl::foldICmpUsingKnownBits(), llvm::InstCombinerImpl::foldICmpWithDominatingICmp(), foldICmpWithTruncSignExtendedVal(), llvm::InstCombinerImpl::foldICmpXorConstant(), foldNoWrapAdd(), foldSelectICmpAnd(), llvm::InstCombinerImpl::foldSelectIntoOp(), foldSetClearBits(), llvm::InstCombinerImpl::FoldShiftByConstant(), foldShiftedShift(), foldSignedTruncationCheck(), foldToUnsignedSaturatedAdd(), getAlternateBinop(), getDemandedBitsLHSMask(), llvm::ConstantExpr::getExactLogBase2(), getNotValue(), getValueFromICmpCondition(), getValueFromOverflowCondition(), isDivZero(), isLoadCombineCandidateImpl(), isNonEqualMul(), isNonEqualPHIs(), isNonEqualShl(), llvm::isSafeToSpeculativelyExecute(), isSignedMinMaxClamp(), isTruePredicate(), lookThroughAnd(), maintainNoSignedWrap(), matchAndOrChain(), matchClamp(), MatchDiv(), matchICmpOperand(), matchIntPart(), matchMinMax(), MatchMul(), matchOrConcat(), MatchRem(), setLimitsForBinOp(), setLimitsForIntrinsic(), setLimitsForSelectPattern(), ShrinkDemandedConstant(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOrOfICmpsWithConstants(), simplifyAndOrOfICmpsWithLimitConst(), simplifyBinaryIntrinsic(), SimplifyBSwap(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), simplifyICmpWithBinOp(), simplifyICmpWithBinOpOnLHS(), simplifyIntrinsic(), SimplifyLShrInst(), llvm::InstCombinerImpl::SimplifyMultipleUseDemandedBits(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifySelectBitTest(), simplifySelectWithICmpCond(), llvm::InstCombinerImpl::tryFactorization(), trySimplifyICmpWithAdds(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitExtractValueInst(), llvm::InstCombinerImpl::visitICmpInst(), llvm::InstCombinerImpl::visitLShr(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitSDiv(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitSub(), llvm::InstCombinerImpl::visitUDiv(), llvm::InstCombinerImpl::visitXor(), and llvm::reassociate::XorOpnd::XorOpnd().

◆ m_APIntAllowUndef()

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

Match APInt while allowing undefs in splat vector constants.

Definition at line 276 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::FoldOpIntoSelect(), matchFunnelShift(), simplifyBinaryIntrinsic(), simplifyICmpWithBinOp(), and simplifyICmpWithConstant().

◆ m_APIntForbidUndef()

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

Match APInt while forbidding undefs in splat vector constants.

Definition at line 281 of file PatternMatch.h.

◆ 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 2047 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_BasicBlock() [1/3]

class_match<BasicBlock> llvm::PatternMatch::m_BasicBlock ( )
inline

◆ m_BasicBlock() [2/3]

bind_ty<BasicBlock> llvm::PatternMatch::m_BasicBlock ( BasicBlock *&  V)
inline

Match a basic block value, capturing it if we match.

Definition at line 773 of file PatternMatch.h.

◆ m_BasicBlock() [3/3]

bind_ty<const BasicBlock> llvm::PatternMatch::m_BasicBlock ( const BasicBlock *&  V)
inline

Definition at line 774 of file PatternMatch.h.

◆ 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 752 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 953 of file PatternMatch.h.

◆ 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

◆ 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 1328 of file PatternMatch.h.

◆ m_Br() [1/2]

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

◆ m_Br() [2/2]

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

Definition at line 1748 of file PatternMatch.h.

References F, and T.

◆ 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

◆ 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

◆ m_c_FAdd()

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

Matches FAdd with LHS and RHS in either order.

Definition at line 2323 of file PatternMatch.h.

Referenced by factorizeLerp(), SimplifyFSubInst(), llvm::InstCombinerImpl::visitFAdd(), and llvm::InstCombinerImpl::visitFSub().

◆ m_c_FMul()

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

◆ 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

◆ m_c_MaxOrMin()

template<typename LHS , typename RHS >
match_combine_or< match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty, true>, MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true> >, match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty, true>, MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty, true> > > llvm::PatternMatch::m_c_MaxOrMin ( const LHS &  L,
const RHS &  R 
)
inline

◆ 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

◆ 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 2293 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), and m_c_MaxOrMin().

◆ 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 2287 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), and m_c_MaxOrMin().

◆ 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 2305 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), and m_c_MaxOrMin().

◆ 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 2299 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), foldToUnsignedSaturatedAdd(), and m_c_MaxOrMin().

◆ 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

◆ 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 1398 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

◆ m_CombineOr()

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

◆ m_Constant() [1/2]

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

Match an arbitrary Constant and ignore it.

Definition at line 142 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), llvm::InstCombinerImpl::commonShiftTransforms(), llvm::findScalarElement(), llvm::InstCombinerImpl::foldAddWithConstant(), foldAndOrOfICmpsWithConstEq(), foldBitCastBitwiseLogic(), foldConstantInsEltIntoShuffle(), foldFDivConstantDividend(), foldFDivConstantDivisor(), foldFNegIntoConstant(), llvm::InstCombinerImpl::foldICmpEquality(), foldICmpWithLowBitMaskedVal(), foldNoWrapAdd(), llvm::InstCombinerImpl::FoldOpIntoSelect(), foldSelectBinOpIdentity(), foldSelectGEP(), foldSelectShuffle(), foldSelectShuffleWith1Binop(), foldShiftOfShiftedLogic(), llvm::InstCombinerImpl::foldSignBitTest(), foldUDivShl(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), foldVectorCmp(), getAlternateBinop(), getBinOpsForFactorization(), getNegatibleInsts(), hoistInsEltConst(), llvm::ARMTTIImpl::instCombineIntrinsic(), lookThroughCast(), m_ImmConstant(), matchFunnelShift(), matchIncrement(), narrowUDivURem(), recordCondition(), simplifyAssocCastAssoc(), llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative(), simplifyLogicOfAddSub(), SimplifySelectInst(), SimplifyShuffleVectorInst(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitFMul(), llvm::InstCombinerImpl::visitFSub(), visitMaskedMerge(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitSExt(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitSub(), llvm::InstCombinerImpl::visitTrunc(), llvm::InstCombinerImpl::visitXor(), and llvm::InstCombinerImpl::visitZExt().

◆ 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 761 of file PatternMatch.h.

◆ m_ConstantExpr() [1/2]

class_match<ConstantExpr> llvm::PatternMatch::m_ConstantExpr ( )
inline

Match an arbitrary ConstantExpr and ignore it.

Definition at line 155 of file PatternMatch.h.

Referenced by m_ImmConstant(), and llvm::InstCombinerImpl::visitXor().

◆ m_ConstantExpr() [2/2]

bind_ty<ConstantExpr> llvm::PatternMatch::m_ConstantExpr ( ConstantExpr *&  C)
inline

Match a ConstantExpr, capturing the value if we match.

Definition at line 770 of file PatternMatch.h.

◆ m_ConstantFP() [1/2]

class_match<ConstantFP> llvm::PatternMatch::m_ConstantFP ( )
inline

Match an arbitrary ConstantFP and ignore it.

Definition at line 150 of file PatternMatch.h.

◆ m_ConstantFP() [2/2]

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

Match a ConstantFP, capturing the value if we match.

Definition at line 767 of file PatternMatch.h.

◆ m_ConstantInt() [1/3]

class_match<ConstantInt> 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 764 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 903 of file PatternMatch.h.

◆ m_Deferred() [1/4]

deferredval_ty<BasicBlock> llvm::PatternMatch::m_Deferred ( BasicBlock *const BB)
inline

A commutative-friendly version of m_Specific().

Definition at line 923 of file PatternMatch.h.

References BB.

◆ m_Deferred() [2/4]

deferredval_ty<const BasicBlock> llvm::PatternMatch::m_Deferred ( const BasicBlock *const BB)
inline

Definition at line 927 of file PatternMatch.h.

References BB.

◆ m_Deferred() [3/4]

deferredval_ty<const Value> llvm::PatternMatch::m_Deferred ( const Value *const V)
inline

Definition at line 821 of file PatternMatch.h.

◆ m_Deferred() [4/4]

deferredval_ty<Value> llvm::PatternMatch::m_Deferred ( Value *const V)
inline

◆ m_Exact()

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

◆ m_ExtractElt()

template<typename Val_t , typename Idx_t >
TwoOps_match<Val_t, Idx_t, Instruction::ExtractElement> llvm::PatternMatch::m_ExtractElt ( const Val_t &  Val,
const Idx_t &  Idx 
)
inline

◆ m_ExtractValue() [1/2]

template<int Ind, typename Val_t >
ExtractValue_match<Ind, Val_t> llvm::PatternMatch::m_ExtractValue ( const Val_t &  V)
inline

Match a single index ExtractValue instruction.

For example m_ExtractValue<1>(...)

Definition at line 2393 of file PatternMatch.h.

Referenced by directlyImpliesPoison().

◆ m_ExtractValue() [2/2]

template<typename Val_t >
ExtractValue_match<-1, Val_t> llvm::PatternMatch::m_ExtractValue ( const Val_t &  V)
inline

Match an ExtractValue instruction with any index.

For example m_ExtractValue(...)

Definition at line 2400 of file PatternMatch.h.

◆ m_FAbs()

template<typename Opnd0 >
m_Intrinsic_Ty<Opnd0>::Ty llvm::PatternMatch::m_FAbs ( const Opnd0 &  Op0)
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

◆ m_FCanonicalize()

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

Definition at line 2179 of file PatternMatch.h.

◆ 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

◆ m_FDiv()

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

◆ m_Finite() [1/2]

cstfp_pred_ty<is_finite> llvm::PatternMatch::m_Finite ( )
inline

Match a finite FP constant, i.e.

not infinity or NaN. For vectors, this includes constants with undefined elements.

Definition at line 674 of file PatternMatch.h.

◆ m_Finite() [2/2]

apf_pred_ty<is_finite> llvm::PatternMatch::m_Finite ( const APFloat *&  V)
inline

Definition at line 677 of file PatternMatch.h.

◆ m_FiniteNonZero() [1/2]

cstfp_pred_ty<is_finitenonzero> llvm::PatternMatch::m_FiniteNonZero ( )
inline

Match a finite non-zero FP constant.

For vectors, this includes constants with undefined elements.

Definition at line 684 of file PatternMatch.h.

Referenced by llvm::GCNTTIImpl::canSimplifyLegacyMulToMul().

◆ m_FiniteNonZero() [2/2]

apf_pred_ty<is_finitenonzero> llvm::PatternMatch::m_FiniteNonZero ( const APFloat *&  V)
inline

Definition at line 687 of file PatternMatch.h.

◆ 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 2190 of file PatternMatch.h.

◆ 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 2184 of file PatternMatch.h.

◆ 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 OpTy >
FNeg_match<OpTy> llvm::PatternMatch::m_FNeg ( const OpTy &  X)
inline

◆ m_FNegNSZ()

template<typename RHS >
BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub> llvm::PatternMatch::m_FNegNSZ ( const RHS &  X)
inline

Match 'fneg X' as 'fsub +-0.0, X'.

Definition at line 1070 of file PatternMatch.h.

References m_AnyZeroFP(), m_FSub(), and X.

Referenced by SimplifyFDivInst().

◆ m_FPExt()

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

◆ 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 848 of file PatternMatch.h.

References m_SpecificFP().

Referenced by factorizeLerp(), llvm::GCNTTIImpl::getArithmeticInstrCost(), instCombineSVEVectorMul(), SimplifyFDivInst(), and SimplifyFMAFMul().

◆ m_FPToSI()

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

Definition at line 1687 of file PatternMatch.h.

Referenced by isKnownExactCastIntToFP().

◆ m_FPToUI()

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

Definition at line 1682 of file PatternMatch.h.

Referenced by isKnownExactCastIntToFP().

◆ m_FPTrunc()

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

◆ m_Freeze()

template<typename OpTy >
OneOps_match<OpTy, Instruction::Freeze> llvm::PatternMatch::m_Freeze ( const OpTy &  Op)
inline

Matches FreezeInst.

Definition at line 1487 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 1117 of file PatternMatch.h.

◆ m_FShl()

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

◆ m_FShr()

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

◆ 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 1334 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), isKnownNonZero(), matchExpandedRem(), and SimplifyMulInst().

◆ m_ImmConstant() [1/2]

match_combine_and<class_match<Constant>, match_unless<class_match<ConstantExpr> > > llvm::PatternMatch::m_ImmConstant ( )
inline

◆ m_ImmConstant() [2/2]

match_combine_and<bind_ty<Constant>, match_unless<class_match<ConstantExpr> > > llvm::PatternMatch::m_ImmConstant ( Constant *&  C)
inline

Match an immediate Constant, capturing the value if we match.

Definition at line 788 of file PatternMatch.h.

References m_CombineAnd(), m_Constant(), m_ConstantExpr(), and m_Unless().

◆ m_Inf()

cstfp_pred_ty<is_inf> llvm::PatternMatch::m_Inf ( )
inline

Match a positive or negative infinity FP constant.

For vectors, this includes constants with undefined elements.

Definition at line 656 of file PatternMatch.h.

Referenced by simplifyFPOp().

◆ m_InsertElt()

template<typename Val_t , typename Elt_t , typename Idx_t >
ThreeOps_match<Val_t, Elt_t, Idx_t, Instruction::InsertElement> llvm::PatternMatch::m_InsertElt ( const Val_t &  Val,
const Elt_t &  Elt,
const Idx_t &  Idx 
)
inline

◆ m_InsertValue()

template<int Ind, typename Val_t , typename Elt_t >
InsertValue_match<Ind, Val_t, Elt_t> llvm::PatternMatch::m_InsertValue ( const Val_t &  Val,
const Elt_t &  Elt 
)
inline

Matches a single index InsertValue instruction.

Definition at line 2422 of file PatternMatch.h.

◆ m_Instruction()

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

◆ m_Intrinsic() [1/7]

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 2108 of file PatternMatch.h.

◆ m_Intrinsic() [2/7]

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

Definition at line 2121 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [3/7]

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 2126 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [4/7]

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 2133 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [5/7]

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 2140 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [6/7]

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

Definition at line 2147 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [7/7]

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

Definition at line 2156 of file PatternMatch.h.

References m_CombineAnd().

◆ m_IntToPtr()

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

Matches IntToPtr.

Definition at line 1615 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::visitPtrToInt().

◆ m_IRem()

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

Matches integer remainder operations.

Definition at line 1341 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest().

◆ m_Load()

template<typename OpTy >
OneOps_match<OpTy, Instruction::Load> llvm::PatternMatch::m_Load ( const OpTy &  Op)
inline

◆ m_LogicalAnd() [1/2]

auto llvm::PatternMatch::m_LogicalAnd ( )
inline

Matches L && R where L and R are arbitrary values.

Definition at line 2504 of file PatternMatch.h.

References m_LogicalAnd(), and m_Value().

◆ m_LogicalAnd() [2/2]

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

◆ m_LogicalOr() [1/2]

auto llvm::PatternMatch::m_LogicalOr ( )
inline

Matches L || R where L and R are arbitrary values.

Definition at line 2515 of file PatternMatch.h.

References m_LogicalOr(), and m_Value().

◆ m_LogicalOr() [2/2]

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

◆ 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 1321 of file PatternMatch.h.

Referenced by collectBitParts(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), matchFunnelShift(), and llvm::InstCombinerImpl::visitAnd().

◆ m_LowBitMask()

cst_pred_ty<is_lowbit_mask> llvm::PatternMatch::m_LowBitMask ( )
inline

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

For vectors, this includes constants with undefined elements.

Definition at line 589 of file PatternMatch.h.

Referenced by foldICmpWithLowBitMaskedVal().

◆ 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_MaskedLoad()

template<typename Opnd0 , typename Opnd1 , typename Opnd2 , typename Opnd3 >
m_Intrinsic_Ty<Opnd0, Opnd1, Opnd2, Opnd3>::Ty llvm::PatternMatch::m_MaskedLoad ( const Opnd0 &  Op0,
const Opnd1 &  Op1,
const Opnd2 &  Op2,
const Opnd3 &  Op3 
)
inline

Matches MaskedLoad Intrinsic.

Definition at line 2115 of file PatternMatch.h.

◆ m_MaxOrMin()

template<typename LHS , typename RHS >
match_combine_or< match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>, MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty> >, match_combine_or<MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>, MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty> > > llvm::PatternMatch::m_MaxOrMin ( const LHS &  L,
const RHS &  R 
)
inline

◆ m_MaxSignedValue() [1/2]

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

Match an integer or vector with values having all bits except for the high bit set (0x7f...).

For vectors, this includes constants with undefined elements.

Definition at line 455 of file PatternMatch.h.

◆ m_MaxSignedValue() [2/2]

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

Definition at line 458 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()

cstfp_pred_ty<is_nan> llvm::PatternMatch::m_NaN ( )
inline

Match an arbitrary NaN constant.

This includes quiet and signalling nans. For vectors, this includes constants with undefined elements.

Definition at line 638 of file PatternMatch.h.

Referenced by llvm::GCNTTIImpl::instCombineIntrinsic(), simplifyBinaryIntrinsic(), SimplifyFCmpInst(), and simplifyFPOp().

◆ m_Neg()

template<typename ValTy >
BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub> llvm::PatternMatch::m_Neg ( const ValTy &  V)
inline

◆ m_NegatedPower2() [1/2]

cst_pred_ty<is_negated_power2> llvm::PatternMatch::m_NegatedPower2 ( )
inline

Match a integer or vector negated power-of-2.

For vectors, this includes constants with undefined elements.

Definition at line 556 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::visitMul(), and llvm::InstCombinerImpl::visitSDiv().

◆ m_NegatedPower2() [2/2]

api_pred_ty<is_negated_power2> llvm::PatternMatch::m_NegatedPower2 ( const APInt *&  V)
inline

Definition at line 559 of file PatternMatch.h.

◆ m_Negative() [1/2]

cst_pred_ty<is_negative> llvm::PatternMatch::m_Negative ( )
inline

Match an integer or vector of negative values.

For vectors, this includes constants with undefined elements.

Definition at line 467 of file PatternMatch.h.

Referenced by simplifyBinaryIntrinsic(), SimplifyShlInst(), llvm::InstCombinerImpl::visitSRem(), llvm::InstCombinerImpl::visitUDiv(), llvm::InstCombinerImpl::visitURem(), and llvm::InstCombinerImpl::visitXor().

◆ m_Negative() [2/2]

api_pred_ty<is_negative> llvm::PatternMatch::m_Negative ( const APInt *&  V)
inline

Definition at line 470 of file PatternMatch.h.

◆ m_NegZeroFP()

cstfp_pred_ty<is_neg_zero_fp> llvm::PatternMatch::m_NegZeroFP ( )
inline

Match a floating-point negative zero.

For vectors, this includes constants with undefined elements.

Definition at line 714 of file PatternMatch.h.

Referenced by llvm::ConstantFoldBinaryInstruction(), SimplifyFAddInst(), SimplifyFRemInst(), SimplifyFSubInst(), and llvm::InstCombinerImpl::visitCallInst().

◆ m_NonInf()

cstfp_pred_ty<is_noninf> llvm::PatternMatch::m_NonInf ( )
inline

Match a non-infinity FP constant, i.e.

finite or NaN. For vectors, this includes constants with undefined elements.

Definition at line 665 of file PatternMatch.h.

◆ m_NonNaN()

cstfp_pred_ty<is_nonnan> llvm::PatternMatch::m_NonNaN ( )
inline

Match a non-NaN FP constant.

For vectors, this includes constants with undefined elements.

Definition at line 647 of file PatternMatch.h.

◆ m_NonNegative() [1/2]

cst_pred_ty<is_nonnegative> llvm::PatternMatch::m_NonNegative ( )
inline

Match an integer or vector of non-negative values.

For vectors, this includes constants with undefined elements.

Definition at line 479 of file PatternMatch.h.

Referenced by foldICmpWithLowBitMaskedVal(), llvm::InstCombinerImpl::visitSDiv(), and llvm::InstCombinerImpl::visitXor().

◆ m_NonNegative() [2/2]

api_pred_ty<is_nonnegative> llvm::PatternMatch::m_NonNegative ( const APInt *&  V)
inline

Definition at line 482 of file PatternMatch.h.

◆ m_NonPositive() [1/2]

cst_pred_ty<is_nonpositive> llvm::PatternMatch::m_NonPositive ( )
inline

Match an integer or vector of non-positive values.

For vectors, this includes constants with undefined elements.

Definition at line 503 of file PatternMatch.h.

◆ m_NonPositive() [2/2]

api_pred_ty<is_nonpositive> llvm::PatternMatch::m_NonPositive ( const APInt *&  V)
inline

Definition at line 506 of file PatternMatch.h.

◆ m_NonZeroFP()

cstfp_pred_ty<is_non_zero_fp> llvm::PatternMatch::m_NonZeroFP ( )
inline

Match a floating-point non-zero.

For vectors, this includes constants with undefined elements.

Definition at line 723 of file PatternMatch.h.

◆ m_Not()

template<typename ValTy >
BinaryOp_match<ValTy, cst_pred_ty<is_all_ones>, Instruction::Xor, true> llvm::PatternMatch::m_Not ( const ValTy &  V)
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_NSWNeg()

template<typename ValTy >
OverflowingBinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap> llvm::PatternMatch::m_NSWNeg ( const ValTy &  V)
inline

Matches a 'Neg' as 'sub nsw 0, V'.

Definition at line 2273 of file PatternMatch.h.

References m_NSWSub(), and m_ZeroInt().

Referenced by foldICmpXNegX(), and llvm::InstCombinerImpl::visitCallInst().

◆ 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 1227 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoUnsignedWrap.

Referenced by decompose().

◆ m_One()

cst_pred_ty<is_one> llvm::PatternMatch::m_One ( )
inline

Match an integer 1 or a vector with all elements equal to 1.

For vectors, this includes constants with undefined elements.

Definition at line 513 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeICmpBool(), canonicalizeLowbitMask(), checkForNegativeOperand(), llvm::InstCombinerImpl::commonIDivTransforms(), computeKnownBitsFromOperator(), llvm::ConstantFoldBinaryInstruction(), despeculateCountZeros(), detectShiftUntilBitTestIdiom(), dropRedundantMaskingOfLeftShiftInput(), foldAnyOrAllBitsSet(), foldCttzCtlz(), llvm::InstCombinerImpl::foldICmpAndConstConst(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpBitCast(), foldICmpOfUAddOv(), foldICmpShlOne(), llvm::InstCombinerImpl::foldICmpUsingKnownBits(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldMulSelectToNegate(), foldSelectICmpAndAnd(), handleOtherCmpSelSimplifications(), llvm::GCNTTIImpl::instCombineIntrinsic(), instCombineSVEVectorMul(), llvm::Constant::isElementWiseEqual(), isKnownToBeAPowerOfTwo(), isNeutralValue(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), matchAndOrChain(), matchSelectPattern(), replaceConditionalBranchesOnConstant(), setLimitsForIntrinsic(), simplifyBinaryIntrinsic(), simplifyDivRem(), simplifyICmpOfBools(), simplifyICmpWithBinOp(), SimplifyMulInst(), SimplifyOrInst(), SimplifySelectInst(), simplifyValueKnownNonZero(), unswitchBestCondition(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitSDiv(), llvm::InstCombinerImpl::visitShl(), and llvm::InstCombinerImpl::visitURem().

◆ m_OneUse()

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

Definition at line 67 of file PatternMatch.h.

Referenced by llvm::canConvertToMinOrMaxIntrinsic(), canonicalizeAbs(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeInsertSplat(), canonicalizeLowbitMask(), cheapToScalarize(), llvm::InstCombinerImpl::commonCastTransforms(), llvm::InstCombinerImpl::commonShiftTransforms(), factorizeFAddFSub(), factorizeLerp(), llvm::InstCombinerImpl::foldAddWithConstant(), foldAnyOrAllBitsSet(), foldBitCastBitwiseLogic(), foldBitCastSelect(), foldCtpop(), foldCttzCtlz(), foldFNegIntoConstant(), foldGuardedFunnelShift(), llvm::InstCombinerImpl::foldICmpAndConstConst(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpEquality(), llvm::InstCombinerImpl::foldICmpOrConstant(), foldICmpWithHighBitMask(), foldICmpWithTruncSignExtendedVal(), llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(), foldLogicCastConstant(), foldMulSelectToNegate(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldNoWrapAdd(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), foldSetClearBits(), llvm::InstCombinerImpl::FoldShiftByConstant(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), foldShiftOfShiftedLogic(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), llvm::InstCombinerImpl::foldVectorBinop(), hoistFNegAboveFMulFDiv(), instCombineSVELast(), llvm::RecurrenceDescriptor::isMinMaxPattern(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), matchDeMorgansLaws(), matchFunnelShift(), matchIntPart(), matchOrConcat(), narrowUDivURem(), narrowVectorSelect(), optimizeTrigReflections(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), simplifyValueKnownNonZero(), sinkNotIntoXor(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitBranchInst(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitFDiv(), llvm::InstCombinerImpl::visitFMul(), llvm::InstCombinerImpl::visitFNeg(), llvm::InstCombinerImpl::visitFSub(), llvm::InstCombinerImpl::visitInsertElementInst(), llvm::InstCombinerImpl::visitLShr(), visitMaskedMerge(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitPtrToInt(), llvm::InstCombinerImpl::visitSDiv(), llvm::InstCombinerImpl::visitSExt(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitSRem(), llvm::InstCombinerImpl::visitSub(), llvm::InstCombinerImpl::visitTrunc(), llvm::InstCombinerImpl::visitXor(), and llvm::InstCombinerImpl::visitZExt().

◆ 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 1907 of file PatternMatch.h.

Referenced by llvm::RecurrenceDescriptor::isMinMaxPattern(), 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 1922 of file PatternMatch.h.

Referenced by llvm::RecurrenceDescriptor::isMinMaxPattern(), and matchFastFloatClamp().

◆ m_Poison()

class_match<PoisonValue> llvm::PatternMatch::m_Poison ( )
inline

Match an arbitrary poison constant.

Definition at line 139 of file PatternMatch.h.

Referenced by simplifyFPOp().

◆ m_PosZeroFP()

cstfp_pred_ty<is_pos_zero_fp> llvm::PatternMatch::m_PosZeroFP ( )
inline

Match a floating-point positive zero.

For vectors, this includes constants with undefined elements.

Definition at line 705 of file PatternMatch.h.

Referenced by llvm::CannotBeNegativeZero(), foldFabsWithFcmpZero(), SimplifyFAddInst(), SimplifyFRemInst(), SimplifyFSubInst(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitFCmpInst().

◆ 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 547 of file PatternMatch.h.

◆ m_Power2OrZero() [1/2]

cst_pred_ty<is_power2_or_zero> llvm::PatternMatch::m_Power2OrZero ( )
inline

Match an integer or vector of 0 or power-of-2 values.

For vectors, this includes constants with undefined elements.

Definition at line 568 of file PatternMatch.h.

Referenced by isKnownToBeAPowerOfTwo().

◆ m_Power2OrZero() [2/2]

api_pred_ty<is_power2_or_zero> llvm::PatternMatch::m_Power2OrZero ( const APInt *&  V)
inline

Definition at line 571 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 >
ThreeOps_match<Cond, LHS, RHS, Instruction::Select> 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 >
ThreeOps_match<Cond, constantint_match<L>, constantint_match<R>, Instruction::Select> 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 1481 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_SExtOrSelf()

template<typename OpTy >
match_combine_or<CastClass_match<OpTy, Instruction::SExt>, OpTy> llvm::PatternMatch::m_SExtOrSelf ( 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

◆ 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_Shuffle() [1/2]

template<typename V1_t , typename V2_t >
TwoOps_match<V1_t, V2_t, Instruction::ShuffleVector> llvm::PatternMatch::m_Shuffle ( const V1_t &  v1,
const V2_t &  v2 
)
inline

◆ m_Shuffle() [2/2]

template<typename V1_t , typename V2_t , typename Mask_t >
Shuffle_match<V1_t, V2_t, Mask_t> llvm::PatternMatch::m_Shuffle ( const V1_t &  v1,
const V2_t &  v2,
const Mask_t &  mask 
)
inline

Definition at line 1567 of file PatternMatch.h.

References v1, and v2.

◆ m_SignMask()

cst_pred_ty<is_sign_mask> llvm::PatternMatch::m_SignMask ( )
inline

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

For vectors, this includes constants with undefined elements.

Definition at line 580 of file PatternMatch.h.

Referenced by isKnownToBeAPowerOfTwo(), SimplifyAddInst(), simplifyICmpWithBinOp(), llvm::InstCombinerImpl::visitAnd(), and llvm::InstCombinerImpl::visitSDiv().

◆ 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 2370 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpOrConstant(), and llvm::InstCombinerImpl::foldICmpTruncConstant().

◆ m_SIToFP()

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

◆ 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 802 of file PatternMatch.h.

Referenced by canonicalizeAbs(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeSaturatedAdd(), canonicalizeSaturatedSubtract(), checkIVUsers(), checkOuterLoopInsts(), llvm::InstCombinerImpl::commonIDivTransforms(), computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), detectShiftUntilBitTestIdiom(), directlyImpliesPoison(), factorizeFAddFSub(), factorizeMathWithShlOps(), foldGuardedFunnelShift(), llvm::InstCombinerImpl::foldICmpAndConstant(), llvm::InstCombinerImpl::foldICmpAndConstConst(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpEquality(), llvm::InstCombinerImpl::foldICmpWithDominatingICmp(), foldICmpWithDominatingICmp(), foldICmpWithMinMax(), foldInsEltIntoIdentityShuffle(), foldInsEltIntoSplat(), foldIsPowerOf2(), foldMinMaxSharedOp(), foldOrToXor(), foldSelectBinOpIdentity(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), foldSelectICmpLshrAshr(), foldSelectShuffleWith1Binop(), foldSelectWithBinaryOp(), foldSelectZeroOrMul(), foldSetClearBits(), llvm::InstCombinerImpl::FoldShiftByConstant(), foldSignedTruncationCheck(), foldUnsignedUnderflowCheck(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), llvm::InstCombinerImpl::foldVectorBinop(), foldXorToXor(), getBundleFromUse(), getValueFromICmpCondition(), llvm::haveNoCommonBitsSet(), llvm::ARMTTIImpl::instCombineIntrinsic(), llvm::GCNTTIImpl::instCombineIntrinsic(), instCombineSVEZip(), llvm::invertCondition(), isEqualImpl(), llvm::isKnownNegation(), isKnownNonNullFromDominatingCondition(), isKnownNonZeroFromAssume(), isKnownToBeAPowerOfTwo(), isMinMaxWithLoads(), isNonEqualMul(), isNonEqualShl(), isTruePredicate(), matchClamp(), matchExpandedRem(), matchFastFloatClamp(), matchFunnelShift(), matchICmpOperand(), matchMinMax(), matchMinMaxOfMinMax(), matchSelectPattern(), matchSelectWithOptionalNotCond(), matchUAddWithOverflowConstantEdgeCases(), optimizeBranch(), processUse(), setLimitsForSelectPattern(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOfICmpsWithSameOperands(), simplifyAndOrOfICmpsWithLimitConst(), simplifyAndOrOfICmpsWithZero(), SimplifyAShrInst(), simplifyBinaryIntrinsic(), simplifyDiv(), simplifyDivRem(), SimplifyFAddInst(), SimplifyFDivInst(), SimplifyFSubInst(), SimplifyGEPInst(), simplifyICmpWithBinOpOnLHS(), llvm::SimplifyInsertElementInst(), simplifyLogicOfAddSub(), SimplifyLShrInst(), SimplifyMulInst(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifyOrOfICmpsWithSameOperands(), simplifyRem(), simplifySelectBitTest(), simplifySelectWithFCmp(), simplifySelectWithICmpCond(), SimplifyShlInst(), simplifyUnsignedRangeCheck(), SimplifyXorInst(), swapMayExposeCSEOpportunities(), trySimplifyICmpWithAdds(), tryToMoveFreeBeforeNullTest(), tryToRecognizePopCount(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFDiv(), llvm::InstCombinerImpl::visitFMul(), llvm::InstCombinerImpl::visitFSub(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitLShr(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitSub(), llvm::InstCombinerImpl::visitUDiv(), llvm::InstCombinerImpl::visitXor(), and llvm::InstCombinerImpl::visitZExt().

◆ m_SpecificBB()

specific_bbval llvm::PatternMatch::m_SpecificBB ( BasicBlock BB)
inline

Match a specific basic block value.

Definition at line 918 of file PatternMatch.h.

References BB.

Referenced by foldGuardedFunnelShift().

◆ 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 845 of file PatternMatch.h.

Referenced by foldMulSelectToNegate(), m_FPOne(), simplifyUnaryIntrinsic(), llvm::InstCombinerImpl::visitFDiv(), and llvm::InstCombinerImpl::visitFMul().

◆ m_SpecificInt() [1/2]

specific_intval<false> llvm::PatternMatch::m_SpecificInt ( APInt  V)
inline

◆ m_SpecificInt() [2/2]

specific_intval<false> llvm::PatternMatch::m_SpecificInt ( uint64_t  V)
inline

Definition at line 889 of file PatternMatch.h.

References m_SpecificInt().

◆ m_SpecificInt_ICMP()

cst_pred_ty<icmp_pred_with_threshold> llvm::PatternMatch::m_SpecificInt_ICMP ( ICmpInst::Predicate  Predicate,
const APInt Threshold 
)
inline

◆ m_SpecificIntAllowUndef() [1/2]

specific_intval<true> llvm::PatternMatch::m_SpecificIntAllowUndef ( APInt  V)
inline

◆ m_SpecificIntAllowUndef() [2/2]

specific_intval<true> llvm::PatternMatch::m_SpecificIntAllowUndef ( uint64_t  V)
inline

Definition at line 897 of file PatternMatch.h.

References m_SpecificIntAllowUndef().

◆ 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_Store()

template<typename ValueOpTy , typename PointerOpTy >
TwoOps_match<ValueOpTy, PointerOpTy, Instruction::Store> llvm::PatternMatch::m_Store ( const ValueOpTy &  ValueOp,
const PointerOpTy &  PointerOp 
)
inline

Matches StoreInst.

Definition at line 1580 of file PatternMatch.h.

Referenced by llvm::slpvectorizer::BoUpSLP::isLoadCombineCandidate().

◆ m_StrictlyPositive() [1/2]

cst_pred_ty<is_strictlypositive> llvm::PatternMatch::m_StrictlyPositive ( )
inline

Match an integer or vector of strictly positive values.

For vectors, this includes constants with undefined elements.

Definition at line 491 of file PatternMatch.h.

◆ m_StrictlyPositive() [2/2]

api_pred_ty<is_strictlypositive> llvm::PatternMatch::m_StrictlyPositive ( const APInt *&  V)
inline

Definition at line 494 of file PatternMatch.h.

◆ 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_TruncOrSelf()

template<typename OpTy >
match_combine_or<CastClass_match<OpTy, Instruction::Trunc>, OpTy> llvm::PatternMatch::m_TruncOrSelf ( 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 2027 of file PatternMatch.h.

References S.

Referenced by llvm::InstCombinerImpl::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

◆ 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 1720 of file PatternMatch.h.

Referenced by tryToMoveFreeBeforeNullTest().

◆ m_Undef()

auto llvm::PatternMatch::m_Undef ( )
inline

◆ m_Unless()

template<typename Ty >
match_unless<Ty> llvm::PatternMatch::m_Unless ( const Ty &  M)
inline

Match if the inner matcher does NOT match.

Definition at line 174 of file PatternMatch.h.

References M.

Referenced by getBundleFromUse(), m_ImmConstant(), and llvm::InstCombinerImpl::visitXor().

◆ m_UnOp() [1/3]

class_match<UnaryOperator> llvm::PatternMatch::m_UnOp ( )
inline

Match an arbitrary unary operation and ignore it.

Definition at line 79 of file PatternMatch.h.

Referenced by cheapToScalarize(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitExtractElementInst().

◆ m_UnOp() [2/3]

template<typename OP_t >
AnyUnaryOp_match<OP_t> llvm::PatternMatch::m_UnOp ( const OP_t &  X)
inline

Definition at line 973 of file PatternMatch.h.

References X.

◆ m_UnOp() [3/3]

bind_ty<UnaryOperator> llvm::PatternMatch::m_UnOp ( UnaryOperator *&  I)
inline

Match a unary operator, capturing it if we match.

Definition at line 750 of file PatternMatch.h.

References I.

◆ 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 1938 of file PatternMatch.h.

Referenced by llvm::RecurrenceDescriptor::isMinMaxPattern(), 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 1953 of file PatternMatch.h.

Referenced by llvm::RecurrenceDescriptor::isMinMaxPattern(), 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 76 of file PatternMatch.h.

Referenced by llvm::analyzeICmp(), annotateNonNullAndDereferenceable(), llvm::ScalarEvolution::applyLoopGuards(), areExtractExts(), areExtractShuffleVectors(), canAlwaysEvaluateInType(), llvm::canConvertToMinOrMaxIntrinsic(), llvm::InstCombiner::canFreelyInvertAllUsersOf(), llvm::CannotBeNegativeZero(), canonicalizeAbs(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeInsertSplat(), canonicalizeLowbitMask(), canonicalizeSaturatedAdd(), canSafelyConvertTo16Bit(), canScalarizeAccess(), canShiftBinOpWithConstantRHS(), cheapToScalarize(), checkForNegativeOperand(), checkIVUsers(), collectBitParts(), llvm::InstCombinerImpl::combineLoadToNewType(), llvm::InstCombinerImpl::commonCastTransforms(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::commonShiftTransforms(), computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), llvm::computeOverflowForUnsignedSub(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), countToEliminateCompares(), decompose(), llvm::decomposeBitTestICmp(), detectShiftUntilBitTestIdiom(), dropRedundantMaskingOfLeftShiftInput(), eliminateConstraints(), factorizeFAddFSub(), factorizeLerp(), factorizeMathWithShlOps(), findAffectedValues(), llvm::SelectionDAGBuilder::FindMergedConditions(), llvm::findScalarElement(), llvm::InstCombinerImpl::foldAddWithConstant(), foldAndOrOfICmpsWithConstEq(), foldAndToXor(), foldAnyOrAllBitsSet(), foldBitCastBitwiseLogic(), foldBitcastExtElt(), foldBitCastSelect(), foldClampRangeOfTwo(), foldCtpop(), foldCttzCtlz(), foldFabsWithFcmpZero(), foldFDivConstantDividend(), foldFDivConstantDivisor(), foldFNegIntoConstant(), foldGuardedFunnelShift(), llvm::InstCombinerImpl::foldICmpAndConstant(), llvm::InstCombinerImpl::foldICmpAndConstConst(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::InstCombinerImpl::foldICmpEquality(), foldICmpOfUAddOv(), llvm::InstCombinerImpl::foldICmpOrConstant(), foldICmpShlOne(), llvm::InstCombinerImpl::foldICmpTruncConstant(), llvm::InstCombinerImpl::foldICmpUsingKnownBits(), llvm::InstCombinerImpl::foldICmpWithConstant(), llvm::InstCombinerImpl::foldICmpWithDominatingICmp(), foldICmpWithDominatingICmp(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithMinMax(), foldICmpWithTruncSignExtendedVal(), llvm::InstCombinerImpl::foldICmpWithZero(), foldICmpWithZextOrSext(), foldICmpXNegX(), foldIdentityExtractShuffle(), llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(), foldIsPowerOf2(), foldLogicCastConstant(), foldMinMaxSharedOp(), foldMulSelectToNegate(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldNoWrapAdd(), foldOrToXor(), foldSelectBinOpIdentity(), foldSelectGEP(), foldSelectICmpAnd(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), foldSelectICmpLshrAshr(), llvm::InstCombinerImpl::foldSelectOpOp(), foldSelectShuffle(), foldSelectWithBinaryOp(), foldSelectZeroOrMul(), foldSetClearBits(), llvm::InstCombinerImpl::FoldShiftByConstant(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), foldShiftOfShiftedLogic(), foldShuffleWithInsert(), llvm::InstCombinerImpl::foldSignBitTest(), foldSignedTruncationCheck(), foldToUnsignedSaturatedAdd(), foldTruncShuffle(), FoldTwoEntryPHINode(), foldUDivShl(), foldUnsignedUnderflowCheck(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), llvm::InstCombinerImpl::foldVectorBinop(), foldVectorCmp(), foldVecTruncToExtElt(), foldXorToXor(), getBinOpsForFactorization(), getBoolVecFromMask(), llvm::AArch64TTIImpl::getCmpSelInstrCost(), llvm::InstCombiner::getComplexity(), getDomPredecessorCondition(), getHashValueImpl(), getMaskedTypeForICmpPair(), getNotValue(), llvm::getSplatValue(), llvm::TargetTransformInfoImplCRTPBase< AMDGPUTTIImpl >::getUserCost(), getValueFromConditionImpl(), llvm::haveNoCommonBitsSet(), hoistFNegAboveFMulFDiv(), hoistInsEltConst(), llvm::ARMTTIImpl::instCombineIntrinsic(), llvm::X86TTIImpl::instCombineIntrinsic(), llvm::GCNTTIImpl::instCombineIntrinsic(), instCombineSVELast(), instCombineSVETupleGet(), instCombineSVEZip(), llvm::invertCondition(), isAMXCast(), llvm::isCheckForZeroAndMulWithOverflow(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), isEqualImpl(), llvm::InstCombiner::isFreeToInvert(), isImpliedCondAndOr(), isKnownExactCastIntToFP(), llvm::isKnownNegation(), isKnownNonNullFromDominatingCondition(), isKnownNonZero(), isKnownNonZeroFromAssume(), isKnownToBeAPowerOfTwo(), llvm::slpvectorizer::BoUpSLP::isLoadCombineCandidate(), isLoadCombineCandidateImpl(), llvm::RecurrenceDescriptor::isMinMaxPattern(), isMinMaxWithLoads(), isOperandOfVmullHighP64(), llvm::isProcessableCondBI(), llvm::isSplatValue(), isTruePredicate(), LinearizeExprTree(), m_LogicalAnd(), m_LogicalOr(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), llvm::PatternMatch::Signum_match< Opnd_t >::match(), llvm::PatternMatch::VScaleVal_match::match(), matchAndOrChain(), matchDeMorgansLaws(), MatchDiv(), matchesAdd(), matchesOr(), matchExpandedRem(), matchFunnelShift(), matchICmpOperand(), matchIntPart(), MatchMul(), matchOrConcat(), matchRdxBop(), MatchRem(), matchSelectWithOptionalNotCond(), llvm::InstCombinerImpl::matchThreeWayIntCompare(), narrowInsElt(), narrowUDivURem(), narrowVectorSelect(), NegateValue(), OptimizeAndOrXor(), optimizeLoopExitWithUnknownExitCount(), optimizeTrigReflections(), llvm::parseWidenableBranch(), processUMulZExtIdiom(), reassociateFCmps(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::recognizeBSwapOrBitReverseIdiom(), recordCondition(), removeBitcastsFromLoadStoreOnMinMax(), llvm::InstCombiner::shouldAvoidAbsorbingNotIntoSelect(), ShouldBreakUpSubtract(), llvm::RISCVTargetLowering::shouldSinkOperands(), llvm::ARMTargetLowering::shouldSinkOperands(), llvm::X86TargetLowering::shouldSinkOperands(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOfICmpsWithSameOperands(), simplifyAndOrOfICmpsWithLimitConst(), simplifyAndOrOfICmpsWithZero(), SimplifyAShrInst(), llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative(), simplifyBinaryIntrinsic(), SimplifyBSwap(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), simplifyDiv(), simplifyDivRem(), SimplifyFAddInst(), SimplifyFCmpInst(), SimplifyFDivInst(), SimplifyFMAFMul(), simplifyFNegInst(), SimplifyFSubInst(), SimplifyGEPInst(), simplifyICmpWithBinOp(), simplifyICmpWithBinOpOnLHS(), simplifyICmpWithConstant(), simplifyICmpWithMinMax(), simplifyIntrinsic(), simplifyLogicOfAddSub(), SimplifyLShrInst(), SimplifyMulInst(), llvm::InstCombinerImpl::SimplifyMultipleUseDemandedBits(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifyOrOfICmpsWithSameOperands(), simplifyRem(), llvm::InstCombinerImpl::SimplifySelectsFeedingBinaryOp(), simplifySelectWithICmpCond(), SimplifyShift(), SimplifyShlInst(), SimplifyShuffleVectorInst(), SimplifySRemInst(), SimplifySubInst(), simplifyUnaryIntrinsic(), simplifyUnsignedRangeCheck(), simplifyValueKnownNonZero(), llvm::InstCombinerImpl::sinkNotIntoOtherHandOfAndOrOr(), sinkNotIntoXor(), splitMergedValStore(), trySimplifyICmpWithAdds(), tryToRecognizePopCount(), tryToVectorizeHorReductionOrInstOperands(), unswitchBestCondition(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitBranchInst(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitExtractElementInst(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitFDiv(), llvm::InstCombinerImpl::visitFMul(), llvm::InstCombinerImpl::visitFNeg(), llvm::InstCombinerImpl::visitFPTrunc(), llvm::InstCombinerImpl::visitFreeze(), llvm::InstCombinerImpl::visitFSub(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitICmpInst(), llvm::InstCombinerImpl::visitInsertElementInst(), llvm::InstCombinerImpl::visitLShr(), visitMaskedMerge(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitPtrToInt(), llvm::InstCombinerImpl::visitSDiv(), llvm::InstCombinerImpl::visitSExt(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitShuffleVectorInst(), llvm::InstCombinerImpl::visitSRem(), llvm::InstCombinerImpl::visitSub(), llvm::InstCombinerImpl::visitSwitchInst(), llvm::InstCombinerImpl::visitTrunc(), llvm::InstCombinerImpl::visitUDiv(), visitUDivOperand(), llvm::InstCombinerImpl::visitURem(), llvm::InstCombinerImpl::visitXor(), and llvm::InstCombinerImpl::visitZExt().

◆ m_Value() [2/3]

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

Definition at line 745 of file PatternMatch.h.

◆ m_Value() [3/3]

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

Match a value, capturing it if we match.

Definition at line 744 of file PatternMatch.h.

◆ m_VScale()

VScaleVal_match llvm::PatternMatch::m_VScale ( const DataLayout DL)
inline

◆ m_WithOverflowInst() [1/2]

bind_ty<const WithOverflowInst> llvm::PatternMatch::m_WithOverflowInst ( const WithOverflowInst *&  I)
inline

Definition at line 756 of file PatternMatch.h.

References I.

◆ m_WithOverflowInst() [2/2]

bind_ty<WithOverflowInst> llvm::PatternMatch::m_WithOverflowInst ( WithOverflowInst *&  I)
inline

Match a with overflow intrinsic, capturing it if we match.

Definition at line 754 of file PatternMatch.h.

References I.

Referenced by directlyImpliesPoison().

◆ 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()

is_zero llvm::PatternMatch::m_Zero ( )
inline

Match any null constant or a vector with all elements equal to 0.

For vectors, this includes constants with undefined elements.

Definition at line 535 of file PatternMatch.h.

Referenced by areInverseVectorBitmasks(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeICmpBool(), canonicalizeSaturatedSubtract(), cmpExcludesZero(), llvm::ConstantFoldBinaryInstruction(), llvm::InstCombinerImpl::Descale(), detectShiftUntilBitTestIdiom(), foldCttzCtlz(), llvm::InstCombinerImpl::foldICmpBitCast(), foldICmpInvariantGroup(), llvm::InstCombinerImpl::foldICmpWithZero(), foldIdentityExtractShuffle(), llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(), foldSelectICmpAnd(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), foldSelectZeroOrMul(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), llvm::InstCombinerImpl::foldSignBitTest(), foldSignedTruncationCheck(), foldUnsignedUnderflowCheck(), llvm::getGEPInductionOperand(), handleOtherCmpSelSimplifications(), llvm::ARMTTIImpl::instCombineIntrinsic(), llvm::GCNTTIImpl::instCombineIntrinsic(), llvm::isCheckForZeroAndMulWithOverflow(), isNeutralValue(), markAliveBlocks(), llvm::PatternMatch::VScaleVal_match::match(), matchMinMax(), replaceConditionalBranchesOnConstant(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOrOfICmpsWithZero(), simplifyBinaryIntrinsic(), simplifyDivRem(), llvm::InstCombinerImpl::simplifyDivRemOfSelectWithZeroOp(), SimplifyGEPInst(), SimplifyICmpInst(), simplifyICmpOfBools(), simplifyICmpWithConstant(), simplifyICmpWithZero(), simplifyIntrinsic(), SimplifyMulInst(), SimplifyOrInst(), SimplifySelectInst(), simplifySelectWithICmpCond(), SimplifyShift(), SimplifySubInst(), simplifyUnsignedRangeCheck(), simplifyWithOpReplaced(), SimplifyXorInst(), tryToMoveFreeBeforeNullTest(), unswitchBestCondition(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitICmpInst(), llvm::InstCombinerImpl::visitPHINode(), llvm::InstCombinerImpl::visitSDiv(), and llvm::InstCombinerImpl::visitSRem().

◆ m_ZeroInt()

cst_pred_ty<is_zero_int> llvm::PatternMatch::m_ZeroInt ( )
inline

◆ m_ZExt()

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

◆ m_ZExtOrSelf()

template<typename OpTy >
match_combine_or<CastClass_match<OpTy, Instruction::ZExt>, OpTy> llvm::PatternMatch::m_ZExtOrSelf ( 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

◆ m_ZExtOrSExtOrSelf()

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

Definition at line 1667 of file PatternMatch.h.

References m_CombineOr(), and m_ZExtOrSExt().

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

◆ match() [1/2]

template<typename Pattern >
bool llvm::PatternMatch::match ( ArrayRef< int Mask,
const Pattern P 
)

◆ match() [2/2]

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 llvm::AliasSetTracker::add(), llvm::analyzeICmp(), annotateNonNullAndDereferenceable(), llvm::ScalarEvolution::applyLoopGuards(), areExtractExts(), areExtractShuffleVectors(), areInverseVectorBitmasks(), canAlwaysEvaluateInType(), llvm::canConvertToMinOrMaxIntrinsic(), canEvaluateShiftedShift(), canEvaluateZExtd(), llvm::InstCombiner::canFreelyInvertAllUsersOf(), llvm::VPIntrinsic::canIgnoreVectorLengthParam(), canNarrowShiftAmt(), llvm::CannotBeNegativeZero(), cannotBeOrderedLessThanZeroImpl(), canonicalizeAbs(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), canonicalizeICmpBool(), canonicalizeInsertSplat(), canonicalizeLowbitMask(), canonicalizeSaturatedAdd(), canonicalizeSaturatedSubtract(), canSafelyConvertTo16Bit(), canScalarizeAccess(), canShiftBinOpWithConstantRHS(), llvm::GCNTTIImpl::canSimplifyLegacyMulToMul(), llvm::canSinkOrHoistInst(), cheapToScalarize(), checkForNegativeOperand(), checkIVUsers(), checkOuterLoopInsts(), cmpExcludesZero(), collectBitParts(), collectHomogenousInstGraphLoopInvariants(), collectShuffleElements(), collectSingleShuffleElements(), llvm::InstCombinerImpl::combineLoadToNewType(), llvm::InstCombinerImpl::commonCastTransforms(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::commonIRemTransforms(), llvm::InstCombinerImpl::commonShiftTransforms(), llvm::computeConstantRange(), computeKnownBits(), computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), ComputeNumSignBitsImpl(), llvm::computeOverflowForUnsignedSub(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), llvm::ConstantFoldBinaryInstruction(), countToEliminateCompares(), decompose(), llvm::decomposeBitTestICmp(), llvm::InstCombinerImpl::Descale(), despeculateCountZeros(), detectShiftUntilBitTestIdiom(), directlyImpliesPoison(), dropRedundantMaskingOfLeftShiftInput(), eliminateConstraints(), evaluateInDifferentElementOrder(), factorizeFAddFSub(), factorizeLerp(), factorizeMathWithShlOps(), findAffectedValues(), llvm::SelectionDAGBuilder::FindMergedConditions(), llvm::findScalarElement(), llvm::InstCombinerImpl::foldAddWithConstant(), foldAndOrOfEqualityCmpsWithConstants(), foldAndOrOfICmpsWithConstEq(), foldAndToXor(), foldAnyOrAllBitsSet(), foldBitCastBitwiseLogic(), foldBitcastExtElt(), foldBitCastSelect(), foldClampRangeOfTwo(), foldConstantInsEltIntoShuffle(), foldCtpop(), foldCttzCtlz(), foldFabsWithFcmpZero(), foldFCmpReciprocalAndZero(), foldFDivConstantDividend(), foldFDivConstantDivisor(), foldFNegIntoConstant(), foldGuardedFunnelShift(), llvm::InstCombinerImpl::foldICmpAddConstant(), llvm::InstCombinerImpl::foldICmpAndConstant(), llvm::InstCombinerImpl::foldICmpAndConstConst(), llvm::InstCombinerImpl::foldICmpAndShift(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpBinOpEqualityWithConstant(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::InstCombinerImpl::foldICmpDivConstant(), llvm::InstCombinerImpl::foldICmpEqIntrinsicWithConstant(), llvm::InstCombinerImpl::foldICmpEquality(), llvm::InstCombinerImpl::foldICmpInstWithConstant(), foldICmpInvariantGroup(), llvm::InstCombinerImpl::foldICmpMulConstant(), foldICmpOfUAddOv(), llvm::InstCombinerImpl::foldICmpOrConstant(), llvm::InstCombinerImpl::foldICmpShlConstant(), foldICmpShlOne(), llvm::InstCombinerImpl::foldICmpShrConstant(), llvm::InstCombinerImpl::foldICmpSRemConstant(), llvm::InstCombinerImpl::foldICmpSubConstant(), llvm::InstCombinerImpl::foldICmpTruncConstant(), llvm::InstCombinerImpl::foldICmpUDivConstant(), llvm::InstCombinerImpl::foldICmpUsingKnownBits(), llvm::InstCombinerImpl::foldICmpWithConstant(), llvm::InstCombinerImpl::foldICmpWithDominatingICmp(), foldICmpWithDominatingICmp(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithMinMax(), foldICmpWithTruncSignExtendedVal(), llvm::InstCombinerImpl::foldICmpWithZero(), foldICmpWithZextOrSext(), foldICmpXNegX(), llvm::InstCombinerImpl::foldICmpXorConstant(), foldIdentityExtractShuffle(), foldIdentityPaddedShuffles(), foldInsEltIntoIdentityShuffle(), foldInsEltIntoSplat(), foldInsSequenceIntoSplat(), llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(), foldIsPowerOf2(), foldLogicCastConstant(), foldLogOpOfMaskedICmps(), foldLogOpOfMaskedICmps_NotAllZeros_BMask_Mixed(), foldMinMaxSharedOp(), foldMulSelectToNegate(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldNoWrapAdd(), llvm::InstCombinerImpl::foldOpIntoPhi(), llvm::InstCombinerImpl::FoldOpIntoSelect(), foldOrToXor(), foldSelectBinOpIdentity(), foldSelectGEP(), foldSelectICmpAnd(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), foldSelectICmpLshrAshr(), llvm::InstCombinerImpl::foldSelectIntoOp(), llvm::InstCombinerImpl::foldSelectOpOp(), foldSelectShuffle(), foldSelectShuffleWith1Binop(), foldSelectWithBinaryOp(), foldSelectZeroOrMul(), foldSetClearBits(), llvm::InstCombinerImpl::FoldShiftByConstant(), foldShiftedShift(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), foldShiftOfShiftedLogic(), foldShuffleWithInsert(), llvm::InstCombinerImpl::foldSignBitTest(), foldSignedTruncationCheck(), foldToUnsignedSaturatedAdd(), foldTruncShuffle(), FoldTwoEntryPHINode(), foldUDivShl(), foldUnsignedUnderflowCheck(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), llvm::InstCombinerImpl::foldVectorBinop(), foldVectorCmp(), foldVecTruncToExtElt(), foldXorToXor(), getAlternateBinop(), llvm::GCNTTIImpl::getArithmeticInstrCost(), getBinOpsForFactorization(), getBoolVecFromMask(), getBundleFromUse(), llvm::AArch64TTIImpl::getCmpSelInstrCost(), llvm::InstCombiner::getComplexity(), getDemandedBitsLHSMask(), getDomPredecessorCondition(), llvm::ConstantExpr::getExactLogBase2(), llvm::ARMTTIImpl::getGatherScatterOpCost(), llvm::getGEPInductionOperand(), getHashValueImpl(), getMaskedTypeForICmpPair(), getNegatibleInsts(), getNotValue(), llvm::SCEVExpander::getRelatedExistingExpansion(), llvm::getSplatValue(), llvm::TargetTransformInfoImplCRTPBase< AMDGPUTTIImpl >::getUserCost(), getValueFromConditionImpl(), getValueFromICmpCondition(), getValueFromOverflowCondition(), llvm::SelectionDAGBuilder::getValueImpl(), handleOtherCmpSelSimplifications(), llvm::haveNoCommonBitsSet(), hoistFNegAboveFMulFDiv(), hoistInsEltConst(), llvm::hoistRegion(), llvm::ARMTTIImpl::instCombineIntrinsic(), llvm::X86TTIImpl::instCombineIntrinsic(), llvm::GCNTTIImpl::instCombineIntrinsic(), instCombineSVELast(), instCombineSVETupleGet(), instCombineSVEVectorMul(), instCombineSVEZip(), llvm::invertCondition(), isAMXCast(), llvm::isCheckForZeroAndMulWithOverflow(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), isDivZero(), llvm::Constant::isElementWiseEqual(), isEqualImpl(), llvm::InstCombiner::isFreeToInvert(), llvm::isGuard(), llvm::isGuardAsWidenableBranch(), isImpliedCondAndOr(), isKnownExactCastIntToFP(), llvm::isKnownNegation(), isKnownNonNullFromDominatingCondition(), isKnownNonZero(), isKnownNonZeroFromAssume(), isKnownToBeAPowerOfTwo(), llvm::slpvectorizer::BoUpSLP::isLoadCombineCandidate(), isLoadCombineCandidateImpl(), isLoopNeverExecuted(), llvm::RecurrenceDescriptor::isMinMaxPattern(), isMinMaxWithLoads(), isNeutralValue(), isNonEqualMul(), isNonEqualPHIs(), isNonEqualShl(), isOperandOfVmullHighP64(), llvm::isProcessableCondBI(), isPTruePromoted(), llvm::isSafeToSpeculativelyExecute(), isSignedMinMaxClamp(), llvm::MemoryWriteTracking::isSpecialInstruction(), llvm::isSplatValue(), isSSATMinMaxPattern(), isTruePredicate(), llvm::SimplifyQuery::isUndefValue(), likeBitCastFromVector(), LinearizeExprTree(), lookThroughAnd(), lookThroughCast(), lowerWidenableCondition(), maintainNoSignedWrap(), markAliveBlocks(), match(), matchAndOrChain(), matchClamp(), matchDeMorgansLaws(), MatchDiv(), matchesAdd(), matchesOr(), matchExpandedRem(), matchFastFloatClamp(), matchFunnelShift(), matchICmpOperand(), matchIncrement(), matchIntPart(), matchMinMax(), matchMinMaxOfMinMax(), MatchMul(), matchOrConcat(), matchRdxBop(), MatchRem(), matchSelectPattern(), matchSelectWithOptionalNotCond(), llvm::InstCombinerImpl::matchThreeWayIntCompare(), matchUAddWithOverflowConstantEdgeCases(), llvm::Constant::mergeUndefsWith(), narrowInsElt(), narrowUDivURem(), narrowVectorSelect(), NegateValue(), OptimizeAndOrXor(), optimizeBranch(), optimizeLoopExitWithUnknownExitCount(), optimizeTrigReflections(), llvm::parseWidenableBranch(), processUMulZExtIdiom(), processUse(), reassociateFCmps(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::recognizeBSwapOrBitReverseIdiom(), recordCondition(), llvm::AssumptionCache::registerAssumption(), removeBitcastsFromLoadStoreOnMinMax(), replaceConditionalBranchesOnConstant(), llvm::Constant::replaceUndefsWith(), setLimitsForBinOp(), setLimitsForIntrinsic(), setLimitsForSelectPattern(), llvm::InstCombiner::shouldAvoidAbsorbingNotIntoSelect(), ShouldBreakUpSubtract(), llvm::RISCVTargetLowering::shouldSinkOperands(), llvm::ARMTargetLowering::shouldSinkOperands(), llvm::X86TargetLowering::shouldSinkOperands(), ShrinkDemandedConstant(), shrinkInsertElt(), shrinkSplatShuffle(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOfICmpsWithAdd(), simplifyAndOfICmpsWithSameOperands(), simplifyAndOrOfICmpsWithConstants(), simplifyAndOrOfICmpsWithLimitConst(), simplifyAndOrOfICmpsWithZero(), SimplifyAShrInst(), simplifyAssocCastAssoc(), llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative(), simplifyBinaryIntrinsic(), SimplifyBSwap(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), simplifyDiv(), simplifyDivRem(), llvm::InstCombinerImpl::simplifyDivRemOfSelectWithZeroOp(), SimplifyFAddInst(), SimplifyFCmpInst(), SimplifyFDivInst(), SimplifyFMAFMul(), simplifyFNegInst(), simplifyFPOp(), SimplifyFRemInst(), SimplifyFSubInst(), SimplifyGEPInst(), SimplifyICmpInst(), simplifyICmpOfBools(), simplifyICmpWithBinOp(), simplifyICmpWithBinOpOnLHS(), simplifyICmpWithConstant(), simplifyICmpWithMinMax(), simplifyICmpWithZero(), llvm::SimplifyInsertElementInst(), simplifyIntrinsic(), simplifyLogicOfAddSub(), SimplifyLShrInst(), SimplifyMulInst(), llvm::InstCombinerImpl::SimplifyMultipleUseDemandedBits(), SimplifyOrInst(), simplifyOrOfICmpsWithAdd(), simplifyOrOfICmpsWithSameOperands(), simplifyRem(), simplifySelectBitTest(), SimplifySelectInst(), llvm::InstCombinerImpl::SimplifySelectsFeedingBinaryOp(), simplifySelectWithFCmp(), simplifySelectWithICmpCond(), SimplifyShift(), SimplifyShlInst(), SimplifyShuffleVectorInst(), SimplifySRemInst(), SimplifySubInst(), simplifyUnaryIntrinsic(), simplifyUnsignedRangeCheck(), simplifyValueKnownNonZero(), simplifyWithOpReplaced(), simplifyX86addcarry(), SimplifyXorInst(), llvm::InstCombinerImpl::sinkNotIntoOtherHandOfAndOrOr(), sinkNotIntoXor(), splitMergedValStore(), swapMayExposeCSEOpportunities(), llvm::InstCombinerImpl::tryFactorization(), trySimplifyICmpWithAdds(), tryToMoveFreeBeforeNullTest(), tryToRecognizePopCount(), llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(), tryToVectorizeHorReductionOrInstOperands(), unswitchBestCondition(), unswitchNontrivialInvariants(), unswitchTrivialBranch(), llvm::AssumptionCacheTracker::verifyAnalysis(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitBitCast(), llvm::InstCombinerImpl::visitBranchInst(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitExtractElementInst(), llvm::InstCombinerImpl::visitExtractValueInst(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitFDiv(), llvm::InstCombinerImpl::visitFMul(), llvm::InstCombinerImpl::visitFNeg(), llvm::InstCombinerImpl::visitFPTrunc(), llvm::InstCombinerImpl::visitFreeze(), llvm::InstCombinerImpl::visitFSub(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitICmpInst(), llvm::InstCombinerImpl::visitInsertElementInst(), llvm::InstCombinerImpl::visitLShr(), visitMaskedMerge(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitPHINode(), llvm::InstCombinerImpl::visitPtrToInt(), llvm::InstCombinerImpl::visitSDiv(), llvm::InstCombinerImpl::visitSExt(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitShuffleVectorInst(), llvm::InstCombinerImpl::visitSRem(), llvm::InstCombinerImpl::visitSub(), llvm::InstCombinerImpl::visitSwitchInst(), llvm::InstCombinerImpl::visitTrunc(), llvm::InstCombinerImpl::visitUDiv(), visitUDivOperand(), llvm::InstCombinerImpl::visitURem(), llvm::InstCombinerImpl::visitXor(), llvm::InstCombinerImpl::visitZExt(), and llvm::reassociate::XorOpnd::XorOpnd().