Classes
struct	AllowFmf_match
struct	AnyBinaryOp_match
struct	AnyOps_match
	Matches instructions with Opcode and any number of operands. More...
struct	AnyUnaryOp_match
struct	ap_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	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	Argument_match
struct	BinaryOp_match
struct	bind_const_intval_ty
struct	bind_immconstant_ty
struct	BinOpPred_match
struct	br_match
struct	brc_match
struct	CastInst_match
struct	CastOperator_match
struct	CmpClass_match
struct	CommutativeBinaryIntrinsic_match
struct	constantint_match
struct	ContainsMatchingVectorElement_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	custom_checkfn
struct	DisjointOr_match
struct	ElementWiseBitCast_match
struct	Exact_match
struct	ExtractValue_match
struct	FMaxMin_match
struct	FNeg_match
struct	icmp_pred_with_threshold
struct	ICmpLike_match
struct	immconstant_ty
struct	InsertValue_match
	Matcher for a single index InsertValue instruction. More...
struct	IntrinsicID_match
	Intrinsic matchers. More...
struct	IntrinsicIDs_match
	Match intrinsic calls with any of the given IDs. More...
struct	IntrinsicMatchImpl
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_lowbit_mask_or_zero
struct	is_maxsignedvalue
struct	is_nan
struct	is_neg_zero_fp
struct	is_negated_power2
struct	is_negated_power2_or_zero
struct	is_negative
struct	is_non_zero_fp
struct	is_non_zero_int
struct	is_non_zero_not_denormal_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_shifted_mask
struct	is_sign_mask
struct	is_signed_inf
struct	is_strictlypositive
struct	is_zero
struct	is_zero_int
struct	LoadSimple_match
	Matches a simple (non-volatile, non-atomic) LoadInst. More...
struct	LogicalOp_match
struct	m_Mask
struct	m_SpecificMask
struct	m_SplatMask
struct	m_SplatOrPoisonMask
struct	m_ZeroMask
struct	match_immconstant_ty
struct	NNegZExt_match
struct	NoWrapTrunc_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	PtrAdd_match
struct	PtrToIntSameSize_match
struct	SelectLike_match
struct	ShiftLike_match
struct	Shuffle_match
	Matches shuffle. More...
struct	Signum_match
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	specific_intval64
struct	SpecificBinaryOp_match
struct	SpecificCmpClass_match
struct	SpecificType_match
struct	specificval_ty
	Matcher for specified Value*. More...
struct	Splat_match
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	undef_match
struct	XorLike_match

Typedefs
template<typename Predicate, bool AllowPoison = true>
using	cst_pred_ty = cstval_pred_ty<Predicate, ConstantInt, AllowPoison>
	specialization of cstval_pred_ty for ConstantInt
template<typename Predicate>
using	cstfp_pred_ty
	specialization of cstval_pred_ty for ConstantFP

Functions
template<typename Val, typename Pattern>
bool	match (Val *V, const Pattern &P)
template<typename Val = const Value, typename Pattern>
auto	match_fn (const Pattern &P)
	A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.
