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	constantexpr_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	NotForbidUndef_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	SpecificBinaryOp_match

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< T >	m_OneUse (const T &SubPattern)

class_match< Value >	m_Value ()
	Match an arbitrary value and ignore it. More...

class_match< UnaryOperator >	m_UnOp ()
	Match an arbitrary unary operation and ignore it. More...

class_match< BinaryOperator >	m_BinOp ()
	Match an arbitrary binary operation and ignore it. More...

class_match< CmpInst >	m_Cmp ()
	Matches any compare instruction and ignore it. More...

auto	m_Undef ()
	Match an arbitrary undef constant. More...

class_match< PoisonValue >	m_Poison ()
	Match an arbitrary poison constant. More...

class_match< Constant >	m_Constant ()
	Match an arbitrary Constant and ignore it. More...

class_match< ConstantInt >	m_ConstantInt ()
	Match an arbitrary ConstantInt and ignore it. More...

class_match< ConstantFP >	m_ConstantFP ()
	Match an arbitrary ConstantFP and ignore it. More...

constantexpr_match	m_ConstantExpr ()
	Match a constant expression or a constant that contains a constant expression. More...

class_match< BasicBlock >	m_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_apint >	m_AnyIntegralConstant ()
	Match an integer or vector with any integral constant. More...

cst_pred_ty< is_all_ones >	m_AllOnes ()
	Match an integer or vector with all bits set. More...

cst_pred_ty< is_maxsignedvalue >	m_MaxSignedValue ()
	Match an integer or vector with values having all bits except for the high bit set (0x7f...). More...

api_pred_ty< is_maxsignedvalue >	m_MaxSignedValue (const APInt *&V)

cst_pred_ty< is_negative >	m_Negative ()
	Match an integer or vector of negative values. More...

api_pred_ty< is_negative >	m_Negative (const APInt *&V)

cst_pred_ty< is_nonnegative >	m_NonNegative ()
	Match an integer or vector of non-negative values. More...

api_pred_ty< is_nonnegative >	m_NonNegative (const APInt *&V)

cst_pred_ty< is_strictlypositive >	m_StrictlyPositive ()
	Match an integer or vector of strictly positive values. More...

api_pred_ty< is_strictlypositive >	m_StrictlyPositive (const APInt *&V)

cst_pred_ty< is_nonpositive >	m_NonPositive ()
	Match an integer or vector of non-positive values. More...

api_pred_ty< is_nonpositive >	m_NonPositive (const APInt *&V)

cst_pred_ty< is_one >	m_One ()
	Match an integer 1 or a vector with all elements equal to 1. More...

cst_pred_ty< is_zero_int >	m_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_power2 >	m_Power2 ()
	Match an integer or vector power-of-2. More...

api_pred_ty< is_power2 >	m_Power2 (const APInt *&V)

cst_pred_ty< is_negated_power2 >	m_NegatedPower2 ()
	Match a integer or vector negated power-of-2. More...

api_pred_ty< is_negated_power2 >	m_NegatedPower2 (const APInt *&V)

cst_pred_ty< is_power2_or_zero >	m_Power2OrZero ()
	Match an integer or vector of 0 or power-of-2 values. More...

api_pred_ty< is_power2_or_zero >	m_Power2OrZero (const APInt *&V)

cst_pred_ty< is_sign_mask >	m_SignMask ()
	Match an integer or vector with only the sign bit(s) set. More...

cst_pred_ty< is_lowbit_mask >	m_LowBitMask ()
	Match an integer or vector with only the low bit(s) set. More...

api_pred_ty< is_lowbit_mask >	m_LowBitMask (const APInt *&V)

cst_pred_ty< icmp_pred_with_threshold >	m_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_nan >	m_NaN ()
	Match an arbitrary NaN constant. More...

cstfp_pred_ty< is_nonnan >	m_NonNaN ()
	Match a non-NaN FP constant. More...

cstfp_pred_ty< is_inf >	m_Inf ()
	Match a positive or negative infinity FP constant. More...

cstfp_pred_ty< is_noninf >	m_NonInf ()
	Match a non-infinity FP constant, i.e. More...

cstfp_pred_ty< is_finite >	m_Finite ()
	Match a finite FP constant, i.e. More...

apf_pred_ty< is_finite >	m_Finite (const APFloat *&V)

cstfp_pred_ty< is_finitenonzero >	m_FiniteNonZero ()
	Match a finite non-zero FP constant. More...

apf_pred_ty< is_finitenonzero >	m_FiniteNonZero (const APFloat *&V)

cstfp_pred_ty< is_any_zero_fp >	m_AnyZeroFP ()
	Match a floating-point negative zero or positive zero. More...

cstfp_pred_ty< is_pos_zero_fp >	m_PosZeroFP ()
	Match a floating-point positive zero. More...

cstfp_pred_ty< is_neg_zero_fp >	m_NegZeroFP ()
	Match a floating-point negative zero. More...

cstfp_pred_ty< is_non_zero_fp >	m_NonZeroFP ()
	Match a floating-point non-zero. More...

bind_ty< Value >	m_Value (Value *&V)
	Match a value, capturing it if we match. More...

bind_ty< const Value >	m_Value (const Value *&V)

bind_ty< Instruction >	m_Instruction (Instruction *&I)
	Match an instruction, capturing it if we match. More...

bind_ty< UnaryOperator >	m_UnOp (UnaryOperator *&I)
	Match a unary operator, capturing it if we match. More...

bind_ty< BinaryOperator >	m_BinOp (BinaryOperator *&I)
	Match a binary operator, capturing it if we match. More...

bind_ty< WithOverflowInst >	m_WithOverflowInst (WithOverflowInst *&I)
	Match a with overflow intrinsic, capturing it if we match. More...

bind_ty< const WithOverflowInst >	m_WithOverflowInst (const WithOverflowInst *&I)

bind_ty< Constant >	m_Constant (Constant *&C)
	Match a Constant, capturing the value if we match. More...

bind_ty< ConstantInt >	m_ConstantInt (ConstantInt *&CI)
	Match a ConstantInt, capturing the value if we match. More...

bind_ty< ConstantFP >	m_ConstantFP (ConstantFP *&C)
	Match a ConstantFP, capturing the value if we match. More...

bind_ty< ConstantExpr >	m_ConstantExpr (ConstantExpr *&C)
	Match a ConstantExpr, capturing the value if we match. More...

bind_ty< BasicBlock >	m_BasicBlock (BasicBlock *&V)
	Match a basic block value, capturing it if we match. More...