template<typename Pattern>
bool	match (ArrayRef< int > Mask, const Pattern &P)
template<typename T>
OneUse_match< T >	m_OneUse (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::AllowReassoc >	m_AllowReassoc (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::AllowReciprocal >	m_AllowReciprocal (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::AllowContract >	m_AllowContract (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::ApproxFunc >	m_ApproxFunc (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::NoNaNs >	m_NoNaNs (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::NoInfs >	m_NoInfs (const T &SubPattern)
template<typename T>
AllowFmf_match< T, FastMathFlags::NoSignedZeros >	m_NoSignedZeros (const T &SubPattern)
auto	m_Value ()
	Match an arbitrary value and ignore it.
auto	m_UnOp ()
	Match an arbitrary unary operation and ignore it.
auto	m_BinOp ()
	Match an arbitrary binary operation and ignore it.
auto	m_Cmp ()
	Matches any compare instruction and ignore it.
auto	m_AnyIntrinsic ()
	Matches any intrinsic call and ignore it.
auto	m_Undef ()
	Match an arbitrary undef constant.
auto	m_UndefValue ()
	Match an arbitrary UndefValue constant.
auto	m_Poison ()
	Match an arbitrary poison constant.
auto	m_Constant ()
	Match an arbitrary Constant and ignore it.
auto	m_ConstantInt ()
	Match an arbitrary ConstantInt and ignore it.
auto	m_ConstantFP ()
	Match an arbitrary ConstantFP and ignore it.
template<typename SPTy>
ContainsMatchingVectorElement_match< SPTy >	m_ContainsMatchingVectorElement (const SPTy &SubPattern)
	Match a vector constant where at least one of its elements matches the subpattern.
auto	m_ConstantExpr ()
	Match a constant expression or a constant that contains a constant expression.
template<typename T>
Splat_match< T >	m_Splat (const T &SubPattern)
	Match a vector splat.
auto	m_BasicBlock ()
	Match an arbitrary basic block value and ignore it.
ap_match< APInt >	m_APInt (const APInt *&Res)
	Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
ap_match< APInt >	m_APIntAllowPoison (const APInt *&Res)
	Match APInt while allowing poison in splat vector constants.
ap_match< APInt >	m_APIntForbidPoison (const APInt *&Res)
	Match APInt while forbidding poison in splat vector constants.
ap_match< APFloat >	m_APFloat (const APFloat *&Res)
	Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat.
ap_match< APFloat >	m_APFloatAllowPoison (const APFloat *&Res)
	Match APFloat while allowing poison in splat vector constants.
ap_match< APFloat >	m_APFloatForbidPoison (const APFloat *&Res)
	Match APFloat while forbidding poison in splat vector constants.
template<int64_t Val>
constantint_match< Val >	m_ConstantInt ()
	Match a ConstantInt with a specific value.
cst_pred_ty< custom_checkfn< APInt > >	m_CheckedInt (function_ref< bool(const APInt &)> CheckFn)
	Match an integer or vector where CheckFn(ele) for each element is true.
cst_pred_ty< custom_checkfn< APInt > >	m_CheckedInt (const Constant *&V, function_ref< bool(const APInt &)> CheckFn)
cstfp_pred_ty< custom_checkfn< APFloat > >	m_CheckedFp (function_ref< bool(const APFloat &)> CheckFn)
	Match a float or vector where CheckFn(ele) for each element is true.
cstfp_pred_ty< custom_checkfn< APFloat > >	m_CheckedFp (const Constant *&V, function_ref< bool(const APFloat &)> CheckFn)
cst_pred_ty< is_any_apint >	m_AnyIntegralConstant ()
	Match an integer or vector with any integral constant.
cst_pred_ty< is_shifted_mask >	m_ShiftedMask ()
cst_pred_ty< is_all_ones >	m_AllOnes ()
	Match an integer or vector with all bits set.
cst_pred_ty< is_all_ones, false >	m_AllOnesForbidPoison ()
auto	m_AllOnesOrPoison ()
cst_pred_ty< is_maxsignedvalue >	m_MaxSignedValue ()
	Match an integer or vector with values having all bits except for the high bit set (0x7f...).
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.
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.
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.
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.
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.
cst_pred_ty< is_zero_int >	m_ZeroInt ()
	Match an integer 0 or a vector with all elements equal to 0.
cst_pred_ty< is_non_zero_int >	m_NonZeroInt ()
	Match a non-zero integer or a vector with all non-zero elements.
is_zero	m_Zero ()
	Match any null constant or a vector with all elements equal to 0.
auto	m_ZeroOrPoison ()
cst_pred_ty< is_power2 >	m_Power2 ()
	Match an integer or vector power-of-2.
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.
api_pred_ty< is_negated_power2 >	m_NegatedPower2 (const APInt *&V)
cst_pred_ty< is_negated_power2_or_zero >	m_NegatedPower2OrZero ()
	Match a integer or vector negated power-of-2.
api_pred_ty< is_negated_power2_or_zero >	m_NegatedPower2OrZero (const APInt *&V)
cst_pred_ty< is_power2_or_zero >	m_Power2OrZero ()
	Match an integer or vector of 0 or power-of-2 values.
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.
cst_pred_ty< is_lowbit_mask >	m_LowBitMask ()
	Match an integer or vector with only the low bit(s) set.
api_pred_ty< is_lowbit_mask >	m_LowBitMask (const APInt *&V)
cst_pred_ty< is_lowbit_mask_or_zero >	m_LowBitMaskOrZero ()
	Match an integer or vector with only the low bit(s) set.
api_pred_ty< is_lowbit_mask_or_zero >	m_LowBitMaskOrZero (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.
cst_pred_ty< icmp_pred_with_threshold, false >	m_SpecificInt_ICMP_ForbidPoison (ICmpInst::Predicate Predicate, const APInt &Threshold)
	Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.
cstfp_pred_ty< is_nan >	m_NaN ()
	Match an arbitrary NaN constant.
cstfp_pred_ty< is_nonnan >	m_NonNaN ()
	Match a non-NaN FP constant.
cstfp_pred_ty< is_inf >	m_Inf ()
	Match a positive or negative infinity FP constant.
cstfp_pred_ty< is_signed_inf< false > >	m_PosInf ()
	Match a positive infinity FP constant.
cstfp_pred_ty< is_signed_inf< true > >	m_NegInf ()
	Match a negative infinity FP constant.
cstfp_pred_ty< is_noninf >	m_NonInf ()
	Match a non-infinity FP constant, i.e.
cstfp_pred_ty< is_finite >	m_Finite ()
	Match a finite FP constant, i.e.
apf_pred_ty< is_finite >	m_Finite (const APFloat *&V)
cstfp_pred_ty< is_finitenonzero >	m_FiniteNonZero ()
	Match a finite non-zero FP constant.
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.
cstfp_pred_ty< is_pos_zero_fp >	m_PosZeroFP ()
	Match a floating-point positive zero.
cstfp_pred_ty< is_neg_zero_fp >	m_NegZeroFP ()
	Match a floating-point negative zero.
cstfp_pred_ty< is_non_zero_fp >	m_NonZeroFP ()
	Match a floating-point non-zero.
cstfp_pred_ty< is_non_zero_not_denormal_fp >	m_NonZeroNotDenormalFP ()
	Match a floating-point non-zero that is not a denormal.
match_bind< Value >	m_Value (Value *&V)
	Match a value, capturing it if we match.
match_bind< const Value >	m_Value (const Value *&V)
template<typename Pattern>
auto	m_Value (Value *&V, const Pattern &P)
	Match against the nested pattern, and capture the value if we match.
template<typename Pattern>
auto	m_Value (const Value *&V, const Pattern &P)
	Match against the nested pattern, and capture the value if we match.
match_bind< Instruction >	m_Instruction (Instruction *&I)
	Match an instruction, capturing it if we match.
match_bind< const Instruction >	m_Instruction (const Instruction *&I)
template<typename Pattern>
auto	m_Instruction (Instruction *&I, const Pattern &P)
	Match against the nested pattern, and capture the instruction if we match.
template<typename Pattern>
auto	m_Instruction (const Instruction *&I, const Pattern &P)
match_bind< UnaryOperator >	m_UnOp (UnaryOperator *&I)
	Match a unary operator, capturing it if we match.
match_bind< const UnaryOperator >	m_UnOp (const UnaryOperator *&I)
match_bind< BinaryOperator >	m_BinOp (BinaryOperator *&I)
	Match a binary operator, capturing it if we match.
match_bind< const BinaryOperator >	m_BinOp (const BinaryOperator *&I)
match_bind< IntrinsicInst >	m_AnyIntrinsic (IntrinsicInst *&I)
	Match any intrinsic call, capturing it if we match.
match_bind< const IntrinsicInst >	m_AnyIntrinsic (const IntrinsicInst *&I)
match_bind< WithOverflowInst >	m_WithOverflowInst (WithOverflowInst *&I)
	Match a with overflow intrinsic, capturing it if we match.
match_bind< const WithOverflowInst >	m_WithOverflowInst (const WithOverflowInst *&I)
match_bind< PHINode >	m_Phi (PHINode *&PN)
	Match a PHI node, capturing it if we match.
match_bind< UndefValue >	m_UndefValue (UndefValue *&U)
	Match an UndefValue, capturing the value if we match.
match_bind< Constant >	m_Constant (Constant *&C)
	Match a Constant, capturing the value if we match.
match_bind< ConstantInt >	m_ConstantInt (ConstantInt *&CI)
	Match a ConstantInt, capturing the value if we match.
match_bind< ConstantFP >	m_ConstantFP (ConstantFP *&C)
	Match a ConstantFP, capturing the value if we match.
match_bind< ConstantExpr >	m_ConstantExpr (ConstantExpr *&C)
	Match a ConstantExpr, capturing the value if we match.
match_bind< BasicBlock >	m_BasicBlock (BasicBlock *&V)
	Match a basic block value, capturing it if we match.
match_bind< const BasicBlock >	m_BasicBlock (const BasicBlock *&V)
match_immconstant_ty	m_ImmConstant ()
	Match an arbitrary immediate Constant and ignore it.
bind_immconstant_ty	m_ImmConstant (Constant *&C)
	Match an immediate Constant, capturing the value if we match.
specificval_ty	m_Specific (const Value *V)
	Match if we have a specific specified value.
match_deferred< 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.
match_deferred< 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.
specific_fpval	m_FPOne ()
	Match a float 1.0 or vector with all elements equal to 1.0.
specific_intval< false >	m_SpecificInt (const APInt &V)
	Match a specific integer value or vector with all elements equal to the value.
specific_intval64< false >	m_SpecificInt (uint64_t V)
specific_intval< true >	m_SpecificIntAllowPoison (const APInt &V)
specific_intval64< true >	m_SpecificIntAllowPoison (uint64_t V)
bind_const_intval_ty	m_ConstantInt (uint64_t &V)
	Match a ConstantInt and bind to its value.
specific_bbval	m_SpecificBB (BasicBlock *BB)
	Match a specific basic block value.
match_deferred< BasicBlock >	m_Deferred (BasicBlock *const &BB)
	A commutative-friendly version of m_Specific().
match_deferred< const BasicBlock >	m_Deferred (const BasicBlock *const &BB)
template<typename Pattern>
	SpecificType_match (const Type *, const Pattern &) -> SpecificType_match< Pattern >
template<typename Pattern>
auto	m_SpecificType (Type *RefTy, const Pattern &P)
	Match a value of a specific type.
auto	m_SpecificType (Type *RefTy)
auto	m_SpecificType (Type RefTy, Value &V)
	Match a value of a specific type, capturing it if we match.
auto	m_SpecificType (Type RefTy, const Value &V)
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'.
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'.
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>
ShiftLike_match< LHS, Instruction::Shl >	m_ShlOrSelf (const LHS &L, uint64_t &R)
	Matches shl L, ConstShAmt or L itself (R will be set to zero in this case).
template<typename LHS>
ShiftLike_match< LHS, Instruction::LShr >	m_LShrOrSelf (const LHS &L, uint64_t &R)
	Matches lshr L, ConstShAmt or L itself (R will be set to zero in this case).
template<typename LHS>
ShiftLike_match< LHS, Instruction::AShr >	m_AShrOrSelf (const LHS &L, uint64_t &R)
	Matches ashr L, ConstShAmt or L itself (R will be set to zero in this case).
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::Add, OverflowingBinaryOperator::NoSignedWrap, true >	m_c_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::Add, OverflowingBinaryOperator::NoUnsignedWrap, true >	m_c_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.
template<typename LHS, typename RHS>
DisjointOr_match< LHS, RHS >	m_DisjointOr (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
DisjointOr_match< LHS, RHS, true >	m_c_DisjointOr (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > >	m_AddLike (const LHS &L, const RHS &R)
	Match either "add" or "or disjoint".
template<typename LHS, typename RHS>
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > >	m_NSWAddLike (const LHS &L, const RHS &R)
	Match either "add nsw" or "or disjoint".
template<typename LHS, typename RHS>
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > >	m_NUWAddLike (const LHS &L, const RHS &R)
	Match either "add nuw" or "or disjoint".
template<typename LHS, typename RHS>
auto	m_c_XorLike (const LHS &L, const RHS &R)
	Match either (xor L, R), (xor R, L) or (sub nuw R, L) iff R.isMask() Only commutative matcher as the sub will need to swap the L and R.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_shift_op >	m_Shift (const LHS &L, const RHS &R)
	Matches shift operations.
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.
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.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_bitwiselogic_op >	m_BitwiseLogic (const LHS &L, const RHS &R)
	Matches bitwise logic operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_bitwiselogic_op, true >	m_c_BitwiseLogic (const LHS &L, const RHS &R)
	Matches bitwise logic operations in either order.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_idiv_op >	m_IDiv (const LHS &L, const RHS &R)
	Matches integer division operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_irem_op >	m_IRem (const LHS &L, const RHS &R)
	Matches integer remainder operations.
template<typename T>
Exact_match< T >	m_Exact (const T &SubPattern)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, CmpInst >	m_Cmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst >	m_ICmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, FCmpInst >	m_FCmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, CmpInst >	m_Cmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst >	m_ICmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, FCmpInst >	m_FCmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, CmpInst >	m_SpecificCmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, ICmpInst >	m_SpecificICmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, ICmpInst, true >	m_c_SpecificICmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, FCmpInst >	m_SpecificFCmp (CmpPredicate MatchPred, 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.
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.: m_SelectCst<-1, 0>(m_Value(V))
template<typename LHS, typename RHS>
ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true >	m_c_Select (const LHS &L, const RHS &R)
	Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
template<typename OpTy>
OneOps_match< OpTy, Instruction::Freeze >	m_Freeze (const OpTy &Op)
	Matches FreezeInst.
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.
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.
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.
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.
template<typename OpTy>
LoadSimple_match< OpTy >	m_LoadSimple (const OpTy &Op)
template<typename ValueOpTy, typename PointerOpTy>
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store >	m_Store (const ValueOpTy &ValueOp, const PointerOpTy &PointerOp)
	Matches StoreInst.
template<typename... OperandTypes>
auto	m_GEP (const OperandTypes &...Ops)
	Matches GetElementPtrInst.
template<typename PointerOpTy, typename OffsetOpTy>
PtrAdd_match< PointerOpTy, OffsetOpTy >	m_PtrAdd (const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
	Matches GEP with i8 source element type.
template<typename OpTy>
CastOperator_match< OpTy, Instruction::BitCast >	m_BitCast (const OpTy &Op)
	Matches BitCast.
template<typename OpTy>
ElementWiseBitCast_match< OpTy >	m_ElementWiseBitCast (const OpTy &Op)
template<typename OpTy>
CastOperator_match< OpTy, Instruction::PtrToInt >	m_PtrToInt (const OpTy &Op)
	Matches PtrToInt.
template<typename OpTy>
PtrToIntSameSize_match< OpTy >	m_PtrToIntSameSize (const DataLayout &DL, const OpTy &Op)
template<typename OpTy>
CastOperator_match< OpTy, Instruction::PtrToAddr >	m_PtrToAddr (const OpTy &Op)
	Matches PtrToAddr.
template<typename OpTy>
auto	m_PtrToIntOrAddr (const OpTy &Op)
	Matches PtrToInt or PtrToAddr.
template<typename OpTy>
CastOperator_match< OpTy, Instruction::IntToPtr >	m_IntToPtr (const OpTy &Op)
	Matches IntToPtr.
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, CastInst >, OpTy >	m_CastOrSelf (const OpTy &Op)
	Matches any cast or self. Used to ignore casts.
template<typename OpTy>
CastInst_match< OpTy, TruncInst >	m_Trunc (const OpTy &Op)
	Matches Trunc.
template<typename OpTy>
NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap >	m_NUWTrunc (const OpTy &Op)
	Matches trunc nuw.
template<typename OpTy>
NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap >	m_NSWTrunc (const OpTy &Op)
	Matches trunc nsw.
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy >	m_TruncOrSelf (const OpTy &Op)
template<typename OpTy>
CastInst_match< OpTy, SExtInst >	m_SExt (const OpTy &Op)
	Matches SExt.
template<typename OpTy>
CastInst_match< OpTy, ZExtInst >	m_ZExt (const OpTy &Op)
	Matches ZExt.
template<typename OpTy>
NNegZExt_match< OpTy >	m_NNegZExt (const OpTy &Op)
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy >	m_ZExtOrSelf (const OpTy &Op)
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, SExtInst >, OpTy >	m_SExtOrSelf (const OpTy &Op)
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, SExtInst >, NNegZExt_match< OpTy > >	m_SExtLike (const OpTy &Op)
	Match either "sext" or "zext nneg".
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >	m_ZExtOrSExt (const OpTy &Op)
template<typename OpTy>
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy >	m_ZExtOrSExtOrSelf (const OpTy &Op)
template<typename OpTy>
auto	m_ZExtOrTruncOrSelf (const OpTy &Op)
template<typename LHS, typename RHS>
ICmpLike_match< LHS, RHS >	m_ICmpLike (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename CondTy, typename LTy, typename RTy>
SelectLike_match< CondTy, LTy, RTy >	m_SelectLike (const CondTy &C, const LTy &TrueC, const RTy &FalseC)
	Matches a value that behaves like a boolean-controlled select, i.e.
template<typename OpTy>
CastInst_match< OpTy, UIToFPInst >	m_UIToFP (const OpTy &Op)
template<typename OpTy>
CastInst_match< OpTy, SIToFPInst >	m_SIToFP (const OpTy &Op)
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, UIToFPInst >, CastInst_match< OpTy, SIToFPInst > >	m_IToFP (const OpTy &Op)
template<typename OpTy>
CastInst_match< OpTy, FPToUIInst >	m_FPToUI (const OpTy &Op)
template<typename OpTy>
CastInst_match< OpTy, FPToSIInst >	m_FPToSI (const OpTy &Op)
template<typename OpTy>
match_combine_or< CastInst_match< OpTy, FPToUIInst >, CastInst_match< OpTy, FPToSIInst > >	m_FPToI (const OpTy &Op)
template<typename OpTy>
CastInst_match< OpTy, FPTruncInst >	m_FPTrunc (const OpTy &Op)
template<typename OpTy>
CastInst_match< OpTy, FPExtInst >	m_FPExt (const OpTy &Op)
br_match	m_UnconditionalBr (BasicBlock *&Succ)
template<typename Cond_t>
brc_match< Cond_t, match_bind< BasicBlock >, match_bind< 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>
FMaxMin_match< LHS, RHS, ofmax_pred_ty >	m_OrdFMax (const LHS &L, const RHS &R)
	Match an 'ordered' floating point maximum function.
template<typename LHS, typename RHS>
FMaxMin_match< LHS, RHS, ofmin_pred_ty >	m_OrdFMin (const LHS &L, const RHS &R)
	Match an 'ordered' floating point minimum function.
template<typename LHS, typename RHS>
FMaxMin_match< LHS, RHS, ufmax_pred_ty >	m_UnordFMax (const LHS &L, const RHS &R)
	Match an 'unordered' floating point maximum function.
template<typename LHS, typename RHS>
FMaxMin_match< LHS, RHS, ufmin_pred_ty >	m_UnordFMin (const LHS &L, const RHS &R)
	Match an 'unordered' floating point minimum function.
template<typename LHS, typename RHS>
match_combine_or< FMaxMin_match< LHS, RHS, ofmax_pred_ty >, FMaxMin_match< LHS, RHS, ufmax_pred_ty > >	m_OrdOrUnordFMax (const LHS &L, const RHS &R)
	Match an 'ordered' or 'unordered' floating point maximum function.
template<typename LHS, typename RHS>
match_combine_or< FMaxMin_match< LHS, RHS, ofmin_pred_ty >, FMaxMin_match< LHS, RHS, ufmin_pred_ty > >	m_OrdOrUnordFMin (const LHS &L, const RHS &R)
	Match an 'ordered' or 'unordered' floating point minimum function.
template<typename ValTy>
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true >	m_Not (const ValTy &V)
	Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
template<typename ValTy>
BinaryOp_match< cst_pred_ty< is_all_ones, false >, ValTy, Instruction::Xor, true >	m_NotForbidPoison (const ValTy &V)
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.
template<unsigned OpI, typename Opnd_t>
Argument_match< Opnd_t >	m_Argument (const Opnd_t &Op)
	Match an argument.
template<Intrinsic::ID IntrID, typename... Ts>
auto	m_Intrinsic (const Ts &...Ops)
	Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
template<Intrinsic::ID... IntrIDs>
IntrinsicIDs_match< IntrIDs... >	m_AnyIntrinsic ()
	Match intrinsic calls with any of the given IDs like this: m_AnyIntrinsic<Intrinsic::fptosi_sat, Intrinsic::fptoui_sat>() This is more efficient than using nested m_CombineOr with m_Intrinsic because it performs the CallInst/Function cast only once.
template<typename Opnd0, typename Opnd1, typename Opnd2>
auto	m_MaskedLoad (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
	Matches MaskedLoad Intrinsic.
template<typename Opnd0, typename Opnd1, typename Opnd2>
auto	m_MaskedStore (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
	Matches MaskedStore Intrinsic.
template<typename Opnd0, typename Opnd1, typename Opnd2>
auto	m_MaskedGather (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
	Matches MaskedGather Intrinsic.
template<typename Opnd0>
auto	m_BitReverse (const Opnd0 &Op0)
template<typename Opnd0>
auto	m_BSwap (const Opnd0 &Op0)
template<typename Opnd0>
auto	m_Ctpop (const Opnd0 &Op0)
template<typename Opnd0>
auto	m_FAbs (const Opnd0 &Op0)
template<typename Opnd0>
auto	m_FCanonicalize (const Opnd0 &Op0)
template<typename Opnd0, typename Opnd1>
auto	m_Ctlz (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_Cttz (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_SMax (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_SMin (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_UMax (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_UMin (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_MaxOrMin (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMinNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMinimum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMinimumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMaxNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMaximum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMaximumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMaxNum_or_FMaximumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
auto	m_FMinNum_or_FMinimumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1, typename Opnd2>
auto	m_FShl (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
template<typename Opnd0, typename Opnd1, typename Opnd2>
auto	m_FShr (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
template<typename Opnd0>
auto	m_Sqrt (const Opnd0 &Op0)
template<typename Opnd0, typename Opnd1>
auto	m_CopySign (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0>
auto	m_VecReverse (const Opnd0 &Op0)
template<typename Opnd0, typename Opnd1, typename Opnd2>
auto	m_VectorInsert (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
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.
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst, true >	m_c_ICmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
	Matches an ICmp with a predicate over LHS and RHS in either order.
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst, true >	m_c_ICmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, CmpInst, true >	m_c_Cmp (const LHS &L, const RHS &R)
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.
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.
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.
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.
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.
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.
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'.
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'.
template<Intrinsic::ID IntrID, typename T0, typename T1>
CommutativeBinaryIntrinsic_match< IntrID, T0, T1 >	m_c_Intrinsic (const T0 &Op0, const T1 &Op1)
template<typename LHS, typename RHS>
auto	m_c_SMin (const LHS &L, const RHS &R)
	Matches an SMin with LHS and RHS in either order.
template<typename LHS, typename RHS>
auto	m_c_SMax (const LHS &L, const RHS &R)
	Matches an SMax with LHS and RHS in either order.
template<typename LHS, typename RHS>
auto	m_c_UMin (const LHS &L, const RHS &R)
	Matches a UMin with LHS and RHS in either order.
template<typename LHS, typename RHS>
auto	m_c_UMax (const LHS &L, const RHS &R)
	Matches a UMax with LHS and RHS in either order.
template<typename LHS, typename RHS>
auto	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.
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.
template<typename Val_t>
Signum_match< Val_t >	m_Signum (const Val_t &V)
	Matches a signum pattern.
template<int Ind, typename Val_t>
ExtractValue_match< Ind, Val_t >	m_ExtractValue (const Val_t &V)
	Match a single index ExtractValue instruction.
template<typename Val_t>
ExtractValue_match<-1, Val_t >	m_ExtractValue (const Val_t &V)
	Match an ExtractValue instruction with any index.
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.
auto	m_VScale ()
	Matches a call to llvm.vscale().
template<typename Opnd0, typename Opnd1>
auto	m_Interleave2 (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd>
auto	m_Deinterleave2 (const Opnd &Op)
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 ?
auto	m_LogicalAnd ()
	Matches L && R where L and R are arbitrary values.
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.
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 ?
auto	m_LogicalOr ()
	Matches L \|\| R where L and R are arbitrary values.
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.
template<typename LHS, typename RHS, bool Commutable = false>
auto	m_LogicalOp (const LHS &L, const RHS &R)
	Matches either L && R or L \|\| R, either one being in the either binary or logical form.
auto	m_LogicalOp ()
	Matches either L && R or L \|\| R where L and R are arbitrary values.
template<typename LHS, typename RHS>
auto	m_c_LogicalOp (const LHS &L, const RHS &R)
	Matches either L && R or L \|\| R with LHS and RHS in either order.

Typedef Documentation

◆ cst_pred_ty

template<typename Predicate, bool AllowPoison = true>

using llvm::PatternMatch::cst_pred_ty = cstval_pred_ty<Predicate, ConstantInt, AllowPoison>

specialization of cstval_pred_ty for ConstantInt

Definition at line 389 of file PatternMatch.h.

◆ cstfp_pred_ty

template<typename Predicate>

using llvm::PatternMatch::cstfp_pred_ty

Initial value:

cstval_pred_ty<Predicate, ConstantFP,

true>

Predicate

Definition AMDGPURegBankLegalizeRules.cpp:497

llvm::ConstantFP

ConstantFP - Floating Point Values [float, double].

Definition Constants.h:420

llvm::PatternMatch::cstval_pred_ty

This helper class is used to match constant scalars, vector splats, and fixed width vectors that sati...

Definition PatternMatch.h:335

specialization of cstval_pred_ty for ConstantFP

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

References LHS, and RHS.

◆ m_AddLike()

template<typename LHS, typename RHS>

match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > llvm::PatternMatch::m_AddLike	(	const LHS &	L,
		const RHS &	R )

inline

Match either "add" or "or disjoint".

Definition at line 1571 of file PatternMatch.h.

References LHS, m_Add(), llvm::PatternMatchHelpers::m_CombineOr(), m_DisjointOr(), and RHS.

Referenced by canonicalizeGEPOfConstGEPI8(), computeKnownBitsFromCmp(), decomposeImpl(), llvm::findValuesAffectedByCondition(), llvm::InstCombinerImpl::foldICmpBinOp(), foldReduceOperandViaVDOT4A(), foldSelectSplitCTLZ(), foldSelectSplitCTTZ(), matchICmpOperand(), llvm::simplifyInstruction(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitMul(), and llvm::InstCombinerImpl::visitSub().

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

Referenced by m_AllOnesOrPoison(), and m_Not().

◆ m_AllOnesForbidPoison()

cst_pred_ty< is_all_ones, false > llvm::PatternMatch::m_AllOnesForbidPoison ( )

inline

Definition at line 513 of file PatternMatch.h.

Referenced by m_NotForbidPoison().

◆ m_AllOnesOrPoison()

auto llvm::PatternMatch::m_AllOnesOrPoison ( )

inline

Definition at line 517 of file PatternMatch.h.

References m_AllOnes(), llvm::PatternMatchHelpers::m_CombineOr(), and m_Poison().

◆ m_AllowContract()

template<typename T>

AllowFmf_match< T, FastMathFlags::AllowContract > llvm::PatternMatch::m_AllowContract ( const T & SubPattern )

inline

Definition at line 109 of file PatternMatch.h.

References T.

Referenced by getFusableFMulOperand(), isFMulAddCandidate(), and isFusableFMulOperand().

◆ m_AllowReassoc()

template<typename T>

AllowFmf_match< T, FastMathFlags::AllowReassoc > llvm::PatternMatch::m_AllowReassoc ( const T & SubPattern )

inline

Definition at line 97 of file PatternMatch.h.

References T.

Referenced by llvm::InstCombinerImpl::foldFMulReassoc(), llvm::InstCombinerImpl::foldPowiReassoc(), and llvm::InstCombinerImpl::visitFMul().

◆ m_AllowReciprocal()

template<typename T>

AllowFmf_match< T, FastMathFlags::AllowReciprocal > llvm::PatternMatch::m_AllowReciprocal ( const T & SubPattern )

inline

Definition at line 103 of file PatternMatch.h.

References T.

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

References LHS, and RHS.

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

◆ m_AnyIntrinsic() [1/4]

auto llvm::PatternMatch::m_AnyIntrinsic ( )

inline

Matches any intrinsic call and ignore it.

Definition at line 148 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

Referenced by addSaturatedDecorationToIntrinsic(), isSpvAggrPlaceholder(), requireAssignType(), and tracesToPointerAlloca().

◆ m_AnyIntrinsic() [2/4]

template<Intrinsic::ID... IntrIDs>

IntrinsicIDs_match< IntrIDs... > llvm::PatternMatch::m_AnyIntrinsic ( )

inline

Match intrinsic calls with any of the given IDs like this: m_AnyIntrinsic<Intrinsic::fptosi_sat, Intrinsic::fptoui_sat>() This is more efficient than using nested m_CombineOr with m_Intrinsic because it performs the CallInst/Function cast only once.

Definition at line 2839 of file PatternMatch.h.

◆ m_AnyIntrinsic() [3/4]

match_bind< const IntrinsicInst > llvm::PatternMatch::m_AnyIntrinsic ( const IntrinsicInst *& I )

inline

Definition at line 881 of file PatternMatch.h.

References I.

◆ m_AnyIntrinsic() [4/4]

match_bind< IntrinsicInst > llvm::PatternMatch::m_AnyIntrinsic ( IntrinsicInst *& I )

inline

Match any intrinsic call, capturing it if we match.

Definition at line 880 of file PatternMatch.h.

References I.

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

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

◆ m_APFloat()

ap_match< APFloat > 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 addNoFPClassAttrsTopDown(), computeKnownFPClass(), computeKnownFPClassFromCond(), factorizeFAddFSub(), foldFabsWithFcmpZero(), foldFCmpFpTrunc(), foldFCmpFSubIntoFCmp(), llvm::InstCombinerImpl::foldFCmpIntToFPConst(), foldFCmpReciprocalAndZero(), foldFPtoI(), foldFrexpOfSelect(), getNegatibleInsts(), llvm::GCNTTIImpl::instCombineIntrinsic(), isImpliedCondFCmps(), isMinMaxCmpSelectEliminable(), matchFastFloatClamp(), simplifyAndOrOfFCmpsWithConstants(), simplifyFCmpInst(), simplifyLdexp(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFAdd(), and llvm::InstCombinerImpl::visitFCmpInst().

◆ m_APFloatAllowPoison()

ap_match< APFloat > llvm::PatternMatch::m_APFloatAllowPoison ( const APFloat *& Res )

inline

Match APFloat while allowing poison in splat vector constants.

Definition at line 301 of file PatternMatch.h.

Referenced by simplifyFCmpInst().

◆ m_APFloatForbidPoison()

ap_match< APFloat > llvm::PatternMatch::m_APFloatForbidPoison ( const APFloat *& Res )

inline

Match APFloat while forbidding poison in splat vector constants.

Definition at line 306 of file PatternMatch.h.

◆ m_APInt()

ap_match< APInt > 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_APIntAllowPoison()

ap_match< APInt > llvm::PatternMatch::m_APIntAllowPoison ( const APInt *& Res )

inline

Match APInt while allowing poison in splat vector constants.

Definition at line 284 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAddUnsigned(), llvm::InstCombinerImpl::convertOrOfShiftsToFunnelShift(), llvm::decomposeBitTestICmp(), llvm::InstCombinerImpl::foldAddWithConstant(), foldAndOrOfICmpEqConstantAndICmp(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpEquality(), llvm::InstCombinerImpl::foldICmpInstWithConstant(), foldNegativePower2AndShiftedMask(), llvm::X86TTIImpl::getIntrinsicInstrCost(), simplifyBinaryIntrinsic(), simplifyICmpWithBinOp(), simplifyICmpWithBinOpOnLHS(), simplifyICmpWithConstant(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitMul(), and llvm::InstCombinerImpl::visitXor().

◆ m_APIntForbidPoison()

ap_match< APInt > llvm::PatternMatch::m_APIntForbidPoison ( const APInt *& Res )

inline

Match APInt while forbidding poison in splat vector constants.

Definition at line 289 of file PatternMatch.h.

◆ m_ApproxFunc()

template<typename T>

AllowFmf_match< T, FastMathFlags::ApproxFunc > llvm::PatternMatch::m_ApproxFunc ( const T & SubPattern )

inline

Definition at line 115 of file PatternMatch.h.

References T.

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

Referenced by llvm::PatternMatch::IntrinsicMatchImpl::impl().

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

References LHS, and RHS.

◆ m_AShrOrSelf()

template<typename LHS>

ShiftLike_match< LHS, Instruction::AShr > llvm::PatternMatch::m_AShrOrSelf	(	const LHS &	L,
		uint64_t &	R )

inline

Matches ashr L, ConstShAmt or L itself (R will be set to zero in this case).

Definition at line 1400 of file PatternMatch.h.

References LHS, and uint64_t.

◆ m_BasicBlock() [1/3]

auto llvm::PatternMatch::m_BasicBlock ( )

inline

Match an arbitrary basic block value and ignore it.

Definition at line 247 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

Referenced by llvm::canPeelLastIteration(), canProveExitOnFirstIteration(), collectUnswitchCandidatesWithInjections(), computeKnownBitsFromOperator(), detectShiftUntilBitTestIdiom(), detectShiftUntilZeroIdiom(), llvm::SCEVExpander::hasRelatedExistingExpansion(), isProcessableCondBI(), and m_Br().

◆ m_BasicBlock() [2/3]

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

inline

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

Definition at line 912 of file PatternMatch.h.

◆ m_BasicBlock() [3/3]

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

inline

Definition at line 913 of file PatternMatch.h.

◆ m_BinOp() [1/5]

auto llvm::PatternMatch::m_BinOp ( )

inline

Match an arbitrary binary operation and ignore it.

Definition at line 142 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

◆ m_BinOp() [2/5]

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

inline

Match a binary operator, capturing it if we match.

Definition at line 875 of file PatternMatch.h.

References I.

◆ m_BinOp() [3/5]

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

inline

Definition at line 876 of file PatternMatch.h.

References I.

◆ m_BinOp() [4/5]

template<typename LHS, typename RHS>

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

inline

Definition at line 1163 of file PatternMatch.h.

References LHS, and RHS.

◆ m_BinOp() [5/5]

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

References LHS, and RHS.

◆ m_BitCast()

template<typename OpTy>

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

inline

◆ m_BitReverse()

template<typename Opnd0>

auto llvm::PatternMatch::m_BitReverse ( const Opnd0 & Op0 )

inline

Definition at line 2864 of file PatternMatch.h.

References m_Intrinsic().

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

References LHS, and RHS.

Referenced by combineCastedMaskArithmetic(), combineMaskBitOp(), combineShiftOfLogicOp(), foldBitOrderCrossLogicOp(), and foldBitOrderCrossLogicOp().

◆ m_Br() [1/2]

template<typename Cond_t>

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

inline

◆ m_Br() [2/2]

template<typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>

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

inline

Definition at line 2524 of file PatternMatch.h.

References C(), F, and T.

◆ m_BSwap()

template<typename Opnd0>

auto llvm::PatternMatch::m_BSwap ( const Opnd0 & Op0 )

inline

Definition at line 2868 of file PatternMatch.h.

References m_Intrinsic().

Referenced by collectBitParts(), foldCtpop(), matchOrConcat(), llvm::recognizeBSwapOrBitReverseIdiom(), 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 3027 of file PatternMatch.h.

References LHS, and RHS.

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

References LHS, and RHS.

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

References LHS, and RHS.

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

References LHS, and RHS.

◆ m_c_BitwiseLogic()

template<typename LHS, typename RHS>

BinOpPred_match< LHS, RHS, is_bitwiselogic_op, true > llvm::PatternMatch::m_c_BitwiseLogic	(	const LHS &	L,
		const RHS &	R )

inline

Matches bitwise logic operations in either order.

Definition at line 1709 of file PatternMatch.h.

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::visitSExt(), and llvm::InstCombinerImpl::visitZExt().

◆ m_c_Cmp()

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, CmpInst, true > llvm::PatternMatch::m_c_Cmp	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 3013 of file PatternMatch.h.

References LHS, and RHS.

Referenced by m_Uncountable(), and llvm::matchUncountableExitCondition().

◆ m_c_DisjointOr()

template<typename LHS, typename RHS>

DisjointOr_match< LHS, RHS, true > llvm::PatternMatch::m_c_DisjointOr	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1562 of file PatternMatch.h.

References LHS, and RHS.

Referenced by simplifyShiftSelectingPackedElement(), and llvm::InstCombinerImpl::visitOr().

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

References LHS, and RHS.

Referenced by llvm::VPlanTransforms::createPartialReductions(), factorizeLerp(), getOptimizableIVOf(), isFMulAddCandidate(), 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 3135 of file PatternMatch.h.

References LHS, and RHS.

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

◆ m_c_ICmp() [1/2]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, ICmpInst, true > llvm::PatternMatch::m_c_ICmp	(	CmpPredicate &	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 3002 of file PatternMatch.h.

References LHS, and RHS.

◆ m_c_ICmp() [2/2]

template<typename LHS, typename RHS>

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

inline

Definition at line 3007 of file PatternMatch.h.

References LHS, and RHS.

◆ m_c_Intrinsic()

template<Intrinsic::ID IntrID, typename T0, typename T1>

CommutativeBinaryIntrinsic_match< IntrID, T0, T1 > llvm::PatternMatch::m_c_Intrinsic	(	const T0 &	Op0,
		const T1 &	Op1 )

inline

Definition at line 3094 of file PatternMatch.h.

References T1.

Referenced by foldSelectZeroOrFixedOp(), m_c_SMax(), m_c_SMin(), m_c_UMax(), m_c_UMin(), m_IncrementOf(), llvm::InstCombinerImpl::visitFAdd(), and llvm::InstCombinerImpl::visitFMul().

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

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::FoldOrOfLogicalAnds(), llvm::VPRecipeWithIRFlags::getCostForRecipeWithOpcode(), simplifyLogicalRecipe(), simplifyOrLogic(), and simplifySelectInst().

◆ m_c_LogicalOp()

template<typename LHS, typename RHS>

auto llvm::PatternMatch::m_c_LogicalOp	(	const LHS &	L,
		const RHS &	R )

inline

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

Definition at line 3342 of file PatternMatch.h.

References LHS, m_LogicalOp(), and RHS.

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

References LHS, and RHS.

Referenced by llvm::VPRecipeWithIRFlags::getCostForRecipeWithOpcode(), simplifyOrLogic(), simplifySelectInst(), and llvm::VPlanTransforms::splitCombinedExits().

◆ m_c_MaxOrMin()

template<typename LHS, typename RHS>

auto llvm::PatternMatch::m_c_MaxOrMin	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 3120 of file PatternMatch.h.

References LHS, m_c_SMax(), m_c_SMin(), m_c_UMax(), m_c_UMin(), llvm::PatternMatchHelpers::m_CombineOr(), and RHS.

Referenced by computeKnownFPClass(), foldMinMaxSharedOp(), reassociateMinMaxWithConstantInOperand(), simplifyCmpSelOfMaxMin(), 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 3034 of file PatternMatch.h.

References LHS, and RHS.

Referenced by checkOuterLoopInsts(), combineRecipe(), llvm::InstCombinerImpl::commonIDivTransforms(), computeKnownBitsFromLerpPattern(), llvm::vputils::findCanonicalIVIncrement(), foldBoxMultiply(), llvm::InstCombinerImpl::foldICmpBinOp(), foldIDivShl(), foldMulHigh(), foldMulSelectToNegate(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldSelectZeroOrFixedOp(), matchExpandedRem(), simplifyDivRem(), simplifyRecipe(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitMul().

◆ m_c_NSWAdd()

template<typename LHS, typename RHS>

OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap, true > llvm::PatternMatch::m_c_NSWAdd	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1443 of file PatternMatch.h.

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

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

◆ m_c_NUWAdd()

template<typename LHS, typename RHS>

OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > llvm::PatternMatch::m_c_NUWAdd	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1485 of file PatternMatch.h.

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

Referenced by computeKnownBitsFromCmp(), llvm::InstCombinerImpl::foldICmpAddConstant(), and isRemOfLoopIncrementWithLoopInvariant().

◆ 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

Matches an Or with LHS and RHS in either order.

Definition at line 3048 of file PatternMatch.h.

References LHS, and RHS.

◆ m_c_Select()

template<typename LHS, typename RHS>

ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true > llvm::PatternMatch::m_c_Select	(	const LHS &	L,
		const RHS &	R )

inline

Match Select(C, LHS, RHS) or Select(C, RHS, LHS)

Definition at line 1979 of file PatternMatch.h.

References LHS, m_Value(), and RHS.

Referenced by foldTwoEntryPHINode(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitFreeze(), and llvm::InstCombinerImpl::visitSub().

◆ m_c_SMax()

template<typename LHS, typename RHS>

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

References LHS, m_c_Intrinsic(), and RHS.

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

◆ m_c_SMin()

template<typename LHS, typename RHS>

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

References LHS, m_c_Intrinsic(), and RHS.

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

◆ m_c_SpecificICmp()

template<typename LHS, typename RHS>

SpecificCmpClass_match< LHS, RHS, ICmpInst, true > llvm::PatternMatch::m_c_SpecificICmp	(	CmpPredicate	MatchPred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 1858 of file PatternMatch.h.

References LHS, and RHS.

◆ m_c_UMax()

template<typename LHS, typename RHS>

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

References LHS, m_c_Intrinsic(), and RHS.

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

◆ m_c_UMin()

template<typename LHS, typename RHS>

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

References LHS, m_c_Intrinsic(), and RHS.

Referenced by foldToUnsignedSaturatedAdd(), isTruePredicate(), 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 3055 of file PatternMatch.h.

References LHS, and RHS.

Referenced by foldComplexAndOrPatterns(), llvm::InstCombinerImpl::foldICmpEquality(), foldICmpPow2Test(), llvm::InstCombinerImpl::foldICmpXorShiftConst(), foldICmpXorXX(), foldXorToXor(), getKnownBitsFromAndXorOr(), haveNoCommonBitsSetSpecialCases(), instCombineXorSVECmpCC(), isConditionalOnXorOfPHIs(), isMaskOrZero(), isSignificantBitCheckWellFormed(), m_Not(), m_NotForbidPoison(), matchXorCC(), simplifyAndInst(), simplifyOrLogic(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitCallInst(), visitMaskedMerge(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitSub(), and llvm::InstCombinerImpl::visitXor().

◆ m_c_XorLike()

template<typename LHS, typename RHS>

auto llvm::PatternMatch::m_c_XorLike	(	const LHS &	L,
		const RHS &	R )

inline

Match either (xor L, R), (xor R, L) or (sub nuw R, L) iff R.isMask() Only commutative matcher as the sub will need to swap the L and R.

Definition at line 1619 of file PatternMatch.h.

References LHS, and RHS.

◆ m_CastOrSelf()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, CastInst >, OpTy > llvm::PatternMatch::m_CastOrSelf ( const OpTy & Op )

inline

Matches any cast or self. Used to ignore casts.

Definition at line 2272 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr().

Referenced by tryToRecognizeTableBasedCttz(), and tryToRecognizeTableBasedLog2().

◆ m_CheckedFp() [1/2]

cstfp_pred_ty< custom_checkfn< APFloat > > llvm::PatternMatch::m_CheckedFp	(	const Constant *&	V,
		function_ref< bool(const APFloat &)>	CheckFn )

inline

Definition at line 483 of file PatternMatch.h.

◆ m_CheckedFp() [2/2]

cstfp_pred_ty< custom_checkfn< APFloat > > llvm::PatternMatch::m_CheckedFp ( function_ref< bool(const APFloat &)> CheckFn )

inline

Match a float or vector where CheckFn(ele) for each element is true.

For vectors, poison elements are assumed to match.

Definition at line 478 of file PatternMatch.h.

Referenced by llvm::isKnownIntegral().

◆ m_CheckedInt() [1/2]

cst_pred_ty< custom_checkfn< APInt > > llvm::PatternMatch::m_CheckedInt	(	const Constant *&	V,
		function_ref< bool(const APInt &)>	CheckFn )

inline

Definition at line 471 of file PatternMatch.h.

◆ m_CheckedInt() [2/2]

cst_pred_ty< custom_checkfn< APInt > > llvm::PatternMatch::m_CheckedInt ( function_ref< bool(const APInt &)> CheckFn )

inline

Match an integer or vector where CheckFn(ele) for each element is true.

For vectors, poison elements are assumed to match.

Definition at line 466 of file PatternMatch.h.

Referenced by foldCttzCtlz(), llvm::InstCombinerImpl::foldICmpCommutative(), foldMinimumOverTrailingOrLeadingZeroCount(), simplifyRem(), and llvm::InstCombinerImpl::visitMul().

◆ m_Cmp() [1/3]

auto llvm::PatternMatch::m_Cmp ( )

inline

Matches any compare instruction and ignore it.

Definition at line 145 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

Referenced by cheapToScalarize(), combineRecipe(), llvm::VPBlendRecipe::computeCost(), llvm::VPInstruction::computeCost(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), llvm::VPlanTransforms::createInLoopReductionRecipes(), foldSelectBinOpIdentity(), foldTwoEntryPHINode(), llvm::AArch64TTIImpl::getCmpSelInstrCost(), llvm::VPRecipeWithIRFlags::getCostForRecipeWithOpcode(), getHashValueImpl(), llvm::SystemZTargetLowering::getJumpConditionMergingParams(), llvm::VPlanTransforms::handleMultiUseReductions(), llvm::RecurrenceDescriptor::isAnyOfPattern(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), isEqualImpl(), llvm::RecurrenceDescriptor::isFindPattern(), and llvm::InstCombinerImpl::visitExtractElementInst().

◆ m_Cmp() [2/3]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, CmpInst > llvm::PatternMatch::m_Cmp	(	CmpPredicate &	Pred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 1783 of file PatternMatch.h.

References LHS, and RHS.

◆ m_Cmp() [3/3]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, CmpInst > llvm::PatternMatch::m_Cmp	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1801 of file PatternMatch.h.

References LHS, and RHS.

◆ m_Constant() [1/2]

auto llvm::PatternMatch::m_Constant ( )

inline

Match an arbitrary Constant and ignore it.

Definition at line 177 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

◆ m_Constant() [2/2]

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

inline

Match a Constant, capturing the value if we match.

Definition at line 900 of file PatternMatch.h.

References C().

◆ m_ConstantExpr() [1/2]

auto llvm::PatternMatch::m_ConstantExpr ( )

inline

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

Definition at line 207 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_ContainsMatchingVectorElement(), and llvm::PatternMatchHelpers::m_Isa().

Referenced by llvm::PatternMatch::immconstant_ty::isImmConstant(), simplifyInstructionWithPHI(), and llvm::InstCombinerImpl::visitXor().

◆ m_ConstantExpr() [2/2]

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

inline

Match a ConstantExpr, capturing the value if we match.

Definition at line 909 of file PatternMatch.h.

References C().

◆ m_ConstantFP() [1/2]

auto llvm::PatternMatch::m_ConstantFP ( )

inline

Match an arbitrary ConstantFP and ignore it.

Definition at line 183 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

Referenced by llvm::GCNTTIImpl::instCombineIntrinsic(), and matchFPExtFromF16().

◆ m_ConstantFP() [2/2]

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

inline

Match a ConstantFP, capturing the value if we match.

Definition at line 906 of file PatternMatch.h.

References C().

◆ m_ConstantInt() [1/4]

auto llvm::PatternMatch::m_ConstantInt ( )

inline

Match an arbitrary ConstantInt and ignore it.

Definition at line 180 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

◆ m_ConstantInt() [2/4]

template<int64_t Val>

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

inline

Match a ConstantInt with a specific value.

Definition at line 326 of file PatternMatch.h.

◆ m_ConstantInt() [3/4]

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

inline

Match a ConstantInt, capturing the value if we match.

Definition at line 903 of file PatternMatch.h.

◆ m_ConstantInt() [4/4]

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

References uint64_t.

◆ m_ContainsMatchingVectorElement()

template<typename SPTy>

ContainsMatchingVectorElement_match< SPTy > llvm::PatternMatch::m_ContainsMatchingVectorElement ( const SPTy & SubPattern )

inline

Match a vector constant where at least one of its elements matches the subpattern.

Scalable vector constants are not matched. Any bindings in the subpattern will be bound to the first match.

Definition at line 201 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::commonIDivRemTransforms(), m_ConstantExpr(), llvm::maskContainsAllOneOrUndef(), and llvm::InstCombinerImpl::visitFreeze().

◆ m_CopySign()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_CopySign	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2974 of file PatternMatch.h.

References m_Intrinsic().

Referenced by optimizeSymmetricCall(), llvm::InstCombiner::stripSignOnlyFPOps(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitFNeg().

◆ m_Ctlz()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_Ctlz	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2884 of file PatternMatch.h.

References m_Intrinsic().

Referenced by computeKnownBitsFromOperator(), foldSelectSplitCTLZ(), foldSubCtlzNot(), llvm::InstCombinerImpl::visitAdd(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_Ctpop()

template<typename Opnd0>

auto llvm::PatternMatch::m_Ctpop ( const Opnd0 & Op0 )

inline

Definition at line 2871 of file PatternMatch.h.

References m_Intrinsic().

Referenced by llvm::findValuesAffectedByCondition(), foldIsPowerOf2(), foldIsPowerOf2OrZero(), isImpliedToBeAPowerOfTwoFromCond(), simplifyAndOrOfICmpsWithCtpop(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), llvm::InstCombinerImpl::tryFoldInstWithCtpopWithNot(), llvm::InstCombinerImpl::visitAdd(), and llvm::InstCombinerImpl::visitSub().

◆ m_Cttz()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_Cttz	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2889 of file PatternMatch.h.

References m_Intrinsic().

Referenced by foldSelectSplitCTTZ(), setShiftFlags(), llvm::InstCombinerImpl::visitLShr(), and llvm::InstCombinerImpl::visitShl().

◆ m_Deferred() [1/4]

match_deferred< BasicBlock > llvm::PatternMatch::m_Deferred ( BasicBlock *const & BB )

inline

A commutative-friendly version of m_Specific().

Definition at line 1100 of file PatternMatch.h.

◆ m_Deferred() [2/4]

match_deferred< const BasicBlock > llvm::PatternMatch::m_Deferred ( const BasicBlock *const & BB )

inline

Definition at line 1104 of file PatternMatch.h.

◆ m_Deferred() [3/4]

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

inline

Definition at line 982 of file PatternMatch.h.

◆ m_Deferred() [4/4]

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

◆ m_Deinterleave2()

template<typename Opnd>

auto llvm::PatternMatch::m_Deinterleave2 ( const Opnd & Op )

inline

Definition at line 3240 of file PatternMatch.h.

References m_Intrinsic().

◆ m_DisjointOr()

template<typename LHS, typename RHS>

DisjointOr_match< LHS, RHS > llvm::PatternMatch::m_DisjointOr	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1557 of file PatternMatch.h.

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::foldAddWithConstant(), isKnownNoWrap(), m_AddLike(), m_NSWAddLike(), m_NUWAddLike(), llvm::InstCombinerImpl::tryFoldInstWithCtpopWithNot(), and llvm::InstCombinerImpl::visitXor().

◆ m_ElementWiseBitCast()

template<typename OpTy>

ElementWiseBitCast_match< OpTy > llvm::PatternMatch::m_ElementWiseBitCast ( const OpTy & Op )

inline

Definition at line 2233 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::commonCastTransforms(), computeKnownBitsFromOperator(), computeKnownFPClass(), computeKnownFPClassFromCond(), llvm::findValuesAffectedByCondition(), foldCopySignIdioms(), llvm::InstCombinerImpl::foldICmpAndConstConst(), foldLogOpOfMaskedICmps_NotAllZeros_BMask_Mixed(), simplifyICmpWithConstant(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFCmpInst(), llvm::InstCombinerImpl::visitOr(), and llvm::InstCombinerImpl::visitXor().

◆ m_Exact()

template<typename T>

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

inline

Definition at line 1742 of file PatternMatch.h.

References T.

Referenced by foldCttzCtlz(), simplifyMulInst(), simplifyShlInst(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitShl(), llvm::InstCombinerImpl::visitTrunc(), 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 2001 of file PatternMatch.h.

Referenced by canonicalizeBitCastExtElt(), canSafelyConvertTo16Bit(), convertTo16Bit(), foldInsEltIntoIdentityShuffle(), foldVecExtTruncToExtElt(), slpvectorizer::BoUpSLP::LookAheadHeuristics::getShallowScore(), isOperandOfVmullHighP64(), lowerBUILD_VECTOR(), matchPMADDWD(), matchPMADDWD_2(), matchSubIntegerPackFromVector(), llvm::RISCVTargetLowering::PerformDAGCombine(), performMINMAXCombine(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), llvm::simplifyInsertElementInst(), and llvm::InstCombinerImpl::visitInsertElementInst().

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

Referenced by llvm::computeConstantRange(), directlyImpliesPoison(), dominatesMergePoint(), llvm::InstCombinerImpl::foldICmpInstWithConstant(), foldICmpOfUAddOv(), foldOrUnsignedUMulOverflowICmp(), isKnownNonZeroFromOperator(), m_IncrementOf(), matchIncrement(), llvm::patchReplacementInstruction(), replaceOverflowUses(), llvm::InstCombinerImpl::SimplifyDemandedUseFPClass(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitExtractValueInst(), and llvm::InstCombinerImpl::visitOr().

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

◆ m_FAbs()

template<typename Opnd0>

auto llvm::PatternMatch::m_FAbs ( const Opnd0 & Op0 )

inline

Definition at line 2875 of file PatternMatch.h.

References m_Intrinsic().

Referenced by computeKnownExponentRangeFromContext(), llvm::findValuesAffectedByCondition(), foldFabsWithFcmpZero(), foldFCmpFAbsFSubIntToFP(), foldSelectBinOpIdentity(), foldShuffleOfUnaryOps(), llvm::GCNTTIImpl::isProfitableToSinkOperands(), optimizeSymmetricCall(), simplifyAndOrOfFCmps(), llvm::InstCombinerImpl::SimplifyDemandedUseFPClass(), llvm::InstCombinerImpl::SimplifyMultipleUseDemandedFPClass(), llvm::InstCombiner::stripSignOnlyFPOps(), 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 1223 of file PatternMatch.h.

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::foldFMulReassoc(), foldFNegIntoConstant(), getFusableFMulOperand(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), m_AnyAdd(), llvm::InstCombinerImpl::visitFAdd(), and llvm::InstCombinerImpl::visitFCmpInst().

◆ m_FCanonicalize()

template<typename Opnd0>

auto llvm::PatternMatch::m_FCanonicalize ( const Opnd0 & Op0 )

inline

Definition at line 2879 of file PatternMatch.h.

References m_Intrinsic().

◆ m_FCmp() [1/2]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, FCmpInst > llvm::PatternMatch::m_FCmp	(	CmpPredicate &	Pred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 1795 of file PatternMatch.h.

References LHS, and RHS.

Referenced by computeKnownExponentRangeFromContext(), computeKnownFPClassFromCond(), llvm::findValuesAffectedByCondition(), reassociateFCmps(), simplifySelectWithFCmp(), and llvm::InstCombinerImpl::visitCondBrInst().

◆ m_FCmp() [2/2]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, FCmpInst > llvm::PatternMatch::m_FCmp	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1811 of file PatternMatch.h.

References LHS, and RHS.

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

References LHS, and RHS.

Referenced by convertFSqrtDivIntoFMul(), factorizeFAddFSub(), foldFDivConstantDividend(), foldFDivSqrtDivisor(), llvm::InstCombinerImpl::foldFMulReassoc(), foldFNegIntoConstant(), foldFPtoI(), getFSqrtDivOptPattern(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFDiv(), 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 771 of file PatternMatch.h.

Referenced by computeKnownExponentRangeFromContext().

◆ m_Finite() [2/2]

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

inline

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

Referenced by foldFCmpFAbsFSubIntToFP().

◆ m_FiniteNonZero() [2/2]

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

inline

Definition at line 784 of file PatternMatch.h.

◆ m_FMaximum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMaximum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2940 of file PatternMatch.h.

References m_Intrinsic().

Referenced by getMinMaxRecurrence(), and llvm::slpvectorizer::matchRdxBop().

◆ m_FMaximumNum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMaximumNum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2945 of file PatternMatch.h.

References m_Intrinsic().

Referenced by m_FMaxNum_or_FMaximumNum().

◆ m_FMaxNum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMaxNum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2935 of file PatternMatch.h.

References m_Intrinsic().

Referenced by m_FMaxNum_or_FMaximumNum(), matchFastFloatClamp(), and llvm::slpvectorizer::matchRdxBop().

◆ m_FMaxNum_or_FMaximumNum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMaxNum_or_FMaximumNum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2950 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_FMaximumNum(), and m_FMaxNum().

Referenced by simplifyFCmpInst().

◆ m_FMinimum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMinimum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2925 of file PatternMatch.h.

References m_Intrinsic().

Referenced by getMinMaxRecurrence(), and llvm::slpvectorizer::matchRdxBop().

◆ m_FMinimumNum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMinimumNum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2930 of file PatternMatch.h.

References m_Intrinsic().

Referenced by m_FMinNum_or_FMinimumNum().

◆ m_FMinNum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMinNum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2920 of file PatternMatch.h.

References m_Intrinsic().

Referenced by m_FMinNum_or_FMinimumNum(), matchFastFloatClamp(), and llvm::slpvectorizer::matchRdxBop().

◆ m_FMinNum_or_FMinimumNum()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_FMinNum_or_FMinimumNum	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2955 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_FMinimumNum(), and m_FMinNum().

Referenced by simplifyFCmpInst().

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

References LHS, and RHS.

Referenced by factorizeFAddFSub(), foldFDivConstantDividend(), foldFNegIntoConstant(), llvm::AArch64TTIImpl::getArithmeticInstrCost(), getFSqrtDivOptPattern(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), isFMulAddCandidate(), isFusableFMulOperand(), isInstructionPairMul(), m_AnyMul(), llvm::RISCVTargetLowering::PerformDAGCombine(), 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 1271 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 1278 of file PatternMatch.h.

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

Referenced by simplifyFDivInst().

◆ m_FPExt()

template<typename OpTy>

CastInst_match< OpTy, FPExtInst > llvm::PatternMatch::m_FPExt ( const OpTy & Op )

inline

Definition at line 2474 of file PatternMatch.h.

Referenced by canSafelyConvertTo16Bit(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::GCNTTIImpl::instCombineIntrinsic(), matchFPExtFromF16(), 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 1009 of file PatternMatch.h.

References m_SpecificFP().

Referenced by factorizeLerp(), llvm::GCNTTIImpl::getArithmeticInstrCost(), getFSqrtDivOptPattern(), simplifyFDivInst(), simplifyFMAFMul(), and llvm::InstCombinerImpl::visitFMul().

◆ m_FPToI()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, FPToUIInst >, CastInst_match< OpTy, FPToSIInst > > llvm::PatternMatch::m_FPToI ( const OpTy & Op )

inline

Definition at line 2464 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_FPToSI(), and m_FPToUI().

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

◆ m_FPToSI()

template<typename OpTy>

CastInst_match< OpTy, FPToSIInst > llvm::PatternMatch::m_FPToSI ( const OpTy & Op )

inline

Definition at line 2457 of file PatternMatch.h.

Referenced by llvm::InstCombiner::canBeCastedExactlyIntToFP(), m_FPToI(), performNanGuardFpToSatCombine(), and tryToFPToSat().

◆ m_FPToUI()

template<typename OpTy>

CastInst_match< OpTy, FPToUIInst > llvm::PatternMatch::m_FPToUI ( const OpTy & Op )

inline

Definition at line 2452 of file PatternMatch.h.

Referenced by m_FPToI(), and performNanGuardFpToSatCombine().

◆ m_FPTrunc()

template<typename OpTy>

CastInst_match< OpTy, FPTruncInst > llvm::PatternMatch::m_FPTrunc ( const OpTy & Op )

inline

Definition at line 2469 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpBitCast(), llvm::InstCombinerImpl::visitFCmpInst(), 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 1986 of file PatternMatch.h.

Referenced by getRecipesForUncountableExit(), and llvm::InstCombinerImpl::visitFreeze().

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

References LHS, and RHS.

◆ m_FShl()

template<typename Opnd0, typename Opnd1, typename Opnd2>

auto llvm::PatternMatch::m_FShl	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1,
		const Opnd2 &	Op2 )

inline

Definition at line 2960 of file PatternMatch.h.

References m_Intrinsic().

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

◆ m_FShr()

template<typename Opnd0, typename Opnd1, typename Opnd2>

auto llvm::PatternMatch::m_FShr	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1,
		const Opnd2 &	Op2 )

inline

Definition at line 2965 of file PatternMatch.h.

References m_Intrinsic().

Referenced by collectBitParts(), foldCtpop(), foldSelectZeroOrFixedOp(), 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 1235 of file PatternMatch.h.

References LHS, and RHS.

Referenced by factorizeLerp(), foldFCmpFAbsFSubIntToFP(), foldFCmpFSubIntoFCmp(), llvm::InstCombinerImpl::foldFMulReassoc(), getFusableFMulOperand(), isAbsoluteValueULEOne(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), m_FNegNSZ(), simplifyFAddInst(), simplifyFSubInst(), llvm::InstCombinerImpl::visitFAdd(), llvm::InstCombinerImpl::visitFNeg(), and llvm::InstCombinerImpl::visitFSub().

◆ m_GEP()

template<typename... OperandTypes>

auto llvm::PatternMatch::m_GEP ( const OperandTypes &... Ops )

inline

Matches GetElementPtrInst.

Definition at line 2121 of file PatternMatch.h.

References AbstractManglingParser< Derived, Alloc >::Ops.

Referenced by foldDependentIVs(), and processUse().

◆ m_ICmp() [1/2]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, ICmpInst > llvm::PatternMatch::m_ICmp	(	CmpPredicate &	Pred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 1789 of file PatternMatch.h.

References LHS, and RHS.

◆ m_ICmp() [2/2]

template<typename LHS, typename RHS>

CmpClass_match< LHS, RHS, ICmpInst > llvm::PatternMatch::m_ICmp	(	const LHS &	L,
		const RHS &	R )

inline

Definition at line 1806 of file PatternMatch.h.

References LHS, and RHS.

◆ m_ICmpLike()

template<typename LHS, typename RHS>

ICmpLike_match< LHS, RHS > llvm::PatternMatch::m_ICmpLike	(	CmpPredicate &	Pred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 2381 of file PatternMatch.h.

References LHS, and RHS.

Referenced by checkOrAndOpImpliedByOther(), llvm::isImpliedCondition(), llvm::isImpliedCondition(), and simplifyAndOrWithICmpEq().

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

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), foldSelectZeroOrFixedOp(), isKnownNonNullFromDominatingCondition(), matchExpandedRem(), simplifyMulInst(), and llvm::InstCombinerImpl::visitGetElementPtrInst().

◆ m_ImmConstant() [1/2]

match_immconstant_ty llvm::PatternMatch::m_ImmConstant ( )

inline

Match an arbitrary immediate Constant and ignore it.

Definition at line 942 of file PatternMatch.h.

◆ m_ImmConstant() [2/2]

bind_immconstant_ty llvm::PatternMatch::m_ImmConstant ( Constant *& C )

inline

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

Definition at line 959 of file PatternMatch.h.

References C().

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

Referenced by matchUnorderedInfCompare(), simplifyFAddInst(), simplifyFPOp(), and simplifyFSubInst().

◆ m_InsertElt()

template<typename Val_t, typename Elt_t, typename Idx_t>

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

inline

◆ m_InsertValue()

template<int Ind, typename Val_t, typename Elt_t>

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

inline

Matches a single index InsertValue instruction.

Definition at line 3227 of file PatternMatch.h.

◆ m_Instruction() [1/4]

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

inline

Definition at line 855 of file PatternMatch.h.

References I.

◆ m_Instruction() [2/4]

template<typename Pattern>

auto llvm::PatternMatch::m_Instruction	(	const Instruction *&	I,
		const Pattern &	P )

inline

Definition at line 865 of file PatternMatch.h.

References I, llvm::PatternMatchHelpers::m_CombineAnd(), and P.

◆ m_Instruction() [3/4]

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

inline

Match an instruction, capturing it if we match.

Definition at line 854 of file PatternMatch.h.

References I.

◆ m_Instruction() [4/4]

template<typename Pattern>

auto llvm::PatternMatch::m_Instruction	(	Instruction *&	I,
		const Pattern &	P )

inline

Match against the nested pattern, and capture the instruction if we match.

Definition at line 861 of file PatternMatch.h.

References I, llvm::PatternMatchHelpers::m_CombineAnd(), and P.

◆ m_Interleave2()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_Interleave2	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 3236 of file PatternMatch.h.

References m_Intrinsic().

◆ m_Intrinsic()

template<Intrinsic::ID IntrID, typename... Ts>

auto llvm::PatternMatch::m_Intrinsic ( const Ts &... Ops )

inline

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

Definition at line 2829 of file PatternMatch.h.

References AbstractManglingParser< Derived, Alloc >::Ops, and llvm::PatternMatch::IntrinsicMatchImpl::impl().

◆ m_IntToPtr()

template<typename OpTy>

CastOperator_match< OpTy, Instruction::IntToPtr > llvm::PatternMatch::m_IntToPtr ( const OpTy & Op )

inline

Matches IntToPtr.

Definition at line 2265 of file PatternMatch.h.

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

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(), foldSelectZeroOrFixedOp(), and isKnownNonNullFromDominatingCondition().

◆ m_IToFP()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, UIToFPInst >, CastInst_match< OpTy, SIToFPInst > > llvm::PatternMatch::m_IToFP ( const OpTy & Op )

inline

Definition at line 2447 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_SIToFP(), and m_UIToFP().

Referenced by foldFCmpFSubIntoFCmp(), getMinimumFPType(), and simplifyUnaryIntrinsic().

◆ m_Load()

template<typename OpTy>

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

inline

Matches LoadInst.

Definition at line 2091 of file PatternMatch.h.

Referenced by cheapToScalarize(), llvm::findHistogram(), foldToMaskedStore(), llvm::X86TTIImpl::getShuffleCost(), llvm::AArch64TTIImpl::isProfitableToSinkOperands(), and llvm::matchUncountableExitCondition().

◆ m_LoadSimple()

template<typename OpTy>

LoadSimple_match< OpTy > llvm::PatternMatch::m_LoadSimple ( const OpTy & Op )

inline

Definition at line 2107 of file PatternMatch.h.

Referenced by processUse().

◆ m_LogicalAnd() [1/2]

auto llvm::PatternMatch::m_LogicalAnd ( )

inline

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

Definition at line 3300 of file PatternMatch.h.

References m_LogicalAnd(), and m_Value().

Referenced by checkOrAndOpImpliedByOther(), collectHomogenousInstGraphLoopInvariants(), collectUnswitchCandidates(), combineRecipe(), computeKnownBitsFromCond(), computeKnownFPClassFromCond(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), findBestNonTrivialUnswitchCandidate(), llvm::SelectionDAGBuilder::FindMergedConditions(), llvm::InstCombinerImpl::FoldOrOfLogicalAnds(), llvm::InstCombiner::getFreelyInvertedImpl(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::TargetTransformInfoImplCRTPBase< T >::getInstructionCost(), hoistMinMax(), isImpliedCondAndOr(), llvm::isImpliedCondition(), isKnownNonNullFromDominatingCondition(), m_LogicalAnd(), llvm::VPlanPatternMatch::RemoveMask_match< Op0_t, Op1_t >::match(), llvm::VPlanTransforms::optimizeEVLMasks(), optimizeLoopExitWithUnknownExitCount(), optimizeMaskToEVL(), reassociateHeaderMask(), simplifyLogicalRecipe(), llvm::InstCombinerImpl::sinkNotIntoLogicalOp(), llvm::InstCombinerImpl::sinkNotIntoOtherHandOfLogicalOp(), llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(), unswitchNontrivialInvariants(), unswitchTrivialBranch(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitCondBrInst(), and llvm::InstCombinerImpl::visitXor().

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

References LHS, and RHS.

Referenced by removeCommonBlendMask(), llvm::InstCombiner::shouldAvoidAbsorbingNotIntoSelect(), llvm::TargetTransformInfoImplBase::shouldTreatInstructionLikeSelect(), tryCombineFromSVBoolBinOp(), and unswitchTrivialBranch().

◆ m_LogicalOp() [1/2]

auto llvm::PatternMatch::m_LogicalOp ( )

inline

Matches either L && R or L || R where L and R are arbitrary values.

Definition at line 3338 of file PatternMatch.h.

References m_LogicalOp(), and m_Value().

Referenced by computeKnownBitsFromCond(), llvm::findValuesAffectedByCondition(), m_LogicalOp(), llvm::InstCombinerImpl::sinkNotIntoLogicalOp(), and llvm::InstCombinerImpl::sinkNotIntoOtherHandOfLogicalOp().

◆ m_LogicalOp() [2/2]

template<typename LHS, typename RHS, bool Commutable = false>

auto llvm::PatternMatch::m_LogicalOp	(	const LHS &	L,
		const RHS &	R )

inline

Matches either L && R or L || R, either one being in the either binary or logical form.

Note that the latter form is poison-blocking.

Definition at line 3331 of file PatternMatch.h.

References LHS, llvm::PatternMatchHelpers::m_CombineOr(), and RHS.

Referenced by m_c_LogicalOp().

◆ m_LogicalOr() [1/2]

auto llvm::PatternMatch::m_LogicalOr ( )

inline

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

Definition at line 3318 of file PatternMatch.h.

References m_LogicalOr(), and m_Value().

Referenced by checkOrAndOpImpliedByOther(), collectHomogenousInstGraphLoopInvariants(), collectUnswitchCandidates(), computeKnownBitsFromCond(), computeKnownFPClassFromCond(), llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(), findBestNonTrivialUnswitchCandidate(), llvm::SelectionDAGBuilder::FindMergedConditions(), llvm::InstCombiner::getFreelyInvertedImpl(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::TargetTransformInfoImplCRTPBase< T >::getInstructionCost(), hoistMinMax(), isImpliedCondAndOr(), llvm::isImpliedCondition(), m_LogicalOr(), llvm::matchCombinedExitCondition(), optimizeLoopExitWithUnknownExitCount(), llvm::VPlanTransforms::splitCombinedExits(), llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(), unswitchNontrivialInvariants(), unswitchTrivialBranch(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitOr(), and llvm::InstCombinerImpl::visitXor().

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

References LHS, and RHS.

Referenced by llvm::InstCombiner::shouldAvoidAbsorbingNotIntoSelect(), llvm::TargetTransformInfoImplBase::shouldTreatInstructionLikeSelect(), and unswitchTrivialBranch().

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

References LHS, and RHS.

Referenced by collectBitParts(), llvm::InstCombinerImpl::convertOrOfShiftsToFunnelShift(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), 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 671 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpAndConstant(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpEquality(), llvm::InstCombinerImpl::foldIsMultipleOfAPowerOfTwo(), llvm::PatternMatch::XorLike_match< LHS, RHS >::match(), processAnd(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), llvm::simplifyInstruction(), simplifySubInst(), simplifyXorInst(), llvm::stripNullTest(), llvm::InstCombinerImpl::visitAdd(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_LowBitMask() [2/2]

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

inline

Definition at line 674 of file PatternMatch.h.

◆ m_LowBitMaskOrZero() [1/2]

cst_pred_ty< is_lowbit_mask_or_zero > llvm::PatternMatch::m_LowBitMaskOrZero ( )

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 681 of file PatternMatch.h.

Referenced by isMaskOrZero().

◆ m_LowBitMaskOrZero() [2/2]

api_pred_ty< is_lowbit_mask_or_zero > llvm::PatternMatch::m_LowBitMaskOrZero ( const APInt *& V )

inline

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

References LHS, and RHS.

◆ m_LShrOrSelf()

template<typename LHS>

ShiftLike_match< LHS, Instruction::LShr > llvm::PatternMatch::m_LShrOrSelf	(	const LHS &	L,
		uint64_t &	R )

inline

Matches lshr L, ConstShAmt or L itself (R will be set to zero in this case).

Definition at line 1393 of file PatternMatch.h.

References LHS, and uint64_t.

Referenced by matchPartStore().

◆ m_MaskedGather()

template<typename Opnd0, typename Opnd1, typename Opnd2>

auto llvm::PatternMatch::m_MaskedGather	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1,
		const Opnd2 &	Op2 )

inline

Matches MaskedGather Intrinsic.

Definition at line 2858 of file PatternMatch.h.

References m_Intrinsic().

◆ m_MaskedLoad()

template<typename Opnd0, typename Opnd1, typename Opnd2>

auto llvm::PatternMatch::m_MaskedLoad	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1,
		const Opnd2 &	Op2 )

inline

Matches MaskedLoad Intrinsic.

Definition at line 2845 of file PatternMatch.h.

References m_Intrinsic().

Referenced by optimizeMaskToEVL().

◆ m_MaskedStore()

template<typename Opnd0, typename Opnd1, typename Opnd2>

auto llvm::PatternMatch::m_MaskedStore	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1,
		const Opnd2 &	Op2 )

inline

Matches MaskedStore Intrinsic.

Definition at line 2851 of file PatternMatch.h.

References m_Intrinsic().

Referenced by optimizeMaskToEVL().

◆ m_MaxOrMin()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_MaxOrMin	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2914 of file PatternMatch.h.

References llvm::PatternMatchHelpers::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::getFreelyInvertedImpl(), 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 525 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAddSigned(), canonicalizeSaturatedSubtractSigned(), and llvm::InstCombinerImpl::visitAnd().

◆ m_MaxSignedValue() [2/2]

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

inline

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

References LHS, and RHS.

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

Referenced by 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 3063 of file PatternMatch.h.

References m_Sub(), and m_ZeroInt().

Referenced by llvm::PatternMatch::Signum_match< Opnd_t >::match().

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

Referenced by foldNegativePower2AndShiftedMask(), foldRoundUpToPow2Alignment(), llvm::simplifyInstruction(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitMul(), llvm::InstCombinerImpl::visitSDiv(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_NegatedPower2() [2/2]

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

inline

Definition at line 628 of file PatternMatch.h.

◆ m_NegatedPower2OrZero() [1/2]

cst_pred_ty< is_negated_power2_or_zero > llvm::PatternMatch::m_NegatedPower2OrZero ( )

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 637 of file PatternMatch.h.

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

◆ m_NegatedPower2OrZero() [2/2]

api_pred_ty< is_negated_power2_or_zero > llvm::PatternMatch::m_NegatedPower2OrZero ( const APInt *& V )

inline

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

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

◆ m_Negative() [2/2]

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

inline

Definition at line 540 of file PatternMatch.h.

◆ m_NegInf()

cstfp_pred_ty< is_signed_inf< true > > llvm::PatternMatch::m_NegInf ( )

inline

Match a negative infinity FP constant.

For vectors, this includes constants with undefined elements.

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

Referenced by llvm::ConstantFoldBinaryInstruction(), simplifyFAddInst(), simplifyFRemInst(), simplifyFSubInst(), and llvm::InstCombinerImpl::visitCallInst().

◆ m_NNegZExt()

template<typename OpTy>

NNegZExt_match< OpTy > llvm::PatternMatch::m_NNegZExt ( const OpTy & Op )

inline

Definition at line 2315 of file PatternMatch.h.

Referenced by m_SExtLike(), and llvm::InstCombinerImpl::visitGetElementPtrInst().

◆ m_NoInfs()

template<typename T>

AllowFmf_match< T, FastMathFlags::NoInfs > llvm::PatternMatch::m_NoInfs ( const T & SubPattern )

inline

Definition at line 125 of file PatternMatch.h.

References T.

◆ m_NoNaNs()

template<typename T>

AllowFmf_match< T, FastMathFlags::NoNaNs > llvm::PatternMatch::m_NoNaNs ( const T & SubPattern )

inline

Definition at line 120 of file PatternMatch.h.

References T.

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

Referenced by llvm::InstCombinerImpl::foldICmpBinOp(), foldICmpWithLowBitMaskedVal(), getBinOpsForFactorization(), instCombineSVESrshl(), isImpliedCondICmps(), llvm::InstCombinerImpl::OptimizePointerDifference(), and llvm::InstCombinerImpl::visitSDiv().

◆ m_NonNegative() [2/2]

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

inline

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

Referenced by isImpliedCondICmps().

◆ m_NonPositive() [2/2]

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

inline

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

◆ m_NonZeroInt()

cst_pred_ty< is_non_zero_int > llvm::PatternMatch::m_NonZeroInt ( )

inline

Match a non-zero integer or a vector with all non-zero elements.

For vectors, this includes constants with undefined elements.

Definition at line 595 of file PatternMatch.h.

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

◆ m_NonZeroNotDenormalFP()

cstfp_pred_ty< is_non_zero_not_denormal_fp > llvm::PatternMatch::m_NonZeroNotDenormalFP ( )

inline

Match a floating-point non-zero that is not a denormal.

For vectors, this includes constants with undefined elements.

Definition at line 832 of file PatternMatch.h.

Referenced by hasNonZeroFPOperands().

◆ m_NoSignedZeros()

template<typename T>

AllowFmf_match< T, FastMathFlags::NoSignedZeros > llvm::PatternMatch::m_NoSignedZeros ( const T & SubPattern )

inline

Definition at line 131 of file PatternMatch.h.

References T.

◆ m_Not()

template<typename ValTy>

BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > llvm::PatternMatch::m_Not ( const ValTy & V )

inline

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

NOTE: we first match the 'Not' (by matching '-1'), and only then match the inner matcher!

Definition at line 2688 of file PatternMatch.h.

References m_AllOnes(), and m_c_Xor().

Referenced by llvm::InstCombiner::canFreelyInvertAllUsersOf(), and llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match().

◆ m_NotForbidPoison()

template<typename ValTy>

BinaryOp_match< cst_pred_ty< is_all_ones, false >, ValTy, Instruction::Xor, true > llvm::PatternMatch::m_NotForbidPoison ( const ValTy & V )

inline

Definition at line 2695 of file PatternMatch.h.

References m_AllOnesForbidPoison(), and m_c_Xor().

Referenced by canonicalizeSaturatedAddUnsigned().

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

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

Referenced by llvm::InstCombinerImpl::foldAddLikeCommutative(), foldSelectICmpMinMax(), foldURemOfLoopIncrement(), isTruePredicate(), m_NSWAddLike(), trySimplifyICmpWithAdds(), and llvm::InstCombinerImpl::visitSub().

◆ m_NSWAddLike()

template<typename LHS, typename RHS>

match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > llvm::PatternMatch::m_NSWAddLike	(	const LHS &	L,
		const RHS &	R )

inline

Match either "add nsw" or "or disjoint".

Definition at line 1581 of file PatternMatch.h.

References LHS, llvm::PatternMatchHelpers::m_CombineOr(), m_DisjointOr(), m_NSWAdd(), and RHS.

Referenced by canonicalizeMaskForVLPredicate(), llvm::InstCombinerImpl::commonIDivTransforms(), foldNoWrapAdd(), hoistAdd(), isTruePredicate(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), and llvm::InstCombinerImpl::visitSub().

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

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

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), matchSelectPattern(), simplifyDiv(), simplifyICmpWithConstant(), simplifyRem(), llvm::InstCombinerImpl::visitAShr(), and llvm::InstCombinerImpl::visitLShr().

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

References m_NSWSub(), and m_ZeroInt().

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

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

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

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::foldICmpCommutative(), foldICmpEqualityWithOffset(), matchSelectPattern(), optimizeShiftInOrChain(), simplifyAShrInst(), simplifyRem(), llvm::InstCombinerImpl::visitAShr(), and llvm::InstCombinerImpl::visitSDiv().

◆ m_NSWSub()

template<typename LHS, typename RHS>

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

inline

◆ m_NSWTrunc()

template<typename OpTy>

NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap > llvm::PatternMatch::m_NSWTrunc ( const OpTy & Op )

inline

Matches trunc nsw.

Definition at line 2292 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpTruncWithTruncOrExt(), and llvm::InstCombinerImpl::visitSExt().

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

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

Referenced by llvm::findValuesAffectedByCondition(), llvm::InstCombinerImpl::foldAddLikeCommutative(), llvm::InstCombinerImpl::foldICmpBinOpEqualityWithConstant(), foldSelectICmpMinMax(), isKnownNonZeroFromOperator(), m_NUWAddLike(), and llvm::InstCombinerImpl::visitICmpInst().

◆ m_NUWAddLike()

template<typename LHS, typename RHS>

match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > llvm::PatternMatch::m_NUWAddLike	(	const LHS &	L,
		const RHS &	R )

inline

Match either "add nuw" or "or disjoint".

Definition at line 1591 of file PatternMatch.h.

References LHS, llvm::PatternMatchHelpers::m_CombineOr(), m_DisjointOr(), m_NUWAdd(), and RHS.

Referenced by canonicalizeGEPOfConstGEPI8(), canonicalizeMaskForVLPredicate(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::commonShiftTransforms(), foldNoWrapAdd(), hoistAdd(), isTruePredicate(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), and llvm::InstCombinerImpl::visitSub().

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

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

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::findValuesAffectedByCondition(), getRangeForNUWMulSquare(), getUnsignedMonotonicValues(), isMultipleOfN(), simplifyDiv(), simplifyICmpWithConstant(), simplifyRem(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitICmpInst(), 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 1510 of file PatternMatch.h.

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

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), foldCttzCtlz(), llvm::InstCombinerImpl::foldICmpCommutative(), foldICmpEqualityWithOffset(), foldICmpShlLHSC(), optimizeShiftInOrChain(), simplifyAndInst(), simplifyLShrInst(), simplifyRem(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitLShr().

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

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

Referenced by llvm::InstCombinerImpl::commonShiftTransforms(), computeKnownBitsFromCmp(), computeKnownBitsFromLerpPattern(), llvm::computeOverflowForUnsignedSub(), llvm::findValuesAffectedByCondition(), llvm::InstCombinerImpl::foldAddLikeCommutative(), llvm::slpvectorizer::getScalarMaxValue(), hoistSub(), simplifyXorInst(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitLShr().

◆ m_NUWTrunc()

template<typename OpTy>

NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap > llvm::PatternMatch::m_NUWTrunc ( const OpTy & Op )

inline

Matches trunc nuw.

Definition at line 2285 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpTruncWithTruncOrExt(), llvm::PredicateBase::getConstraint(), llvm::PatternMatch::ICmpLike_match< LHS_t, RHS_t >::match(), and llvm::InstCombinerImpl::visitZExt().

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

◆ m_OneUse()

template<typename T>

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

inline

Definition at line 79 of file PatternMatch.h.

References T.

Referenced by llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match().

◆ m_Or()

template<typename LHS, typename RHS>

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

inline

Definition at line 1337 of file PatternMatch.h.

References LHS, and RHS.

◆ m_OrdFMax()

template<typename LHS, typename RHS>

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

References LHS, and RHS.

◆ m_OrdFMin()

template<typename LHS, typename RHS>

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

References LHS, and RHS.

◆ m_OrdOrUnordFMax()

template<typename LHS, typename RHS>

match_combine_or< FMaxMin_match< LHS, RHS, ofmax_pred_ty >, FMaxMin_match< LHS, RHS, ufmax_pred_ty > > llvm::PatternMatch::m_OrdOrUnordFMax	(	const LHS &	L,
		const RHS &	R )

inline

Match an 'ordered' or '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.

Definition at line 2665 of file PatternMatch.h.

References LHS, llvm::PatternMatchHelpers::m_CombineOr(), and RHS.

Referenced by getMinMaxRecurrence(), and matchFastFloatClamp().

◆ m_OrdOrUnordFMin()

template<typename LHS, typename RHS>

match_combine_or< FMaxMin_match< LHS, RHS, ofmin_pred_ty >, FMaxMin_match< LHS, RHS, ufmin_pred_ty > > llvm::PatternMatch::m_OrdOrUnordFMin	(	const LHS &	L,
		const RHS &	R )

inline

Match an 'ordered' or '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.

Definition at line 2678 of file PatternMatch.h.

References LHS, llvm::PatternMatchHelpers::m_CombineOr(), and RHS.

Referenced by getMinMaxRecurrence(), and matchFastFloatClamp().

◆ m_Phi()

match_bind< PHINode > llvm::PatternMatch::m_Phi ( PHINode *& PN )

inline

Match a PHI node, capturing it if we match.

Definition at line 894 of file PatternMatch.h.

Referenced by isRemOfLoopIncrementWithLoopInvariant(), and llvm::matchSimpleRecurrence().

◆ m_Poison()

auto llvm::PatternMatch::m_Poison ( )

inline

Match an arbitrary poison constant.

Definition at line 174 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

Referenced by canonicalizeInsertSplat(), canSkipDemandedEltsInInsertChain(), collectInsertionElements(), collectShuffleElements(), collectSingleShuffleElements(), llvm::InstCombinerImpl::commonCastTransforms(), foldIdentityExtractShuffle(), foldInsEltIntoIdentityShuffle(), foldInsSequenceIntoSplat(), llvm::InstCombinerImpl::foldShuffledIntrinsicOperands(), foldSpliceBinOp(), foldTruncShuffle(), llvm::InstCombinerImpl::foldVectorBinop(), llvm::RISCVTTIImpl::instCombineIntrinsic(), m_AllOnesOrPoison(), m_ZeroOrPoison(), narrowVectorSelect(), llvm::VPlanTransforms::optimizeEVLMasks(), performANDORDUPNOTCombine(), shrinkFPConstantVector(), shrinkInsertElt(), shrinkSplatShuffle(), llvm::InstCombinerImpl::simplifyBinOpSplats(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), llvm::simplifyIntrinsic(), llvm::InstCombinerImpl::visitBitCast(), llvm::InstCombinerImpl::visitFNeg(), and llvm::InstCombinerImpl::visitShuffleVectorInst().

◆ m_PosInf()

cstfp_pred_ty< is_signed_inf< false > > llvm::PatternMatch::m_PosInf ( )

inline

Match a positive infinity FP constant.

For vectors, this includes constants with undefined elements.

Definition at line 747 of file PatternMatch.h.

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

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

◆ m_Power2() [2/2]

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

inline

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

Referenced by llvm::isKnownToBeAPowerOfTwo().

◆ m_Power2OrZero() [2/2]

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

inline

Definition at line 653 of file PatternMatch.h.

◆ m_PtrAdd()

template<typename PointerOpTy, typename OffsetOpTy>

PtrAdd_match< PointerOpTy, OffsetOpTy > llvm::PatternMatch::m_PtrAdd	(	const PointerOpTy &	PointerOp,
		const OffsetOpTy &	OffsetOp )

inline

Matches GEP with i8 source element type.

Definition at line 2128 of file PatternMatch.h.

Referenced by canonicalizeGEPOfConstGEPI8(), foldExtractOfStridedPointerVector(), llvm::ConditionalInductionDescriptor::isConditionalInductionPHI(), simplifyCastInst(), llvm::InstCombinerImpl::SimplifyDemandedUseBits(), and llvm::InstCombinerImpl::visitCallInst().

◆ m_PtrToAddr()

template<typename OpTy>

CastOperator_match< OpTy, Instruction::PtrToAddr > llvm::PatternMatch::m_PtrToAddr ( const OpTy & Op )

inline

Matches PtrToAddr.

Definition at line 2253 of file PatternMatch.h.

Referenced by llvm::vputils::getSCEVExprForVPValue(), m_PtrToIntOrAddr(), and llvm::InstCombinerImpl::visitSub().

◆ m_PtrToInt()

template<typename OpTy>

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

inline

Matches PtrToInt.

Definition at line 2240 of file PatternMatch.h.

Referenced by llvm::InstCombinerImpl::foldICmpOrConstant(), isKnownNonZeroFromAssume(), m_PtrToIntOrAddr(), simplifyGEPInst(), and llvm::InstCombinerImpl::visitSub().

◆ m_PtrToIntOrAddr()

template<typename OpTy>

auto llvm::PatternMatch::m_PtrToIntOrAddr ( const OpTy & Op )

inline

Matches PtrToInt or PtrToAddr.

Definition at line 2258 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_PtrToAddr(), and m_PtrToInt().

Referenced by addValueAffectedByCondition(), isImpliedCondICmps(), simplifyBinaryIntrinsic(), simplifyCastInst(), simplifyGEPInst(), simplifySubInst(), tryToImproveAlign(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), and llvm::InstCombinerImpl::visitSub().

◆ m_PtrToIntSameSize()

template<typename OpTy>

PtrToIntSameSize_match< OpTy > llvm::PatternMatch::m_PtrToIntSameSize	(	const DataLayout &	DL,
		const OpTy &	Op )

inline

Definition at line 2245 of file PatternMatch.h.

References DL.

Referenced by computeKnownBitsFromCmp(), isKnownNonEqual(), llvm::InstCombinerImpl::visitIntToPtr(), 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 1301 of file PatternMatch.h.

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::foldAddLikeCommutative(), foldAddToAshr(), llvm::InstCombinerImpl::foldICmpCommutative(), llvm::InstCombinerImpl::FoldShiftByConstant(), llvm::vputils::getSCEVExprForVPValue(), MatchDiv(), simplifyDivRem(), simplifyGEPInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitMul(), 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 1963 of file PatternMatch.h.

References C(), Cond, LHS, and RHS.

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

References C(), Cond, m_ConstantInt(), and m_Select().

◆ m_SelectLike()

template<typename CondTy, typename LTy, typename RTy>

SelectLike_match< CondTy, LTy, RTy > llvm::PatternMatch::m_SelectLike	(	const CondTy &	C,
		const LTy &	TrueC,
		const RTy &	FalseC )

inline

Matches a value that behaves like a boolean-controlled select, i.e.

one of: select i1 Cond, TrueC, FalseC zext i1 Cond (equivalent to select i1 Cond, 1, 0) sext i1 Cond (equivalent to select i1 Cond, -1, 0)

The condition is matched against Cond, and the true/false constants against TrueC and FalseC respectively. For zext/sext, the synthetic constants are bound to TrueC and FalseC via their matchers.

Definition at line 2430 of file PatternMatch.h.

References C().

Referenced by combineRecipe(), llvm::InstCombinerImpl::foldBinOpOfSelectAndCastOfSelectCondition(), llvm::InstCombinerImpl::foldICmpBinOpWithConstantViaTruthTable(), foldSelectWithIdentityConstant(), llvm::VPlanTransforms::handleFindLastReductions(), llvm::VPlanTransforms::optimizeFindIVReductions(), optimizeMaskToEVL(), performNanGuardFpToSatCombine(), takeInexpensiveLog2(), and tryToFoldExtendSelectLoad().

◆ m_SExt()

template<typename OpTy>

CastInst_match< OpTy, SExtInst > llvm::PatternMatch::m_SExt ( const OpTy & Op )

inline

Matches SExt.

Definition at line 2304 of file PatternMatch.h.

◆ m_SExtLike()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, SExtInst >, NNegZExt_match< OpTy > > llvm::PatternMatch::m_SExtLike ( const OpTy & Op )

inline

Match either "sext" or "zext nneg".

Definition at line 2334 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_NNegZExt(), and m_SExt().

Referenced by foldLogicCastConstant(), foldNoWrapAdd(), llvm::InstCombiner::getFreelyInvertedImpl(), llvm::InstCombinerImpl::visitGetElementPtrInst(), and llvm::InstCombinerImpl::visitSub().

◆ m_SExtOrSelf()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, SExtInst >, OpTy > llvm::PatternMatch::m_SExtOrSelf ( const OpTy & Op )

inline

Definition at line 2327 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), and m_SExt().

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), matchOrConcat(), llvm::InstCombinerImpl::simplifyRangeCheck(), 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 1680 of file PatternMatch.h.

References LHS, and RHS.

Referenced by detectShiftUntilZeroIdiom(), dropRedundantMaskingOfLeftShiftInput(), llvm::findValuesAffectedByCondition(), llvm::InstCombinerImpl::foldBinOpShiftWithShift(), foldCttzCtlz(), llvm::AArch64TTIImpl::isProfitableToSinkOperands(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), and llvm::InstCombinerImpl::visitZExt().

◆ m_ShiftedMask()

cst_pred_ty< is_shifted_mask > llvm::PatternMatch::m_ShiftedMask ( )

inline

Definition at line 500 of file PatternMatch.h.

Referenced by foldNegativePower2AndShiftedMask().

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

References LHS, and RHS.

◆ m_ShlOrSelf()

template<typename LHS>

ShiftLike_match< LHS, Instruction::Shl > llvm::PatternMatch::m_ShlOrSelf	(	const LHS &	L,
		uint64_t &	R )

inline

Matches shl L, ConstShAmt or L itself (R will be set to zero in this case).

Definition at line 1386 of file PatternMatch.h.

References LHS, and uint64_t.

Referenced by foldLoadsRecursive(), and matchSubIntegerPackFromVector().

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

References LHS, and RHS.

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

Referenced by areExtractShuffleVectors(), combineConcatVectorOfShuffles(), llvm::InstCombinerImpl::commonCastTransforms(), llvm::InstCombinerImpl::foldICmpBitCast(), foldIdentityExtractShuffle(), llvm::InstCombinerImpl::foldShuffledIntrinsicOperands(), llvm::InstCombinerImpl::foldVectorBinop(), foldVectorCmp(), llvm::getSplatValue(), llvm::X86TTIImpl::instCombineIntrinsic(), llvm::AArch64TTIImpl::isProfitableToSinkOperands(), llvm::ARMTTIImpl::isProfitableToSinkOperands(), llvm::RISCVTTIImpl::isProfitableToSinkOperands(), llvm::WebAssemblyTTIImpl::isProfitableToSinkOperands(), llvm::X86TTIImpl::isProfitableToSinkOperands(), matchSubIntegerPackFromVector(), narrowVectorSelect(), performANDORDUPNOTCombine(), shrinkSplatShuffle(), llvm::InstCombinerImpl::simplifyBinOpSplats(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), simplifyReductionOperand(), and llvm::InstCombinerImpl::visitFNeg().

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

References mask().

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

Referenced by canonicalizeSaturatedAddSigned(), canonicalizeSaturatedSubtractSigned(), foldCopySignIdioms(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::isKnownToBeAPowerOfTwo(), isPowerOfTwoRecurrence(), simplifyAddInst(), simplifyICmpWithBinOp(), llvm::InstCombinerImpl::visitAnd(), llvm::InstCombinerImpl::visitOr(), llvm::InstCombinerImpl::visitSDiv(), and llvm::InstCombinerImpl::visitXor().

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

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

◆ m_SIToFP()

template<typename OpTy>

CastInst_match< OpTy, SIToFPInst > llvm::PatternMatch::m_SIToFP ( const OpTy & Op )

inline

Definition at line 2440 of file PatternMatch.h.

Referenced by foldFCmpFAbsFSubIntToFP(), foldFPtoI(), llvm::InstCombinerImpl::foldICmpBitCast(), and m_IToFP().

◆ m_SMax()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_SMax	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2894 of file PatternMatch.h.

References m_Intrinsic().

Referenced by detectSSatPattern(), detectSSatSPattern(), detectSSatUPattern(), detectUSatPattern(), foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldICmpWithClamp(), FoldOrOfSelectSmaxToAbs(), getMinMaxRecurrence(), m_MaxOrMin(), matchClamp(), simplifyICmpWithMinMax(), tryToFPToSat(), llvm::InstCombinerImpl::visitCallInst(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_SMin()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_SMin	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2899 of file PatternMatch.h.

References m_Intrinsic().

Referenced by detectSSatPattern(), detectSSatSPattern(), detectSSatUPattern(), detectUSatPattern(), foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldICmpWithZero(), getMinMaxRecurrence(), m_MaxOrMin(), matchClamp(), simplifyICmpWithMinMax(), tryToFPToSat(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_Specific()

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

inline

Match if we have a specific specified value.

Definition at line 973 of file PatternMatch.h.

◆ m_SpecificBB()

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

inline

Match a specific basic block value.

Definition at line 1095 of file PatternMatch.h.

Referenced by foldGuardedFunnelShift().

◆ m_SpecificCmp()

template<typename LHS, typename RHS>

SpecificCmpClass_match< LHS, RHS, CmpInst > llvm::PatternMatch::m_SpecificCmp	(	CmpPredicate	MatchPred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 1846 of file PatternMatch.h.

References LHS, and RHS.

Referenced by combineRecipe(), llvm::VPlanTransforms::convertEVLExitCond(), and foldOrUnsignedUMulOverflowICmp().

◆ m_SpecificFCmp()

template<typename LHS, typename RHS>

SpecificCmpClass_match< LHS, RHS, FCmpInst > llvm::PatternMatch::m_SpecificFCmp	(	CmpPredicate	MatchPred,
		const LHS &	L,
		const RHS &	R )

inline

Definition at line 1864 of file PatternMatch.h.

References LHS, and RHS.

Referenced by reassociateFCmps().

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

Referenced by convertFSqrtDivIntoFMul(), llvm::InstCombinerImpl::foldFMulReassoc(), foldMulSelectToNegate(), llvm::InstCombinerImpl::foldSquareSumFP(), getFSqrtDivOptPattern(), m_FPOne(), simplifyUnaryIntrinsic(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFDiv(), and llvm::InstCombinerImpl::visitFMul().

◆ m_SpecificICmp()

template<typename LHS, typename RHS>

SpecificCmpClass_match< LHS, RHS, ICmpInst > llvm::PatternMatch::m_SpecificICmp	(	CmpPredicate	MatchPred,
		const LHS &	L,
		const RHS &	R )

inline

◆ m_SpecificInt() [1/2]

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

inline

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

Definition at line 1062 of file PatternMatch.h.

◆ m_SpecificInt() [2/2]

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

inline

Definition at line 1066 of file PatternMatch.h.

References uint64_t.

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

References P.

Referenced by canNarrowShiftAmt(), llvm::InstCombinerImpl::convertOrOfShiftsToFunnelShift(), foldSelectICmpLshrAshr(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), foldShiftOfShiftedBinOp(), llvm::InstCombinerImpl::foldSignBitTest(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::InstCombinerImpl::visitAnd(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_SpecificInt_ICMP_ForbidPoison()

cst_pred_ty< icmp_pred_with_threshold, false > llvm::PatternMatch::m_SpecificInt_ICMP_ForbidPoison	(	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 708 of file PatternMatch.h.

References P.

Referenced by foldSelectICmpAndAnd().

◆ m_SpecificIntAllowPoison() [1/2]

specific_intval< true > llvm::PatternMatch::m_SpecificIntAllowPoison ( const APInt & V )

inline

Definition at line 1070 of file PatternMatch.h.

◆ m_SpecificIntAllowPoison() [2/2]

specific_intval64< true > llvm::PatternMatch::m_SpecificIntAllowPoison ( uint64_t V )

inline

Definition at line 1074 of file PatternMatch.h.

References uint64_t.

◆ m_SpecificType() [1/4]

auto llvm::PatternMatch::m_SpecificType ( Type * RefTy )

inline

Definition at line 1129 of file PatternMatch.h.

References m_SpecificType(), and m_Value().

◆ m_SpecificType() [2/4]

template<typename Pattern>

auto llvm::PatternMatch::m_SpecificType	(	Type *	RefTy,
		const Pattern &	P )

inline

Match a value of a specific type.

Definition at line 1126 of file PatternMatch.h.

References P, and SpecificType_match().

Referenced by m_SpecificType(), m_SpecificType(), and m_SpecificType().

◆ m_SpecificType() [3/4]

auto llvm::PatternMatch::m_SpecificType	(	Type *	RefTy,
		const Value *&	V )

inline

Definition at line 1137 of file PatternMatch.h.

References m_SpecificType(), and m_Value().

◆ m_SpecificType() [4/4]

auto llvm::PatternMatch::m_SpecificType	(	Type *	RefTy,
		Value *&	V )

inline

Match a value of a specific type, capturing it if we match.

Definition at line 1134 of file PatternMatch.h.

References m_SpecificType(), and m_Value().

◆ m_Splat()

template<typename T>

Splat_match< T > llvm::PatternMatch::m_Splat ( const T & SubPattern )

inline

Match a vector splat.

May be a constant splat or a shufflevector of the first element.

Definition at line 242 of file PatternMatch.h.

References T.

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

◆ m_Sqrt()

template<typename Opnd0>

auto llvm::PatternMatch::m_Sqrt ( const Opnd0 & Op0 )

inline

Definition at line 2969 of file PatternMatch.h.

References m_Intrinsic().

Referenced by llvm::InstCombinerImpl::foldFMulReassoc(), foldSqrtWithFcmpZero(), getFSqrtDivOptPattern(), and simplifyFMAFMul().

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

References LHS, and RHS.

Referenced by llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::commonShiftTransforms(), llvm::computeOverflowForSignedSub(), llvm::vputils::getSCEVExprForVPValue(), isDivZero(), MatchRem(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitGetElementPtrInst(), 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 2114 of file PatternMatch.h.

Referenced by computeShapeInfoForInst(), and llvm::findHistogram().

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

Referenced by canonicalizeSaturatedAddSigned(), matchSelectPattern(), and llvm::InstCombinerImpl::visitCallInst().

◆ m_StrictlyPositive() [2/2]

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

inline

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

References LHS, and RHS.

◆ m_Trunc()

template<typename OpTy>

CastInst_match< OpTy, TruncInst > llvm::PatternMatch::m_Trunc ( const OpTy & Op )

inline

Matches Trunc.

Definition at line 2278 of file PatternMatch.h.

◆ m_TruncOrSelf()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy > llvm::PatternMatch::m_TruncOrSelf ( const OpTy & Op )

inline

Definition at line 2298 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), and m_Trunc().

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), llvm::InstCombinerImpl::foldSignBitTest(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), llvm::VPlanTransforms::handleMultiUseReductions(), LowerAndToBT(), optimizeMaskToEVL(), PerformSELECTShiftCombine(), llvm::InstCombinerImpl::visitAdd(), 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 2769 of file PatternMatch.h.

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

References LHS, and RHS.

Referenced by combineRecipe(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::InstCombinerImpl::foldDivCeil(), llvm::InstCombinerImpl::foldICmpCommutative(), llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(), llvm::vputils::getSCEVExprForVPValue(), isTruePredicate(), MatchDiv(), processUse(), simplifyDivRem(), simplifyICmpWithBinOpOnLHS(), llvm::InstCombinerImpl::visitGetElementPtrInst(), llvm::InstCombinerImpl::visitMul(), and llvm::InstCombinerImpl::visitUDiv().

◆ m_UIToFP()

template<typename OpTy>

CastInst_match< OpTy, UIToFPInst > llvm::PatternMatch::m_UIToFP ( const OpTy & Op )

inline

Definition at line 2435 of file PatternMatch.h.

Referenced by foldFCmpFAbsFSubIntToFP(), foldFPtoI(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::AArch64TargetLowering::lowerInterleavedLoad(), m_IToFP(), simplifyICmpWithConstant(), and llvm::InstCombinerImpl::visitFMul().

◆ m_UMax()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_UMax	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2904 of file PatternMatch.h.

References m_Intrinsic().

Referenced by combineBasicSADPattern(), llvm::InstCombinerImpl::foldAddWithConstant(), foldClampRangeOfTwo(), llvm::InstCombinerImpl::foldICmpWithClamp(), getMinMaxRecurrence(), m_MaxOrMin(), matchClamp(), simplifyICmpWithMinMax(), and llvm::InstCombinerImpl::visitICmpInst().

◆ m_UMin()

template<typename Opnd0, typename Opnd1>

auto llvm::PatternMatch::m_UMin	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1 )

inline

Definition at line 2909 of file PatternMatch.h.

References m_Intrinsic().

Referenced by combineBasicSADPattern(), combineShiftRightArithmetic(), detectSSatUPattern(), detectUSatPattern(), detectUSatUPattern(), foldClampRangeOfTwo(), foldSubOfMinMax(), foldToUnsignedSaturatedAdd(), getMinMaxRecurrence(), m_MaxOrMin(), matchClamp(), processUse(), simplifyICmpWithMinMax(), simplifySwitchWhenUMin(), and llvm::InstCombinerImpl::visitTrunc().

◆ m_UnconditionalBr()

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

inline

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

Referenced by areExtractShuffleVectors(), combineOr(), combineTargetShuffle(), llvm::ConstantFoldBinaryInstruction(), evaluateInDifferentElementOrder(), llvm::InstCombinerImpl::foldICmpBitCast(), foldIdentityPaddedShuffles(), foldInsEltIntoSplat(), llvm::InstCombinerImpl::foldSelectShuffle(), foldSelectZeroOrFixedOp(), foldTruncInsEltPair(), llvm::InstCombinerImpl::foldVectorBinop(), foldVectorCmp(), slpvectorizer::BoUpSLP::LookAheadHeuristics::getShallowScore(), llvm::X86TTIImpl::instCombineIntrinsic(), llvm::ARMTTIImpl::isProfitableToSinkOperands(), llvm::SimplifyQuery::isUndefValue(), likeBitCastFromVector(), markAliveBlocks(), llvm::Constant::mergeUndefsWith(), llvm::RISCVTargetLowering::PerformDAGCombine(), performPredicateLoadCombine(), llvm::Constant::replaceUndefsWith(), llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), simplifyReductionOperand(), llvm::InstCombinerImpl::visitCallInst(), llvm::InstCombinerImpl::visitFreeze(), llvm::InstCombinerImpl::visitInsertElementInst(), and llvm::InstCombinerImpl::visitShuffleVectorInst().

◆ m_UndefValue() [1/2]

auto llvm::PatternMatch::m_UndefValue ( )

inline

Match an arbitrary UndefValue constant.

Definition at line 171 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

Referenced by llvm::InstCombinerImpl::commonIDivRemTransforms(), and llvm::maskContainsAllOneOrUndef().

◆ m_UndefValue() [2/2]

match_bind< UndefValue > llvm::PatternMatch::m_UndefValue ( UndefValue *& U )

inline

Match an UndefValue, capturing the value if we match.

Definition at line 897 of file PatternMatch.h.

◆ m_UnOp() [1/4]

auto llvm::PatternMatch::m_UnOp ( )

inline

Match an arbitrary unary operation and ignore it.

Definition at line 139 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

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

◆ m_UnOp() [2/4]

template<typename OP_t>

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

inline

Definition at line 1183 of file PatternMatch.h.

References X.

◆ m_UnOp() [3/4]

match_bind< const UnaryOperator > llvm::PatternMatch::m_UnOp ( const UnaryOperator *& I )

inline

Definition at line 871 of file PatternMatch.h.

References I.

◆ m_UnOp() [4/4]

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

inline

Match a unary operator, capturing it if we match.

Definition at line 870 of file PatternMatch.h.

References I.

◆ m_UnordFMax()

template<typename LHS, typename RHS>

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

References LHS, and RHS.

◆ m_UnordFMin()

template<typename LHS, typename RHS>

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

References LHS, and RHS.

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

References LHS, and RHS.

Referenced by canScalarizeAccess(), combineRecipe(), llvm::InstCombinerImpl::commonIDivTransforms(), llvm::computeOverflowForUnsignedSub(), llvm::InstCombinerImpl::foldDivCeil(), llvm::InstCombinerImpl::foldICmpBinOp(), llvm::InstCombinerImpl::foldICmpSubConstant(), llvm::InstCombinerImpl::foldICmpWithZero(), llvm::vputils::getSCEVExprForVPValue(), isNonEqualURem(), isRemOfLoopIncrementWithLoopInvariant(), MatchRem(), simplifyICmpWithBinOpOnLHS(), and simplifySelectWithICmpCond().

◆ m_Value() [1/5]

auto llvm::PatternMatch::m_Value ( )

inline

Match an arbitrary value and ignore it.

Definition at line 136 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_Isa().

◆ m_Value() [2/5]

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

inline

Definition at line 840 of file PatternMatch.h.

◆ m_Value() [3/5]

template<typename Pattern>

auto llvm::PatternMatch::m_Value	(	const Value *&	V,
		const Pattern &	P )

inline

Match against the nested pattern, and capture the value if we match.

Definition at line 849 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineAnd(), and P.

◆ m_Value() [4/5]

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

inline

Match a value, capturing it if we match.

Definition at line 839 of file PatternMatch.h.

◆ m_Value() [5/5]

template<typename Pattern>

auto llvm::PatternMatch::m_Value	(	Value *&	V,
		const Pattern &	P )

inline

Match against the nested pattern, and capture the value if we match.

Definition at line 843 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineAnd(), and P.

◆ m_VecReverse()

template<typename Opnd0>

auto llvm::PatternMatch::m_VecReverse ( const Opnd0 & Op0 )

inline

Definition at line 2978 of file PatternMatch.h.

References m_Intrinsic().

Referenced by llvm::InstCombinerImpl::foldReversedIntrinsicOperands(), llvm::InstCombinerImpl::foldVectorBinop(), foldVectorCmp(), simplifyReductionOperand(), simplifyUnaryIntrinsic(), and llvm::InstCombinerImpl::visitFNeg().

◆ m_VectorInsert()

template<typename Opnd0, typename Opnd1, typename Opnd2>

auto llvm::PatternMatch::m_VectorInsert	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1,
		const Opnd2 &	Op2 )

inline

Definition at line 2983 of file PatternMatch.h.

References m_Intrinsic().

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

◆ m_VScale()

auto llvm::PatternMatch::m_VScale ( )

inline

Matches a call to llvm.vscale().

Definition at line 3233 of file PatternMatch.h.

References m_Intrinsic().

Referenced by areBothVScale(), llvm::VPIntrinsic::canIgnoreVectorLengthParam(), llvm::vputils::findCanonicalIVIncrement(), llvm::SelectionDAGBuilder::getValueImpl(), llvm::isKnownToBeAPowerOfTwo(), performLastTrueTestVectorCombine(), shouldSinkVScale(), llvm::InstCombinerImpl::visitSExt(), llvm::InstCombinerImpl::visitTrunc(), and llvm::InstCombinerImpl::visitZExt().

◆ m_WithOverflowInst() [1/2]

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

inline

Definition at line 889 of file PatternMatch.h.

References I.

◆ m_WithOverflowInst() [2/2]

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

inline

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

Definition at line 885 of file PatternMatch.h.

References I.

Referenced by directlyImpliesPoison(), dominatesMergePoint(), isKnownNonZeroFromOperator(), llvm::patchReplacementInstruction(), and llvm::InstCombinerImpl::visitOr().

◆ m_Xor()

template<typename LHS, typename RHS>

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

inline

Definition at line 1343 of file PatternMatch.h.

References LHS, and RHS.

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

Referenced by m_Neg(), m_NSWNeg(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), and simplifyLdexp().

◆ m_ZeroOrPoison()

auto llvm::PatternMatch::m_ZeroOrPoison ( )

inline

Definition at line 610 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_Poison(), and m_Zero().

Referenced by llvm::simplifyIntrinsic().

◆ m_ZExt()

template<typename OpTy>

CastInst_match< OpTy, ZExtInst > llvm::PatternMatch::m_ZExt ( const OpTy & Op )

inline

Matches ZExt.

Definition at line 2310 of file PatternMatch.h.

◆ m_ZExtOrSelf()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy > llvm::PatternMatch::m_ZExtOrSelf ( const OpTy & Op )

inline

Definition at line 2321 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), and m_ZExt().

Referenced by llvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(), llvm::VPlanTransforms::convertEVLExitCond(), dropRedundantMaskingOfLeftShiftInput(), llvm::InstCombinerImpl::foldDivCeil(), foldShiftIntoShiftInAnotherHandOfAndInICmp(), llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(), matchSubIntegerPackFromVector(), performCTPOPCombine(), performLastTrueTestVectorCombine(), processUse(), llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), llvm::InstCombinerImpl::visitAdd(), and llvm::InstCombinerImpl::visitAnd().

◆ m_ZExtOrSExt()

template<typename OpTy>

match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > llvm::PatternMatch::m_ZExtOrSExt ( const OpTy & Op )

inline

Definition at line 2341 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_SExt(), and m_ZExt().

Referenced by analyzeCostOfVecReduction(), areExtractExts(), areExtractExts(), combineRecipe(), foldCmpIntrinsicOfExtended(), llvm::InstCombinerImpl::foldICmpBitCast(), llvm::InstCombinerImpl::foldICmpTruncWithTruncOrExt(), llvm::InstCombinerImpl::foldICmpUsingBoolRange(), llvm::InstCombinerImpl::foldICmpWithZextOrSext(), slpvectorizer::BoUpSLP::getTreeCost(), haveNoCommonBitsSetSpecialCases(), llvm::AArch64TTIImpl::isExtPartOfAvgExpr(), llvm::AArch64TTIImpl::isProfitableToSinkOperands(), lookThroughCast(), m_ZExtOrSExtOrSelf(), matchOpWithOpEqZero(), simplifyRecipe(), tryToMatchAndCreateExtendedReduction(), tryToMatchAndCreateMulAccumulateReduction(), llvm::InstCombinerImpl::visitAdd(), llvm::InstCombinerImpl::visitICmpInst(), llvm::InstCombinerImpl::visitMul(), and llvm::InstCombinerImpl::visitSwitchInst().

◆ m_ZExtOrSExtOrSelf()

template<typename OpTy>

match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy > llvm::PatternMatch::m_ZExtOrSExtOrSelf ( const OpTy & Op )

inline

Definition at line 2349 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), and m_ZExtOrSExt().

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

◆ m_ZExtOrTruncOrSelf()

template<typename OpTy>

auto llvm::PatternMatch::m_ZExtOrTruncOrSelf ( const OpTy & Op )

inline

Definition at line 2353 of file PatternMatch.h.

References llvm::PatternMatchHelpers::m_CombineOr(), m_Trunc(), and m_ZExt().

Referenced by llvm::vputils::findCanonicalIVIncrement(), isConditionalOnXorOfPHIs(), and isSignificantBitCheckWellFormed().

◆ match() [1/2]

template<typename Pattern>

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

Definition at line 65 of file PatternMatch.h.

References P.

◆ match() [2/2]

template<typename Val, typename Pattern>

bool llvm::PatternMatch::match	(	Val *	V,
		const Pattern &	P )

Definition at line 54 of file PatternMatch.h.

References P.

◆ match_fn()

template<typename Val = const Value, typename Pattern>

auto llvm::PatternMatch::match_fn ( const Pattern & P )

A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.

Definition at line 61 of file PatternMatch.h.

References llvm::bind_back(), and P.

Referenced by llvm::InstCombinerImpl::foldShuffledIntrinsicOperands(), llvm::vputils::getGEPFlagsForPtr(), getRecipesForUncountableExit(), llvm::isOnlyUsedInZeroComparison(), llvm::VPlanTransforms::optimizeFindIVReductions(), preparePlanForEpilogueVectorLoop(), simplifyGEPInst(), and llvm::InstCombinerImpl::visitSub().

◆ SpecificType_match()

template<typename Pattern>

llvm::PatternMatch::SpecificType_match	(	const Type *	,
		const Pattern &	) -> SpecificType_match< Pattern >

Referenced by m_SpecificType().

Classes

Typedefs

Functions

Typedef Documentation

◆ cst_pred_ty

◆ cstfp_pred_ty

Function Documentation

◆ m_Add()

◆ m_AddLike()

◆ m_AllOnes()

◆ m_AllOnesForbidPoison()

◆ m_AllOnesOrPoison()

◆ m_AllowContract()

◆ m_AllowReassoc()

◆ m_AllowReciprocal()

◆ m_And()

◆ m_AnyIntegralConstant()

◆ m_AnyIntrinsic() [1/4]

◆ m_AnyIntrinsic() [2/4]

◆ m_AnyIntrinsic() [3/4]

◆ m_AnyIntrinsic() [4/4]

◆ m_AnyZeroFP()

◆ m_APFloat()

◆ m_APFloatAllowPoison()

◆ m_APFloatForbidPoison()

◆ m_APInt()

◆ m_APIntAllowPoison()

◆ m_APIntForbidPoison()

◆ m_ApproxFunc()

◆ m_Argument()

◆ m_AShr()

◆ m_AShrOrSelf()

◆ m_BasicBlock() [1/3]

◆ m_BasicBlock() [2/3]

◆ m_BasicBlock() [3/3]

◆ m_BinOp() [1/5]

◆ m_BinOp() [2/5]

◆ m_BinOp() [3/5]

◆ m_BinOp() [4/5]

◆ m_BinOp() [5/5]

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

◆ m_c_Cmp()

◆ m_c_DisjointOr()

◆ m_c_FAdd()

◆ m_c_FMul()

◆ m_c_ICmp() [1/2]

◆ m_c_ICmp() [2/2]

◆ m_c_Intrinsic()

◆ m_c_LogicalAnd()

◆ m_c_LogicalOp()

◆ m_c_LogicalOr()

◆ m_c_MaxOrMin()

◆ m_c_Mul()

◆ m_c_NSWAdd()

◆ m_c_NUWAdd()

◆ m_c_Or()

◆ m_c_Select()

◆ m_c_SMax()

◆ m_c_SMin()

◆ m_c_SpecificICmp()

◆ m_c_UMax()

◆ m_c_UMin()

◆ m_c_Xor()

◆ m_c_XorLike()

◆ m_CastOrSelf()

◆ m_CheckedFp() [1/2]

◆ m_CheckedFp() [2/2]

◆ m_CheckedInt() [1/2]

◆ m_CheckedInt() [2/2]

◆ m_Cmp() [1/3]