bind_ty< const BasicBlock >	m_BasicBlock (const BasicBlock *&V)

match_combine_and< class_match< Constant >, match_unless< constantexpr_match > >	m_ImmConstant ()
	Match an arbitrary immediate Constant and ignore it. More...

match_combine_and< bind_ty< Constant >, match_unless< constantexpr_match > >	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< Value >	m_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 Value >	m_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< false >	m_SpecificInt (APInt V)
	Match a specific integer value or vector with all elements equal to the value. More...

specific_intval< false >	m_SpecificInt (uint64_t V)

specific_intval< true >	m_SpecificIntAllowUndef (APInt V)

specific_intval< true >	m_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< BasicBlock >	m_Deferred (BasicBlock *const &BB)
	A commutative-friendly version of m_Specific(). More...

deferredval_ty< const BasicBlock >	m_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::NoSignedWrap >	m_NSWAdd (const LHS &L, const RHS &R)

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

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

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

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

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

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

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

template<typename LHS , typename RHS >
SpecificBinaryOp_match< LHS, RHS >	m_BinOp (unsigned Opcode, const LHS &L, const RHS &R)
	Matches a specific opcode. More...

template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_shift_op >	m_Shift (const LHS &L, const RHS &R)
	Matches shift operations. More...

template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_right_shift_op >	m_Shr (const LHS &L, const RHS &R)
	Matches logical shift operations. More...

template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_logical_shift_op >	m_LogicalShift (const LHS &L, const RHS &R)
	Matches logical shift operations. More...

template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_bitwiselogic_op >	m_BitwiseLogic (const LHS &L, const RHS &R)
	Matches bitwise logic operations. More...

template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_idiv_op >	m_IDiv (const LHS &L, const RHS &R)
	Matches integer division operations. More...

template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_irem_op >	m_IRem (const LHS &L, const RHS &R)
	Matches integer remainder operations. More...

template<typename T >
Exact_match< T >	m_Exact (const T &SubPattern)

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

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

template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate >	m_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_ty >	m_SMax (const LHS &L, const RHS &R)

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

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

template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty >	m_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_ty >	m_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_ty >	m_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_ty >	m_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_ty >	m_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<typename Opnd0 , typename Opnd1 , typename Opnd2 , typename Opnd3 >
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty	m_MaskedGather (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
	Matches MaskedGather 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 Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty	m_Sqrt (const Opnd0 &Op0)

template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS, true >	m_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, true >	m_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 >
SpecificBinaryOp_match< LHS, RHS, true >	m_c_BinOp (unsigned Opcode, const LHS &L, const RHS &R)
	Matches a specific opcode with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Add, true >	m_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, true >	m_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, true >	m_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, true >	m_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, true >	m_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::NoSignedWrap >	m_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, true >	m_Not (const ValTy &V)
	Matches a 'Not' as 'xor V, -1' or 'xor -1, V'. More...

template<typename ValTy >
NotForbidUndef_match< ValTy >	m_NotForbidUndef (const ValTy &V)
	Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. More...

template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true >	m_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, true >	m_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, true >	m_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, true >	m_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, true >	m_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, true >	m_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::And, true >	m_c_LogicalAnd (const LHS &L, const RHS &R)
	Matches L && R with LHS and RHS in either order. 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...

template<typename LHS , typename RHS >
LogicalOp_match< LHS, RHS, Instruction::Or, true >	m_c_LogicalOr (const LHS &L, const RHS &R)
	Matches L \|\| R with LHS and RHS in either order. 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 372 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 376 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

Definition at line 979 of file PatternMatch.h.

◆ m_AllOnes()

cst_pred_ty<is_all_ones> llvm::PatternMatch::m_AllOnes ( )

inline

Match an integer or vector with all bits set.

For vectors, this includes constants with undefined elements.

Definition at line 453 of file PatternMatch.h.

◆ m_And()

template<typename LHS , typename RHS >

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

inline

Definition at line 1093 of file PatternMatch.h.

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

Match a floating-point negative zero or positive zero.

For vectors, this includes constants with undefined elements.

Definition at line 664 of file PatternMatch.h.

Referenced by foldFCmpReciprocalAndZero(), foldSelectBinOpIdentity(), llvm::GCNTTIImpl::instCombineIntrinsic(), m_FNegNSZ(), matchSelectPattern(), reassociateFCmps(), simplifyFAddInst(), simplifyFCmpInst(), simplifyFDivInst(), simplifyFMAFMul(), simplifyFSubInst(), llvm::InstCombinerImpl::visitFAdd(), and llvm::InstCombinerImpl::visitFCmpInst().

◆ m_APFloat()

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

inline

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

Definition at line 295 of file PatternMatch.h.

Referenced by cannotBeOrderedLessThanZeroImpl(), factorizeFAddFSub(), foldFCmpReciprocalAndZero(), getNegatibleInsts(), llvm::GCNTTIImpl::instCombineIntrinsic(), matchFastFloatClamp(), simplifyBinaryIntrinsic(), simplifyFCmpInst(), simplifySelectWithFCmp(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFAdd(), and llvm::InstCombinerImpl::visitFCmpInst().

◆ m_APFloatAllowUndef()

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

inline

Match APFloat while allowing undefs in splat vector constants.

Definition at line 301 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 306 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 278 of file PatternMatch.h.

◆ m_APIntAllowUndef()

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

inline

Match APInt while allowing undefs in splat vector constants.

Definition at line 284 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpEquality(), llvm::InstCombinerImpl::foldICmpInstWithConstant(), llvm::InstCombinerImpl::FoldOpIntoSelect(), matchFunnelShift(), simplifyBinaryIntrinsic(), simplifyICmpWithBinOp(), simplifyICmpWithBinOpOnLHS(), simplifyICmpWithConstant(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitXor().

◆ m_APIntForbidUndef()

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

inline

Match APInt while forbidding undefs in splat vector constants.

Definition at line 289 of file PatternMatch.h.

Referenced by llvm::PatternMatch::NotForbidUndef_match< ValTy >::match().

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

Definition at line 1123 of file PatternMatch.h.

◆ m_BasicBlock() [1/3]

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

inline

Match an arbitrary basic block value and ignore it.

Definition at line 168 of file PatternMatch.h.

Referenced by computeKnownBitsFromOperator(), detectShiftUntilBitTestIdiom(), detectShiftUntilZeroIdiom(), llvm::SCEVExpander::getRelatedExistingExpansion(), llvm::isProcessableCondBI(), m_Br(), optimizeLoopExitWithUnknownExitCount(), and llvm::InstCombinerImpl::visitBranchInst().

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

◆ m_BasicBlock() [3/3]

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

inline

Definition at line 744 of file PatternMatch.h.

◆ m_BinOp() [1/4]

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

inline

Match an arbitrary binary operation and ignore it.

Definition at line 84 of file PatternMatch.h.

◆ m_BinOp() [2/4]

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

inline

Match a binary operator, capturing it if we match.

Definition at line 720 of file PatternMatch.h.

References I.

◆ m_BinOp() [3/4]

template<typename LHS , typename RHS >

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

inline

Definition at line 922 of file PatternMatch.h.

◆ m_BinOp() [4/4]

template<typename LHS , typename RHS >

SpecificBinaryOp_match<LHS, RHS> llvm::PatternMatch::m_BinOp	(	unsigned	Opcode,
		const LHS &	L,
		const RHS &	R
	)

inline

Matches a specific opcode.

Definition at line 1234 of file PatternMatch.h.

◆ m_BitCast()

template<typename OpTy >

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

inline

Matches BitCast.

Definition at line 1593 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::combineLoadToNewType(), findAffectedValues(), foldBitCastBitwiseLogic(), foldBitCastSelect(), foldIdentityExtractShuffle(), foldReductionIdiom(), foldTruncShuffle(), foldVecTruncToExtElt(), removeBitcastsFromLoadStoreOnMinMax(), simplifyICmpWithConstant(), llvm::InstCombinerImpl::visitBitCast(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitInsertElementInst(), and llvm::InstCombinerImpl::visitShuffleVectorInst().

◆ m_BitReverse()

template<typename Opnd0 >

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

inline

Definition at line 2161 of file PatternMatch.h.

Referenced by collectBitParts(), foldCtpop(), foldCttzCtlz(), matchOrConcat(), and simplifyUnaryIntrinsic().

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

Definition at line 1731 of file PatternMatch.h.

References F, m_BasicBlock(), and T.

Referenced by computeKnownBitsFromOperator(), detectShiftUntilBitTestIdiom(), detectShiftUntilZeroIdiom(), foldGuardedFunnelShift(), llvm::InstCombinerImpl::foldICmpWithDominatingICmp(), foldICmpWithDominatingICmp(), getDomPredecessorCondition(), llvm::SCEVExpander::getRelatedExistingExpansion(), isLoopNeverExecuted(), llvm::isProcessableCondBI(), optimizeLoopExitWithUnknownExitCount(), tryToMoveFreeBeforeNullTest(), and llvm::InstCombinerImpl::visitBranchInst().

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

Definition at line 2166 of file PatternMatch.h.

Referenced by collectBitParts(), foldCtpop(), matchOrConcat(), SimplifyBSwap(), simplifyUnaryIntrinsic(), and llvm::InstCombinerImpl::visitCallInst().

◆ m_c_Add()

template<typename LHS , typename RHS >

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

inline

Matches a Add with LHS and RHS in either order.

Definition at line 2237 of file PatternMatch.h.

Referenced by canonicalizeAbs(), canonicalizeSaturatedAdd(), detectShiftUntilZeroIdiom(), llvm::InstCombinerImpl::foldICmpBinOp(), foldSubOfMinMax(), foldToUnsignedSaturatedAdd(), foldUnsignedUnderflowCheck(), llvm::ARMTTIImpl::instCombineIntrinsic(), FlattenInfo::matchLinearIVUser(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), simplifyOrInst(), trySimplifyICmpWithAdds(), tryToRecognizePopCount(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitLShr(), and llvm::InstCombinerImpl::visitSub().

◆ m_c_And()

template<typename LHS , typename RHS >

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

inline

Matches an And with LHS and RHS in either order.

Definition at line 2251 of file PatternMatch.h.

◆ m_c_BinOp() [1/2]

template<typename LHS , typename RHS >

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

inline

Matches a BinaryOperator with LHS and RHS in either order.

Definition at line 2215 of file PatternMatch.h.

◆ m_c_BinOp() [2/2]

template<typename LHS , typename RHS >

SpecificBinaryOp_match<LHS, RHS, true> llvm::PatternMatch::m_c_BinOp	(	unsigned	Opcode,
		const LHS &	L,
		const RHS &	R
	)

inline

Matches a specific opcode with LHS and RHS in either order.

Definition at line 2231 of file PatternMatch.h.

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

Matches FMul with LHS and RHS in either order.

Definition at line 2364 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), factorizeLerp(), foldMulSelectToNegate(), simplifyFDivInst(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFDiv(), llvm::InstCombinerImpl::visitFMul(), and llvm::InstCombinerImpl::visitFSub().

◆ m_c_ICmp()

template<typename LHS , typename RHS >

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

inline

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

Swaps the predicate if operands are commuted.

Definition at line 2223 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), computeKnownBitsFromOperator(), foldAndOrOfICmpsWithConstEq(), foldICmpUsingBoolRange(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), foldICmpXNegX(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldSelectWithBinaryOp(), foldUnsignedUnderflowCheck(), isKnownNonNullFromDominatingCondition(), isKnownNonZeroFromAssume(), simplifyAndOrOfICmpsWithLimitConst(), and simplifyUnsignedRangeCheck().

◆ m_c_LogicalAnd()

template<typename LHS , typename RHS >

LogicalOp_match<LHS, RHS, Instruction::And, true> llvm::PatternMatch::m_c_LogicalAnd	(	const LHS &	L,
		const RHS &	R
	)

inline

Matches L && R with LHS and RHS in either order.

Definition at line 2548 of file PatternMatch.h.

◆ m_c_LogicalOr()

template<typename LHS , typename RHS >

LogicalOp_match<LHS, RHS, Instruction::Or, true> llvm::PatternMatch::m_c_LogicalOr	(	const LHS &	L,
		const RHS &	R
	)

inline

Matches L || R with LHS and RHS in either order.

Definition at line 2566 of file PatternMatch.h.

Referenced by simplifySelectInst().

◆ 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

Definition at line 2349 of file PatternMatch.h.

References m_c_SMax(), m_c_SMin(), m_c_UMax(), m_c_UMin(), and m_CombineOr().

Referenced by foldMinMaxSharedOp(), reassociateMinMaxWithConstantInOperand(), and llvm::InstCombinerImpl::visitSub().

◆ m_c_Mul()

template<typename LHS , typename RHS >

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

inline

Matches a Mul with LHS and RHS in either order.

Definition at line 2244 of file PatternMatch.h.

Referenced by llvm::VPIntrinsic::canIgnoreVectorLengthParam(), checkOuterLoopInsts(), llvm::InstCombinerImpl::commonIDivTransforms(), foldMulSelectToNegate(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldSelectZeroOrMul(), matchExpandedRem(), FlattenInfo::matchLinearIVUser(), simplifyDivRem(), and llvm::InstCombinerImpl::visitMul().

◆ 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 2327 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 2321 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 2339 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), m_c_MaxOrMin(), and llvm::InstCombinerImpl::visitSub().

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

Referenced by foldICmpWithMinMax(), foldToUnsignedSaturatedAdd(), m_c_MaxOrMin(), and llvm::InstCombinerImpl::visitSub().

◆ m_c_Xor()

template<typename LHS , typename RHS >

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

inline

Matches an Xor with LHS and RHS in either order.

Definition at line 2265 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), foldComplexAndOrPatterns(), llvm::InstCombinerImpl::foldICmpXorShiftConst(), foldXorToXor(), llvm::haveNoCommonBitsSet(), m_Not(), simplifyAndInst(), simplifyOrLogic(), llvm::InstCombinerImpl::visitAnd(), visitMaskedMerge(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitSub(), and llvm::InstCombinerImpl::visitXor().

◆ m_Cmp() [1/2]

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

inline

Matches any compare instruction and ignore it.

Definition at line 89 of file PatternMatch.h.

Referenced by cheapToScalarize(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), foldSelectBinOpIdentity(), llvm::AArch64TTIImpl::getCmpSelInstrCost(), getHashValueImpl(), llvm::GCNTTIImpl::instCombineIntrinsic(), isEqualImpl(), llvm::RecurrenceDescriptor::isMinMaxPattern(), isMinMaxWithLoads(), llvm::RecurrenceDescriptor::isSelectCmpPattern(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitExtractElementInst().

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

◆ m_CombineAnd()

template<typename LTy , typename RTy >

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

inline

Combine two pattern matchers matching L && R.

Definition at line 224 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), detectShiftUntilBitTestIdiom(), dropRedundantMaskingOfLeftShiftInput(), foldComplexAndOrPatterns(), foldFNegShuffle(), foldICmpWithLowBitMaskedVal(), llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), m_ImmConstant(), m_Intrinsic(), matchExpandedRem(), reassociateMinMaxWithConstantInOperand(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), simplifyAndInst(), simplifyOrLogic(), simplifyXorInst(), llvm::InstCombinerImpl::visitAnd(), visitMaskedMerge(), llvm::InstCombinerImpl::visitOr(), and llvm::InstCombinerImpl::visitXor().

◆ m_CombineOr()

template<typename LTy , typename RTy >

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

inline

Combine two pattern matchers matching L || R.

Definition at line 218 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), llvm::ConstantFoldBinaryInstruction(), dropRedundantMaskingOfLeftShiftInput(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), llvm::InstCombinerImpl::foldSelectShuffle(), FoldTwoEntryPHINode(), foldVecTruncToExtElt(), llvm::slpvectorizer::BoUpSLP::LookAheadHeuristics::getShallowScore(), getValueFromICmpCondition(), llvm::isCheckForZeroAndMulWithOverflow(), isKnownNonZeroFromAssume(), m_AnyMul(), m_c_MaxOrMin(), m_MaxOrMin(), m_SExtOrSelf(), m_TruncOrSelf(), m_ZExtOrSelf(), m_ZExtOrSExt(), m_ZExtOrSExtOrSelf(), markAliveBlocks(), matchFastFloatClamp(), matchSelectPattern(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), simplifySelectWithICmpCond(), tryToMoveFreeBeforeNullTest(), llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(), and unswitchBestCondition().

◆ m_Constant() [1/2]

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

inline

Match an arbitrary Constant and ignore it.

Definition at line 144 of file PatternMatch.h.

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

◆ m_ConstantExpr() [1/2]

constantexpr_match llvm::PatternMatch::m_ConstantExpr ( )

inline

Match a constant expression or a constant that contains a constant expression.

Definition at line 165 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 740 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 152 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 737 of file PatternMatch.h.

◆ m_ConstantInt() [1/3]

class_match<ConstantInt> llvm::PatternMatch::m_ConstantInt ( )

inline

Match an arbitrary ConstantInt and ignore it.

Match a ConstantInt with a specific value.

Definition at line 147 of file PatternMatch.h.

◆ 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 734 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 872 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 892 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 896 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 791 of file PatternMatch.h.

◆ m_Deferred() [4/4]

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

inline

Like m_Specific(), but works if the specific value to match is determined as part of the same match() expression.

For example: m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will bind X before the pattern match starts. m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against whichever value m_Value(X) populated.

Definition at line 790 of file PatternMatch.h.

◆ m_Exact()

template<typename T >

Exact_match<T> llvm::PatternMatch::m_Exact ( const T & SubPattern )

inline

Definition at line 1351 of file PatternMatch.h.

Referenced by isKnownNonZero(), isKnownToBeAPowerOfTwo(), simplifyMulInst(), simplifyShlInst(), llvm::InstCombinerImpl::visitShl(), and llvm::InstCombinerImpl::visitUDiv().

◆ 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

Matches ExtractElementInst.

Definition at line 1492 of file PatternMatch.h.

Referenced by canonicalizeBitCastExtElt(), foldInsEltIntoIdentityShuffle(), llvm::slpvectorizer::BoUpSLP::LookAheadHeuristics::getShallowScore(), isOperandOfVmullHighP64(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), llvm::simplifyInsertElementInst(), llvm::InstCombinerImpl::visitInsertElementInst(), and llvm::InstCombinerImpl::visitTrunc().

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

◆ m_FAbs()

template<typename Opnd0 >

m_Intrinsic_Ty<Opnd0>::Ty llvm::PatternMatch::m_FAbs ( const Opnd0 & Op0 )

inline

Definition at line 2171 of file PatternMatch.h.

Referenced by foldFabsWithFcmpZero(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitFDiv().

◆ m_FAdd()

template<typename LHS , typename RHS >

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

inline

Definition at line 985 of file PatternMatch.h.

Referenced by llvm::CannotBeNegativeZero(), foldFNegIntoConstant(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), and llvm::InstCombinerImpl::visitFMul().

◆ m_FCanonicalize()

template<typename Opnd0 >

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

inline

Definition at line 2176 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

Definition at line 1400 of file PatternMatch.h.

Referenced by reassociateFCmps(), simplifySelectWithFCmp(), and llvm::InstCombinerImpl::visitBranchInst().

◆ m_FDiv()

template<typename LHS , typename RHS >

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

inline

Definition at line 1069 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), foldFDivConstantDividend(), foldFNegIntoConstant(), hoistFNegAboveFMulFDiv(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFDiv(), llvm::InstCombinerImpl::visitFMul(), and llvm::InstCombinerImpl::visitFSub().

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

◆ m_Finite() [2/2]

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

inline

Definition at line 645 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 652 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 655 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 2187 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 2181 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

Definition at line 1051 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), foldFDivConstantDividend(), foldFNegIntoConstant(), hoistFNegAboveFMulFDiv(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), m_AnyMul(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFMul(), and llvm::InstCombinerImpl::visitFSub().

◆ m_FNeg()

template<typename OpTy >

FNeg_match<OpTy> llvm::PatternMatch::m_FNeg ( const OpTy & X )

inline

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

Definition at line 1033 of file PatternMatch.h.

References X.

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

Definition at line 1687 of file PatternMatch.h.

Referenced by canSafelyConvertTo16Bit(), llvm::InstCombinerImpl::foldICmpBitCast(), narrowInsElt(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitFPTrunc(), and llvm::InstCombinerImpl::visitFSub().

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

Referenced by isKnownExactCastIntToFP(), and tryToFPToSat().

◆ m_FPToUI()

template<typename OpTy >

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

inline

Definition at line 1672 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

Definition at line 1682 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpBitCast(), and llvm::InstCombinerImpl::visitFSub().

◆ m_Freeze()

template<typename OpTy >

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

inline

Matches FreezeInst.

Definition at line 1477 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 1087 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

Definition at line 2194 of file PatternMatch.h.

Referenced by collectBitParts(), foldCtpop(), llvm::recognizeBSwapOrBitReverseIdiom(), and simplifySelectWithICmpCond().

◆ 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

Definition at line 2200 of file PatternMatch.h.

Referenced by collectBitParts(), foldCtpop(), llvm::recognizeBSwapOrBitReverseIdiom(), and simplifySelectWithICmpCond().

◆ m_FSub()

template<typename LHS , typename RHS >

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

inline

Definition at line 997 of file PatternMatch.h.

Referenced by factorizeLerp(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), m_FNegNSZ(), simplifyFAddInst(), simplifyFSubInst(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFMul(), llvm::InstCombinerImpl::visitFNeg(), and llvm::InstCombinerImpl::visitFSub().

◆ 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

Definition at line 1394 of file PatternMatch.h.

◆ 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 1324 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<constantexpr_match> > llvm::PatternMatch::m_ImmConstant ( )

inline

Match an arbitrary immediate Constant and ignore it.

Definition at line 751 of file PatternMatch.h.

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

◆ m_ImmConstant() [2/2]

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

inline

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

Definition at line 758 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 626 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

Matches InsertElementInst.

Definition at line 1484 of file PatternMatch.h.

Referenced by canonicalizeInsertSplat(), cheapToScalarize(), foldIdentityExtractShuffle(), foldInsEltIntoSplat(), foldShuffleWithInsert(), llvm::getSplatValue(), llvm::RISCVTargetLowering::shouldSinkOperands(), llvm::ARMTargetLowering::shouldSinkOperands(), simplifyShuffleVectorInst(), llvm::InstCombinerImpl::visitBitCast(), and llvm::InstCombinerImpl::visitPtrToInt().

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

◆ m_Instruction()

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

inline

Match an instruction, capturing it if we match.

Definition at line 716 of file PatternMatch.h.

References I.

◆ 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 2097 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 2118 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 2123 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 2130 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 2137 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 2144 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 2153 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 1605 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 1331 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

Matches LoadInst.

Definition at line 1563 of file PatternMatch.h.

Referenced by cheapToScalarize(), isMinMaxWithLoads(), and removeBitcastsFromLoadStoreOnMinMax().

◆ m_LogicalAnd() [1/2]

auto llvm::PatternMatch::m_LogicalAnd ( )

inline

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

Definition at line 2543 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

Matches L && R either in the form of L & R or L ? R : false.

Note that the latter form is poison-blocking.

Definition at line 2537 of file PatternMatch.h.

Referenced by llvm::ScalarEvolution::applyLoopGuards(), collectHomogenousInstGraphLoopInvariants(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), llvm::SelectionDAGBuilder::FindMergedConditions(), llvm::TargetTransformInfoImplCRTPBase< AMDGPUTTIImpl >::getInstructionCost(), getValueFromConditionImpl(), isImpliedCondAndOr(), llvm::isImpliedCondition(), isKnownNonNullFromDominatingCondition(), m_LogicalAnd(), llvm::InstCombiner::shouldAvoidAbsorbingNotIntoSelect(), llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(), unswitchBestCondition(), unswitchNontrivialInvariants(), unswitchTrivialBranch(), llvm::InstCombinerImpl::visitAnd(), and llvm::InstCombinerImpl::visitCallInst().

◆ m_LogicalOr() [1/2]

auto llvm::PatternMatch::m_LogicalOr ( )

inline

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

Definition at line 2561 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

Matches L || R either in the form of L | R or L ? true : R.

Note that the latter form is poison-blocking.

Definition at line 2555 of file PatternMatch.h.

Referenced by llvm::ScalarEvolution::applyLoopGuards(), collectHomogenousInstGraphLoopInvariants(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), llvm::SelectionDAGBuilder::FindMergedConditions(), llvm::TargetTransformInfoImplCRTPBase< AMDGPUTTIImpl >::getInstructionCost(), getValueFromConditionImpl(), isImpliedCondAndOr(), llvm::isImpliedCondition(), m_LogicalOr(), llvm::InstCombiner::shouldAvoidAbsorbingNotIntoSelect(), llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(), unswitchBestCondition(), unswitchNontrivialInvariants(), unswitchTrivialBranch(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitOr().

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

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

◆ m_LowBitMask() [1/2]

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

Referenced by llvm::InstCombinerImpl::foldICmpBinOp(), and foldICmpWithLowBitMaskedVal().

◆ m_LowBitMask() [2/2]

api_pred_ty<is_lowbit_mask> llvm::PatternMatch::m_LowBitMask ( const APInt *& V )

inline

Definition at line 588 of file PatternMatch.h.

◆ m_LShr()

template<typename LHS , typename RHS >

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

inline

Definition at line 1117 of file PatternMatch.h.

◆ m_MaskedGather()

template<typename Opnd0 , typename Opnd1 , typename Opnd2 , typename Opnd3 >

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

inline

Matches MaskedGather Intrinsic.

Definition at line 2112 of file PatternMatch.h.

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

Definition at line 1882 of file PatternMatch.h.

References m_CombineOr(), m_SMax(), m_SMin(), m_UMax(), and m_UMin().

Referenced by llvm::InstCombinerImpl::foldICmpUsingKnownBits(), llvm::InstCombinerImpl::foldICmpWithDominatingICmp(), foldMinMaxSharedOp(), llvm::InstCombinerImpl::foldSelectOpOp(), llvm::InstCombiner::isFreeToInvert(), isKnownToBeAPowerOfTwo(), and reassociateMinMaxWithConstantInOperand().

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

◆ m_MaxSignedValue() [2/2]

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

inline

Definition at line 466 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

Definition at line 1045 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpBinOp(), isKnownNonZero(), isNonEqualMul(), m_AnyMul(), MatchMul(), processUse(), simplifyICmpWithBinOpOnLHS(), tryToRecognizePopCount(), tryToRecognizeTableBasedCttz(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitICmpInst(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitOr(), and llvm::InstCombinerImpl::visitShl().

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

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

Definition at line 2273 of file PatternMatch.h.

References m_Sub(), and m_ZeroInt().

◆ 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 552 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 555 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 475 of file PatternMatch.h.

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

◆ m_Negative() [2/2]

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

inline

Definition at line 478 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 682 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 633 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 617 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 485 of file PatternMatch.h.

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

◆ m_NonNegative() [2/2]

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

inline

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

◆ m_NonPositive() [2/2]

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

inline

Definition at line 510 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 691 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

Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.

Definition at line 2289 of file PatternMatch.h.

References m_AllOnes(), and m_c_Xor().

◆ m_NotForbidUndef()

template<typename ValTy >

NotForbidUndef_match<ValTy> llvm::PatternMatch::m_NotForbidUndef ( const ValTy & V )

inline

Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'.

For vectors, the constant value must be composed of only -1 scalar elements.

Definition at line 2314 of file PatternMatch.h.

Referenced by simplifyOrLogic(), and simplifyXorInst().

◆ 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

Definition at line 1156 of file PatternMatch.h.

References llvm::MCID::Add, LHS, llvm::OverflowingBinaryOperator::NoSignedWrap, and RHS.

Referenced by decompose(), foldNoWrapAdd(), isTruePredicate(), trySimplifyICmpWithAdds(), and llvm::InstCombinerImpl::visitCallInst().

◆ 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

Definition at line 1172 of file PatternMatch.h.

References LHS, Mul, llvm::OverflowingBinaryOperator::NoSignedWrap, and RHS.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), and simplifyICmpWithConstant().

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

Definition at line 1180 of file PatternMatch.h.

References LHS, llvm::OverflowingBinaryOperator::NoSignedWrap, and RHS.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), simplifyAShrInst(), simplifyRem(), and llvm::InstCombinerImpl::visitAShr().

◆ 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

Definition at line 1164 of file PatternMatch.h.

References LHS, llvm::OverflowingBinaryOperator::NoSignedWrap, and RHS.

Referenced by llvm::computeOverflowForSignedSub(), foldSubOfMinMax(), getKnownSign(), llvm::isKnownNegation(), m_NSWNeg(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitLShr(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitSDiv(), and llvm::InstCombinerImpl::visitSRem().

◆ 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

Definition at line 1189 of file PatternMatch.h.

References llvm::MCID::Add, LHS, llvm::OverflowingBinaryOperator::NoUnsignedWrap, and RHS.

Referenced by llvm::InstCombinerImpl::commonShiftTransforms(), decompose(), foldNoWrapAdd(), isTruePredicate(), and llvm::InstCombinerImpl::visitCallInst().

◆ 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

Definition at line 1205 of file PatternMatch.h.

References LHS, Mul, llvm::OverflowingBinaryOperator::NoUnsignedWrap, and RHS.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), simplifyICmpWithConstant(), llvm::InstCombinerImpl::visitLShr(), and llvm::InstCombinerImpl::visitUDiv().

◆ 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

Definition at line 1213 of file PatternMatch.h.

References LHS, llvm::OverflowingBinaryOperator::NoUnsignedWrap, and RHS.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), decompose(), simplifyAndInst(), simplifyLShrInst(), and simplifyRem().

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

References LHS, llvm::OverflowingBinaryOperator::NoUnsignedWrap, and RHS.

Referenced by llvm::computeOverflowForUnsignedSub(), and 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 517 of file PatternMatch.h.

◆ m_OneUse()

template<typename T >

OneUse_match<T> llvm::PatternMatch::m_OneUse ( const T & SubPattern )

inline

Definition at line 67 of file PatternMatch.h.

◆ 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 1897 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 1912 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 llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), and 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 673 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

Match an integer or vector power-of-2.

For vectors, this includes constants with undefined elements.

Definition at line 544 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::commonShiftTransforms(), detectShiftUntilBitTestIdiom(), llvm::InstCombinerImpl::foldICmpSRemConstant(), llvm::InstCombinerImpl::foldICmpUsingKnownBits(), foldSelectICmpAnd(), foldSelectICmpAndOr(), foldSignedTruncationCheck(), isKnownToBeAPowerOfTwo(), isPowerOfTwoRecurrence(), simplifyICmpWithBinOp(), takeLog2(), llvm::InstCombinerImpl::visitAnd(), and llvm::InstCombinerImpl::visitSDiv().

◆ m_Power2() [2/2]

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

inline

Definition at line 545 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 564 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 567 of file PatternMatch.h.

◆ m_PtrToInt()

template<typename OpTy >

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

inline

Matches PtrToInt.

Definition at line 1599 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), findAffectedValues(), llvm::InstCombinerImpl::foldICmpOrConstant(), isKnownNonZeroFromAssume(), llvm::PatternMatch::VScaleVal_match::match(), simplifyAndOrOfICmpsWithZero(), simplifyGEPInst(), simplifySubInst(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), and llvm::InstCombinerImpl::visitSub().

◆ m_SDiv()

template<typename LHS , typename RHS >

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

inline

Definition at line 1063 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::FoldShiftByConstant(), MatchDiv(), simplifyDivRem(), simplifyGEPInst(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitGetElementPtrInst(), and llvm::InstCombinerImpl::visitSDiv().

◆ 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

Matches SelectInst.

Definition at line 1462 of file PatternMatch.h.

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

Matches SExt.

Definition at line 1623 of file PatternMatch.h.

◆ m_SExtOrSelf()

template<typename OpTy >

match_combine_or<CastClass_match<OpTy, Instruction::SExt>, OpTy> llvm::PatternMatch::m_SExtOrSelf ( const OpTy & Op )

inline

Definition at line 1641 of file PatternMatch.h.

References m_CombineOr(), and m_SExt().

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), and llvm::InstCombinerImpl::visitAnd().

◆ m_Shift()

template<typename LHS , typename RHS >

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

inline

Matches shift operations.

Definition at line 1296 of file PatternMatch.h.

Referenced by detectShiftUntilZeroIdiom(), dropRedundantMaskingOfLeftShiftInput(), foldShiftOfShiftedLogic(), and llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts().

◆ m_Shl()

template<typename LHS , typename RHS >

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

inline

Definition at line 1111 of file PatternMatch.h.

◆ 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

Matches logical shift operations.

Definition at line 1303 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), dropRedundantMaskingOfLeftShiftInput(), llvm::InstCombinerImpl::foldICmpTruncConstant(), llvm::InstCombinerImpl::foldSignBitTest(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), isKnownNonZero(), optimizeBranch(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), simplifyShlInst(), llvm::InstCombinerImpl::visitShl(), and llvm::InstCombinerImpl::visitTrunc().

◆ 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

Matches ShuffleVectorInst independently of mask value.

Definition at line 1551 of file PatternMatch.h.

References v1, and v2.

Referenced by areExtractShuffleVectors(), llvm::InstCombinerImpl::commonCastTransforms(), llvm::InstCombinerImpl::foldICmpBitCast(), foldIdentityExtractShuffle(), foldShuffledIntrinsicOperands(), llvm::InstCombinerImpl::foldVectorBinop(), foldVectorCmp(), llvm::getSplatValue(), narrowVectorSelect(), llvm::RISCVTargetLowering::shouldSinkOperands(), llvm::ARMTargetLowering::shouldSinkOperands(), and llvm::InstCombinerImpl::visitCallInst().

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

Referenced by isKnownToBeAPowerOfTwo(), isPowerOfTwoRecurrence(), 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 2404 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

Definition at line 1667 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpBitCast(), and simplifyUnaryIntrinsic().

◆ 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

Definition at line 1853 of file PatternMatch.h.

Referenced by foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldSelectOpOp(), llvm::RecurrenceDescriptor::isMinMaxPattern(), m_MaxOrMin(), matchClamp(), simplifyICmpWithMinMax(), and tryToFPToSat().

◆ 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

Definition at line 1859 of file PatternMatch.h.

Referenced by foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldICmpWithZero(), llvm::InstCombinerImpl::foldSelectOpOp(), llvm::RecurrenceDescriptor::isMinMaxPattern(), m_MaxOrMin(), matchClamp(), simplifyICmpWithMinMax(), and tryToFPToSat().

◆ m_Specific()

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

inline

Match if we have a specific specified value.

Definition at line 772 of file PatternMatch.h.

◆ m_SpecificBB()

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

inline

Match a specific basic block value.

Definition at line 887 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 815 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

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

Definition at line 854 of file PatternMatch.h.

References move.

◆ m_SpecificInt() [2/2]

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

inline

Definition at line 858 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

Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.

For vectors, this includes constants with undefined elements.

Definition at line 598 of file PatternMatch.h.

References P.

Referenced by canNarrowShiftAmt(), llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), foldSelectICmpAndAnd(), foldSelectICmpLshrAshr(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), foldShiftOfShiftedLogic(), llvm::InstCombinerImpl::foldSignBitTest(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), matchFunnelShift(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::InstCombinerImpl::visitAnd(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_SpecificIntAllowUndef() [1/2]

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

inline

Definition at line 862 of file PatternMatch.h.

References move.

Referenced by llvm::InstCombinerImpl::foldAddWithConstant(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::FoldShiftByConstant(), m_SpecificIntAllowUndef(), matchFunnelShift(), llvm::InstCombinerImpl::visitAShr(), llvm::InstCombinerImpl::visitMul(), and llvm::InstCombinerImpl::visitSExt().

◆ m_SpecificIntAllowUndef() [2/2]

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

inline

Definition at line 866 of file PatternMatch.h.

References m_SpecificIntAllowUndef().

◆ m_Sqrt()

template<typename Opnd0 >

m_Intrinsic_Ty<Opnd0>::Ty llvm::PatternMatch::m_Sqrt ( const Opnd0 & Op0 )

inline

Definition at line 2205 of file PatternMatch.h.

Referenced by simplifyFMAFMul(), and llvm::InstCombinerImpl::visitFMul().

◆ m_SRem()

template<typename LHS , typename RHS >

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

inline

Definition at line 1081 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::commonShiftTransforms(), llvm::computeOverflowForSignedSub(), MatchRem(), simplifyDiv(), simplifyRem(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitLShr(), and llvm::InstCombinerImpl::visitSRem().

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

◆ m_StrictlyPositive() [2/2]

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

inline

Definition at line 498 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

Definition at line 991 of file PatternMatch.h.

◆ 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

Definition at line 1617 of file PatternMatch.h.

References m_CombineOr(), and m_Trunc().

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), llvm::InstCombinerImpl::foldSignBitTest(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), and llvm::InstCombinerImpl::visitXor().

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

Definition at line 1057 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), isKnownToBeAPowerOfTwo(), MatchDiv(), simplifyDiv(), simplifyDivRem(), and simplifyICmpWithBinOpOnLHS().

◆ m_UIToFP()

template<typename OpTy >

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

inline

Definition at line 1662 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpBitCast(), simplifyICmpWithConstant(), and simplifyUnaryIntrinsic().

◆ 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

Definition at line 1865 of file PatternMatch.h.

Referenced by foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldSelectOpOp(), llvm::RecurrenceDescriptor::isMinMaxPattern(), m_MaxOrMin(), matchClamp(), and simplifyICmpWithMinMax().

◆ 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

Definition at line 1871 of file PatternMatch.h.

Referenced by foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldSelectOpOp(), foldSubOfMinMax(), foldToUnsignedSaturatedAdd(), llvm::RecurrenceDescriptor::isMinMaxPattern(), m_MaxOrMin(), matchClamp(), processUse(), and simplifyICmpWithMinMax().

◆ m_UnconditionalBr()

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

inline

Definition at line 1710 of file PatternMatch.h.

Referenced by tryToMoveFreeBeforeNullTest().

◆ m_Undef()

auto llvm::PatternMatch::m_Undef ( )

inline

Match an arbitrary undef constant.

This matches poison as well. If this is an aggregate and contains a non-aggregate element that is neither undef nor poison, the aggregate is not matched.

Definition at line 136 of file PatternMatch.h.

◆ 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 182 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 942 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 718 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 1928 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 1943 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

Definition at line 1075 of file PatternMatch.h.

Referenced by canScalarizeAccess(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::computeOverflowForUnsignedSub(), llvm::InstCombinerImpl::foldICmpWithZero(), getValueFromICmpCondition(), MatchRem(), simplifyDiv(), simplifyICmpWithBinOpOnLHS(), and simplifyRem().

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

◆ m_Value() [2/3]

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

inline

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

◆ m_VScale()

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

inline

Definition at line 2489 of file PatternMatch.h.

References DL.

Referenced by llvm::VPIntrinsic::canIgnoreVectorLengthParam(), llvm::SelectionDAGBuilder::getValueImpl(), llvm::InstCombinerImpl::visitSExt(), llvm::InstCombinerImpl::visitTrunc(), and llvm::InstCombinerImpl::visitZExt().

◆ m_WithOverflowInst() [1/2]

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

inline

Definition at line 726 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 722 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 537 of file PatternMatch.h.

◆ m_ZeroInt()

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 524 of file PatternMatch.h.

Referenced by foldGuardedFunnelShift(), llvm::InstCombinerImpl::foldICmpEquality(), foldICmpOfUAddOv(), foldInsEltIntoSplat(), foldIsPowerOf2(), foldIsPowerOf2OrZero(), foldSubOfMinMax(), getAlternateBinop(), llvm::getSplatValue(), llvm::GCNTTIImpl::instCombineIntrinsic(), llvm::isKnownNegation(), m_Neg(), m_NSWNeg(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), matchSelectPattern(), matchUAddWithOverflowConstantEdgeCases(), simplifyAndOrOfICmpsWithCtpop(), simplifySelectInst(), simplifyX86addcarry(), tryToRecognizeTableBasedCttz(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitOr(), and llvm::InstCombinerImpl::visitSub().

◆ m_ZExt()

template<typename OpTy >

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

inline

Matches ZExt.

Definition at line 1629 of file PatternMatch.h.

◆ m_ZExtOrSelf()

template<typename OpTy >

match_combine_or<CastClass_match<OpTy, Instruction::ZExt>, OpTy> llvm::PatternMatch::m_ZExtOrSelf ( const OpTy & Op )

inline

Definition at line 1635 of file PatternMatch.h.

References m_CombineOr(), and m_ZExt().

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), dropRedundantMaskingOfLeftShiftInput(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), and tryToRecognizeTableBasedCttz().

◆ m_ZExtOrSExt()

template<typename OpTy >

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

inline

Definition at line 1648 of file PatternMatch.h.

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

Referenced by areExtractExts(), canAlwaysEvaluateInType(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::InstCombinerImpl::foldICmpWithZextOrSext(), llvm::GCNTTIImpl::instCombineIntrinsic(), m_ZExtOrSExtOrSelf(), and llvm::AArch64TargetLowering::shouldSinkOperands().

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

Definition at line 53 of file PatternMatch.h.

References llvm::BitmaskEnumDetail::Mask(), match(), and P.

Referenced by llvm::PatternMatch::MaxMin_match< CmpInst_t, LHS_t, RHS_t, Pred_t, Commutable >::match().

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

Classes

Typedefs

Functions

Typedef Documentation

◆ cst_pred_ty

◆ cstfp_pred_ty

Function Documentation

◆ m_Add()

◆ m_AllOnes()

◆ m_And()

◆ m_AnyIntegralConstant()

◆ m_AnyZeroFP()

◆ m_APFloat()

◆ m_APFloatAllowUndef()

◆ m_APFloatForbidUndef()

◆ m_APInt()

◆ m_APIntAllowUndef()

◆ m_APIntForbidUndef()

◆ m_Argument()

◆ m_AShr()

◆ m_BasicBlock() [1/3]

◆ m_BasicBlock() [2/3]

◆ m_BasicBlock() [3/3]

◆ m_BinOp() [1/4]

◆ m_BinOp() [2/4]

◆ m_BinOp() [3/4]

◆ m_BinOp() [4/4]

◆ m_BitCast()

◆ m_BitReverse()

◆ m_BitwiseLogic()

◆ m_Br() [1/2]

◆ m_Br() [2/2]

◆ m_BSwap()

◆ m_c_Add()

◆ m_c_And()

◆ m_c_BinOp() [1/2]

◆ m_c_BinOp() [2/2]

◆ m_c_FAdd()

◆ m_c_FMul()

◆ m_c_ICmp()

◆ m_c_LogicalAnd()

◆ m_c_LogicalOr()

◆ m_c_MaxOrMin()

◆ m_c_Mul()

◆ m_c_Or()

◆ m_c_SMax()

◆ m_c_SMin()

◆ m_c_UMax()

◆ m_c_UMin()

◆ m_c_Xor()

◆ m_Cmp() [1/2]

◆ m_Cmp() [2/2]

◆ m_CombineAnd()

◆ m_CombineOr()

◆ m_Constant() [1/2]

◆ m_Constant() [2/2]

◆ m_ConstantExpr() [1/2]

◆ m_ConstantExpr() [2/2]

◆ m_ConstantFP() [1/2]

◆ m_ConstantFP() [2/2]

◆ m_ConstantInt() [1/3]

◆ m_ConstantInt() [2/3]

◆ m_ConstantInt() [3/3]

◆ m_Deferred() [1/4]

◆ m_Deferred() [2/4]

◆ m_Deferred() [3/4]

◆ m_Deferred() [4/4]

◆ m_Exact()

◆ m_ExtractElt()

◆ m_ExtractValue() [1/2]

◆ m_ExtractValue() [2/2]

◆ m_FAbs()

◆ m_FAdd()

◆ m_FCanonicalize()

◆ m_FCmp()

◆ m_FDiv()

◆ m_Finite() [1/2]

◆ m_Finite() [2/2]

◆ m_FiniteNonZero() [1/2]

◆ m_FiniteNonZero() [2/2]