Movatterモバイル変換

Classes
struct	AllowReassoc_match

struct	AnyBinaryOp_match

struct	AnyOps_match
	Matches instructions with Opcode and any number of operands.More...

struct	AnyUnaryOp_match

struct	apf_pred_ty
	This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to anAPFloat.More...

struct	apfloat_match

struct	api_pred_ty
	This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to anAPInt.More...

struct	apint_match

struct	Argument_match

struct	BinaryOp_match

struct	bind_const_intval_ty

struct	bind_ty

struct	BinOpPred_match

struct	br_match

struct	brc_match

struct	CastInst_match

struct	CastOperator_match

struct	class_match

struct	CmpClass_match

struct	constantexpr_match

struct	constantint_match

struct	cstval_pred_ty
	This helper class is used to match constant scalars, vector splats, and fixed width vectors that satisfy a specified predicate.More...

struct	custom_checkfn

struct	deferredval_ty
	Stores a reference to theValue , not theValue itself, thus can be used in commutative matchers.More...

struct	DisjointOr_match

struct	ElementWiseBitCast_match

struct	Exact_match

struct	ExtractValue_match

struct	FNeg_match

struct	icmp_pred_with_threshold

struct	InsertValue_match
	Matcher for a single index InsertValue instruction.More...

struct	IntrinsicID_match
	Intrinsic matchers.More...

struct	is_all_ones

struct	is_any_apint

struct	is_any_zero_fp

struct	is_bitwiselogic_op

struct	is_finite

struct	is_finitenonzero

struct	is_idiv_op

struct	is_inf

struct	is_irem_op

struct	is_logical_shift_op

struct	is_lowbit_mask

struct	is_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_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_strictlypositive

struct	is_zero

struct	is_zero_int

struct	LogicalOp_match

struct	m_Intrinsic_Ty
	Intrinsic matches are combinations of ID matchers, and argument matchers.More...

struct	m_Intrinsic_Ty< T0 >

struct	m_Intrinsic_Ty< T0, T1 >

struct	m_Intrinsic_Ty< T0, T1, T2 >

struct	m_Intrinsic_Ty< T0, T1, T2, T3 >

struct	m_Intrinsic_Ty< T0, T1, T2, T3, T4 >

struct	m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >

struct	m_Mask

struct	m_SpecificMask

struct	m_SplatOrPoisonMask

struct	m_ZeroMask

struct	match_combine_and

struct	match_combine_or
	Matching combinators.More...

struct	match_unless
	Inverting matcher.More...

struct	MaxMin_match

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	Shuffle_match
	Matches shuffle.More...

struct	Signum_match

struct	smax_pred_ty
	Helper class for identifying signed max predicates.More...

struct	smin_pred_ty
	Helper class for identifying signed min predicates.More...

struct	specific_bbval
	Match a specified basic block value.More...

struct	specific_fpval
	Match a specified floating point value or vector of all elements of that value.More...

struct	specific_intval
	Match a specified integer value or vector of all elements of that value.More...

struct	specific_intval64

struct	SpecificBinaryOp_match

struct	SpecificCmpClass_match

struct	specificval_ty
	Match a specified Value*.More...

struct	ThreeOps_match
	Matches instructions with Opcode and three operands.More...

struct	TwoOps_match
	Matches instructions with Opcode and three operands.More...

struct	UAddWithOverflow_match

struct	ufmax_pred_ty
	Helper class for identifying unordered max predicates.More...

struct	ufmin_pred_ty
	Helper class for identifying unordered min predicates.More...

struct	umax_pred_ty
	Helper class for identifying unsigned max predicates.More...

struct	umin_pred_ty
	Helper class for identifying unsigned min predicates.More...

struct	undef_match

struct	VScaleVal_match
	Matches patterns for`vscale`.More...

struct	XorLike_match

Typedefs
template<typenamePredicate ,bool AllowPoison = true>
using	cst_pred_ty =cstval_pred_ty<Predicate,ConstantInt, AllowPoison >
	specialization ofcstval_pred_ty forConstantInt

template<typenamePredicate >
using	cstfp_pred_ty =cstval_pred_ty<Predicate,ConstantFP,true >
	specialization ofcstval_pred_ty forConstantFP

Functions
template<typename Val , typenamePattern >
bool	match (Val *V,const Pattern &P)

template<typenamePattern >
bool	match (ArrayRef< int > Mask,const Pattern &P)

template<typenameT >
OneUse_match<T >	m_OneUse (const T &SubPattern)

template<typenameT >
AllowReassoc_match<T >	m_AllowReassoc (const T &SubPattern)

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

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

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

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

auto	m_Undef ()
	Match an arbitrary undef constant.

class_match<UndefValue >	m_UndefValue ()
	Match an arbitraryUndefValue constant.

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

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

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

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

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

class_match<BasicBlock >	m_BasicBlock ()
	Match an arbitrary basic block value and ignore it.

template<typename Ty >
match_unless< Ty >	m_Unless (const Ty &M)
	Match if the inner matcher doesNOT match.

template<typename LTy , typename RTy >
match_combine_or< LTy, RTy >	m_CombineOr (const LTy &L,const RTy &R)
	Combine two pattern matchers matching L \|\| R.

template<typename LTy , typename RTy >
match_combine_and< LTy, RTy >	m_CombineAnd (const LTy &L,const RTy &R)
	Combine two pattern matchers matching L && R.

apint_match	m_APInt (const APInt *&Res)
	Match aConstantInt or splattedConstantVector, binding the specified pointer to the containedAPInt.

apint_match	m_APIntAllowPoison (const APInt *&Res)
	MatchAPInt while allowing poison in splat vector constants.

apint_match	m_APIntForbidPoison (const APInt *&Res)
	MatchAPInt while forbidding poison in splat vector constants.

apfloat_match	m_APFloat (const APFloat *&Res)
	Match aConstantFP or splattedConstantVector, binding the specified pointer to the containedAPFloat.

apfloat_match	m_APFloatAllowPoison (const APFloat *&Res)
	MatchAPFloat while allowing poison in splat vector constants.

apfloat_match	m_APFloatForbidPoison (const APFloat *&Res)
	MatchAPFloat while forbidding poison in splat vector constants.

template<int64_t Val>
constantint_match< Val >	m_ConstantInt ()
	Match aConstantInt 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 ()

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.

is_zero	m_Zero ()
	Match any null constant or a vector with all elements equal to 0.

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.

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

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

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

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

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

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

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

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

bind_ty<UndefValue >	m_UndefValue (UndefValue *&U)
	Match anUndefValue, capturing the value if we match.

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

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

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

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

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

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

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

match_combine_and<bind_ty<Constant >,match_unless<constantexpr_match > >	m_ImmConstant (Constant *&C)
	Match an immediateConstant, capturing the value if we match.

specificval_ty	m_Specific (const Value *V)
	Match if we have a specific specified value.

deferredval_ty<Value >	m_Deferred (Value *const &V)
	Likem_Specific(), but works if the specific value to match is determined as part of the samematch() expression.

deferredval_ty<const Value >	m_Deferred (const Value *const &V)

specific_fpval	m_SpecificFP (double V)
	Match a specific floating point value or vector with all elements equal to the value.

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 aConstantInt and bind to its value.

specific_bbval	m_SpecificBB (BasicBlock *BB)
	Match a specific basic block value.

deferredval_ty<BasicBlock >	m_Deferred (BasicBlock *const &BB)
	A commutative-friendly version ofm_Specific().

deferredval_ty<const BasicBlock >	m_Deferred (const BasicBlock *const &BB)

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::Add >	m_Add (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::FAdd >	m_FAdd (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::Sub >	m_Sub (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
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<typenameRHS >
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<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::Mul >	m_Mul (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::FMul >	m_FMul (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::UDiv >	m_UDiv (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::SDiv >	m_SDiv (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::FDiv >	m_FDiv (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::URem >	m_URem (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::SRem >	m_SRem (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::FRem >	m_FRem (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::And >	m_And (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::Or >	m_Or (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::Xor >	m_Xor (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::Shl >	m_Shl (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::LShr >	m_LShr (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
BinaryOp_match<LHS,RHS, Instruction::AShr >	m_AShr (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
OverflowingBinaryOp_match<LHS,RHS, Instruction::Add,OverflowingBinaryOperator::NoSignedWrap >	m_NSWAdd (const LHS &L,const RHS &R)

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

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

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

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

template<typenameLHS , typenameRHS >
OverflowingBinaryOp_match<LHS,RHS, Instruction::Add,OverflowingBinaryOperator::NoUnsignedWrap,true >	m_c_NUWAdd (const LHS &L,const RHS &R)

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

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

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

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

template<typenameLHS , typenameRHS >
DisjointOr_match<LHS,RHS >	m_DisjointOr (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
DisjointOr_match<LHS,RHS,true >	m_c_DisjointOr (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
BinOpPred_match<LHS,RHS,is_shift_op >	m_Shift (const LHS &L,const RHS &R)
	Matches shift operations.

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

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

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

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
BinOpPred_match<LHS,RHS,is_idiv_op >	m_IDiv (const LHS &L,const RHS &R)
	Matches integer division operations.

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

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

template<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,CmpInst >	m_Cmp (CmpPredicate &Pred,const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,ICmpInst >	m_ICmp (CmpPredicate &Pred,const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,FCmpInst >	m_FCmp (CmpPredicate &Pred,const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,CmpInst >	m_Cmp (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,ICmpInst >	m_ICmp (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,FCmpInst >	m_FCmp (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
SpecificCmpClass_match<LHS,RHS,CmpInst >	m_SpecificCmp (CmpPredicate MatchPred,const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
SpecificCmpClass_match<LHS,RHS,ICmpInst >	m_SpecificICmp (CmpPredicate MatchPred,const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
SpecificCmpClass_match<LHS,RHS,ICmpInst,true >	m_c_SpecificICmp (CmpPredicate MatchPred,const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
SpecificCmpClass_match<LHS,RHS,FCmpInst >	m_SpecificFCmp (CmpPredicate MatchPred,const LHS &L,const RHS &R)

template<typenameCond , typenameLHS , typenameRHS >
ThreeOps_match<Cond,LHS,RHS, Instruction::Select >	m_Select (const Cond &C,const LHS &L,const RHS &R)
	MatchesSelectInst.

template<int64_t L, int64_t R, typenameCond >
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<typenameLHS , typenameRHS >
ThreeOps_match< decltype(m_Value()),LHS,RHS, Instruction::Select,true >	m_c_Select (const LHS &L,const RHS &R)
	MatchSelect(C, LHS, RHS) orSelect(C, RHS, LHS)

template<typename OpTy >
OneOps_match< OpTy, Instruction::Freeze >	m_Freeze (const OpTy &Op)
	MatchesFreezeInst.

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)
	MatchesInsertElementInst.

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)
	MatchesExtractElementInst.

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)
	MatchesShuffleVectorInst 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)
	MatchesLoadInst.

template<typename ValueOpTy , typename PointerOpTy >
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store >	m_Store (const ValueOpTy &ValueOp,const PointerOpTy &PointerOp)
	MatchesStoreInst.

template<typename... OperandTypes>
auto	m_GEP (const OperandTypes &...Ops)
	MatchesGetElementPtrInst.

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::IntToPtr >	m_IntToPtr (const OpTy &Op)
	Matches IntToPtr.

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 >
CastInst_match< OpTy,UIToFPInst >	m_UIToFP (const OpTy &Op)

template<typename OpTy >
CastInst_match< OpTy,SIToFPInst >	m_SIToFP (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 >
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,bind_ty<BasicBlock >,bind_ty<BasicBlock > >	m_Br (const Cond_t &C,BasicBlock &T,BasicBlock &F)

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

template<typenameLHS , typenameRHS >
MaxMin_match<ICmpInst,LHS,RHS,smax_pred_ty >	m_SMax (const LHS &L,const RHS &R)

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

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

template<typenameLHS , typenameRHS >
MaxMin_match<ICmpInst,LHS,RHS,umin_pred_ty >	m_UMin (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
match_combine_or<match_combine_or<MaxMin_match<ICmpInst,LHS,RHS,smax_pred_ty >,MaxMin_match<ICmpInst,LHS,RHS,smin_pred_ty > >,match_combine_or<MaxMin_match<ICmpInst,LHS,RHS,umax_pred_ty >,MaxMin_match<ICmpInst,LHS,RHS,umin_pred_ty > > >	m_MaxOrMin (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
MaxMin_match<FCmpInst,LHS,RHS,ofmax_pred_ty >	m_OrdFMax (const LHS &L,const RHS &R)
	Match an 'ordered' floating point maximum function.

template<typenameLHS , typenameRHS >
MaxMin_match<FCmpInst,LHS,RHS,ofmin_pred_ty >	m_OrdFMin (const LHS &L,const RHS &R)
	Match an 'ordered' floating point minimum function.

template<typenameLHS , typenameRHS >
MaxMin_match<FCmpInst,LHS,RHS,ufmax_pred_ty >	m_UnordFMax (const LHS &L,const RHS &R)
	Match an 'unordered' floating point maximum function.

template<typenameLHS , typenameRHS >
MaxMin_match<FCmpInst,LHS,RHS,ufmin_pred_ty >	m_UnordFMin (const LHS &L,const RHS &R)
	Match an 'unordered' floating point minimum function.

template<typenameLHS , typenameRHS >
match_combine_or<MaxMin_match<FCmpInst,LHS,RHS,ofmax_pred_ty >,MaxMin_match<FCmpInst,LHS,RHS,ufmax_pred_ty > >	m_OrdOrUnordFMax (const LHS &L,const RHS &R)
	Match an 'ordered' or 'unordered' floating point maximum function.

template<typenameLHS , typenameRHS >
match_combine_or<MaxMin_match<FCmpInst,LHS,RHS,ofmin_pred_ty >,MaxMin_match<FCmpInst,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<typenameLHS_t , typenameRHS_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>
IntrinsicID_match	m_Intrinsic ()
	Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))

template<typename Opnd0 , typename Opnd1 , typename Opnd2 , typename Opnd3 >
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty	m_MaskedLoad (const Opnd0 &Op0,const Opnd1 &Op1,const Opnd2 &Op2,const Opnd3 &Op3)
	Matches MaskedLoadIntrinsic.

template<typename Opnd0 , typename Opnd1 , typename Opnd2 , typename Opnd3 >
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty	m_MaskedGather (const Opnd0 &Op0,const Opnd1 &Op1,const Opnd2 &Op2,const Opnd3 &Op3)
	Matches MaskedGatherIntrinsic.

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

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

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

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

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

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

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

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

template<typename Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty	m_FAbs (const Opnd0 &Op0)

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

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

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

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

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

template<typename Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty	m_Sqrt (const Opnd0 &Op0)

template<typename Opnd0 , typename Opnd1 >
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	m_CopySign (const Opnd0 &Op0,const Opnd1 &Op1)

template<typename Opnd0 >
m_Intrinsic_Ty< Opnd0 >::Ty	m_VecReverse (const Opnd0 &Op0)

template<typenameLHS , typenameRHS >
AnyBinaryOp_match<LHS,RHS,true >	m_c_BinOp (const LHS &L,const RHS &R)
	Matches aBinaryOperator with LHS and RHS in either order.

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
CmpClass_match<LHS,RHS,ICmpInst,true >	m_c_ICmp (const LHS &L,const RHS &R)

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
MaxMin_match<ICmpInst,LHS,RHS,smin_pred_ty,true >	m_c_SMin (const LHS &L,const RHS &R)
	Matches an SMin with LHS and RHS in either order.

template<typenameLHS , typenameRHS >
MaxMin_match<ICmpInst,LHS,RHS,smax_pred_ty,true >	m_c_SMax (const LHS &L,const RHS &R)
	Matches an SMax with LHS and RHS in either order.

template<typenameLHS , typenameRHS >
MaxMin_match<ICmpInst,LHS,RHS,umin_pred_ty,true >	m_c_UMin (const LHS &L,const RHS &R)
	Matches a UMin with LHS and RHS in either order.

template<typenameLHS , typenameRHS >
MaxMin_match<ICmpInst,LHS,RHS,umax_pred_ty,true >	m_c_UMax (const LHS &L,const RHS &R)
	Matches a UMax with LHS and RHS in either order.

template<typenameLHS , typenameRHS >
match_combine_or<match_combine_or<MaxMin_match<ICmpInst,LHS,RHS,smax_pred_ty,true >,MaxMin_match<ICmpInst,LHS,RHS,smin_pred_ty,true > >,match_combine_or<MaxMin_match<ICmpInst,LHS,RHS,umax_pred_ty,true >,MaxMin_match<ICmpInst,LHS,RHS,umin_pred_ty,true > > >	m_c_MaxOrMin (const LHS &L,const RHS &R)

template<Intrinsic::ID IntrID, typename T0 , typenameT1 >
match_combine_or< typenamem_Intrinsic_Ty< T0,T1 >::Ty, typenamem_Intrinsic_Ty<T1, T0 >::Ty >	m_c_Intrinsic (const T0 &Op0,const T1 &Op1)

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
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.

VScaleVal_match	m_VScale ()

template<typename Opnd0 , typename Opnd1 >
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	m_Interleave2 (const Opnd0 &Op0,const Opnd1 &Op1)

template<typename Opnd >
m_Intrinsic_Ty< Opnd >::Ty	m_Deinterleave2 (const Opnd &Op)

template<typenameLHS , typenameRHS >
LogicalOp_match<LHS,RHS, Instruction::And >	m_LogicalAnd (const LHS &L,const RHS &R)
	Matches L && R either in the form of L & R or L ? R : false.

auto	m_LogicalAnd ()
	Matches L && R where L and R are arbitrary values.

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS >
LogicalOp_match<LHS,RHS, Instruction::Or >	m_LogicalOr (const LHS &L,const RHS &R)
	Matches L \|\| R either in the form of L \| R or L ? true : R.

auto	m_LogicalOr ()
	Matches L \|\| R where L and R are arbitrary values.

template<typenameLHS , typenameRHS >
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<typenameLHS , typenameRHS ,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<typenameLHS , typenameRHS >
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<typenamePredicate ,bool AllowPoison = true>

usingllvm::PatternMatch::cst_pred_ty = typedefcstval_pred_ty<Predicate,ConstantInt, AllowPoison>

specialization ofcstval_pred_ty forConstantInt

Definition at line404 of filePatternMatch.h.

◆ cstfp_pred_ty

template<typenamePredicate >

usingllvm::PatternMatch::cstfp_pred_ty = typedefcstval_pred_ty<Predicate,ConstantFP,true>

specialization ofcstval_pred_ty forConstantFP

Definition at line408 of filePatternMatch.h.

Function Documentation

◆ m_Add()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1102 of filePatternMatch.h.

◆ m_AddLike()

template<typenameLHS , typenameRHS >

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 line1409 of filePatternMatch.h.

Referencesm_Add(),m_CombineOr(), andm_DisjointOr().

Referenced bycanonicalizeGEPOfConstGEPI8(),computeKnownBitsFromCmp(),llvm::findValuesAffectedByCondition(),llvm::InstCombinerImpl::foldICmpBinOp(),matchICmpOperand(),llvm::InstCombinerImpl::visitMul(), andllvm::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 line524 of filePatternMatch.h.

◆ m_AllOnesForbidPoison()

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

(

)

inline

Definition at line528 of filePatternMatch.h.

Referenced bym_NotForbidPoison().

◆ m_AllowReassoc()

template<typenameT >

AllowReassoc_match<T > llvm::PatternMatch::m_AllowReassoc

(

const T &

SubPattern

)

inline

Definition at line83 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldFMulReassoc(), andllvm::InstCombinerImpl::foldPowiReassoc().

◆ m_And()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1216 of filePatternMatch.h.

◆ m_AnyIntegralConstant()

cst_pred_ty<is_any_apint > llvm::PatternMatch::m_AnyIntegralConstant

(

)

inline

Match an integer or vector with any integral constant.

For vectors, this includes constants with undefined elements.

Definition at line507 of filePatternMatch.h.

Referenced byfoldTwoEntryPHINode().

◆ 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 line764 of filePatternMatch.h.

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

◆ m_APFloat()

apfloat_match llvm::PatternMatch::m_APFloat

(

const APFloat *&

Res

)

inline

Match aConstantFP or splattedConstantVector, binding the specified pointer to the containedAPFloat.

Definition at line316 of filePatternMatch.h.

Referenced bycomputeKnownFPClassFromCond(),factorizeFAddFSub(),foldFabsWithFcmpZero(),llvm::InstCombinerImpl::foldFCmpIntToFPConst(),foldFCmpReciprocalAndZero(),getNegatibleInsts(),isOneOrNegOne(),matchFastFloatClamp(),llvm::simplifyBinaryIntrinsic(),simplifyFCmpInst(),simplifyLdexp(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitFAdd(), andllvm::InstCombinerImpl::visitFCmpInst().

◆ m_APFloatAllowPoison()

apfloat_match llvm::PatternMatch::m_APFloatAllowPoison

(

const APFloat *&

Res

)

inline

MatchAPFloat while allowing poison in splat vector constants.

Definition at line322 of filePatternMatch.h.

Referenced byllvm::fcmpImpliesClass(),llvm::fcmpToClassTest(),simplifyFCmpInst(), andllvm::InstCombinerImpl::visitFMul().

◆ m_APFloatForbidPoison()

apfloat_match llvm::PatternMatch::m_APFloatForbidPoison

(

const APFloat *&

Res

)

inline

MatchAPFloat while forbidding poison in splat vector constants.

Definition at line327 of filePatternMatch.h.

◆ m_APInt()

apint_match llvm::PatternMatch::m_APInt

(

const APInt *&

Res

)

inline

Match aConstantInt or splattedConstantVector, binding the specified pointer to the containedAPInt.

Definition at line299 of filePatternMatch.h.

◆ m_APIntAllowPoison()

apint_match llvm::PatternMatch::m_APIntAllowPoison

(

const APInt *&

Res

)

inline

MatchAPInt while allowing poison in splat vector constants.

Definition at line305 of filePatternMatch.h.

◆ m_APIntForbidPoison()

apint_match llvm::PatternMatch::m_APIntForbidPoison

(

const APInt *&

Res

)

inline

MatchAPInt while forbidding poison in splat vector constants.

Definition at line310 of filePatternMatch.h.

◆ m_Argument()

template<unsigned OpI, typename Opnd_t >

Argument_match< Opnd_t > llvm::PatternMatch::m_Argument

(

const Opnd_t &

)

inline

Match an argument.

Definition at line2568 of filePatternMatch.h.

◆ m_AShr()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1246 of filePatternMatch.h.

◆ m_BasicBlock()[1/3]

class_match<BasicBlock > llvm::PatternMatch::m_BasicBlock

(

)

inline

Match an arbitrary basic block value and ignore it.

Definition at line189 of filePatternMatch.h.

Referenced bycollectUnswitchCandidatesWithInjections(),computeKnownBitsFromOperator(),detectShiftUntilBitTestIdiom(),detectShiftUntilZeroIdiom(),llvm::SCEVExpander::hasRelatedExistingExpansion(),llvm::isProcessableCondBI(), andm_Br().

◆ m_BasicBlock()[2/3]

bind_ty<BasicBlock > llvm::PatternMatch::m_BasicBlock

(

BasicBlock *&

)

inline

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

Definition at line856 of filePatternMatch.h.

◆ m_BasicBlock()[3/3]

bind_ty<const BasicBlock > llvm::PatternMatch::m_BasicBlock

(

const BasicBlock *&

)

inline

Definition at line857 of filePatternMatch.h.

◆ m_BinOp()[1/4]

class_match<BinaryOperator > llvm::PatternMatch::m_BinOp

(

)

inline

Match an arbitrary binary operation and ignore it.

Definition at line100 of filePatternMatch.h.

◆ m_BinOp()[2/4]

bind_ty<BinaryOperator > llvm::PatternMatch::m_BinOp

(

BinaryOperator *&

)

inline

Match a binary operator, capturing it if we match.

Definition at line830 of filePatternMatch.h.

ReferencesI.

◆ m_BinOp()[3/4]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1050 of filePatternMatch.h.

◆ m_BinOp()[4/4]

template<typenameLHS , typenameRHS >

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

inline

Matches a specific opcode.

Definition at line1369 of filePatternMatch.h.

◆ m_BitCast()

template<typename OpTy >

CastOperator_match< OpTy, Instruction::BitCast > llvm::PatternMatch::m_BitCast

(

const OpTy &

)

inline

Matches BitCast.

Definition at line2021 of filePatternMatch.h.

Referenced bycombineSCALAR_TO_VECTOR(),foldBitCastBitwiseLogic(),foldBitCastSelect(),foldIdentityExtractShuffle(),foldReductionIdiom(),foldTruncShuffle(),foldVecTruncToExtElt(),isUsedWithinShuffleVector(),llvm::InstCombinerImpl::visitBitCast(),llvm::InstCombinerImpl::visitInsertElementInst(), andllvm::InstCombinerImpl::visitShuffleVectorInst().

◆ m_BitReverse()

template<typename Opnd0 >

m_Intrinsic_Ty< Opnd0 >::Ty llvm::PatternMatch::m_BitReverse

(

const Opnd0 &

Op0

)

inline

Definition at line2692 of filePatternMatch.h.

Referenced bycollectBitParts(),foldCtpop(),foldCttzCtlz(),matchOrConcat(), andsimplifyUnaryIntrinsic().

◆ m_BitwiseLogic()

template<typenameLHS , typenameRHS >

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

inline

Matches bitwise logic operations.

Definition at line1540 of filePatternMatch.h.

Referenced byllvm::findValuesAffectedByCondition(), andfoldBitOrderCrossLogicOp().

◆ m_Br()[1/2]

template<typename Cond_t >

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

inline

Definition at line2220 of filePatternMatch.h.

Referencesllvm::CallingConv::C,F, andm_BasicBlock().

Referenced bycollectUnswitchCandidatesWithInjections(),computeKnownBitsFromOperator(),detectShiftUntilBitTestIdiom(),detectShiftUntilZeroIdiom(),foldGuardedFunnelShift(),foldICmpWithDominatingICmp(),getAppleRuntimeUnrollPreferences(),getDomPredecessorCondition(),llvm::SCEVExpander::hasRelatedExistingExpansion(),isLoopNeverExecuted(),llvm::isProcessableCondBI(), andtryToMoveFreeBeforeNullTest().

◆ 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 line2227 of filePatternMatch.h.

Referencesllvm::CallingConv::C, andF.

◆ m_BSwap()

template<typename Opnd0 >

m_Intrinsic_Ty< Opnd0 >::Ty llvm::PatternMatch::m_BSwap

(

const Opnd0 &

Op0

)

inline

Definition at line2697 of filePatternMatch.h.

Referenced bycollectBitParts(),foldCtpop(),matchOrConcat(),llvm::recognizeBSwapOrBitReverseIdiom(),simplifyUnaryIntrinsic(), andllvm::InstCombinerImpl::visitCallInst().

◆ m_c_Add()

template<typenameLHS , typenameRHS >

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 line2784 of filePatternMatch.h.

Referenced bycanonicalizeAbs(),canonicalizeSaturatedAdd(),combineAddSubWithShlAddSub(),detectShiftUntilZeroIdiom(),foldBoxMultiply(),llvm::InstCombinerImpl::foldICmpBinOp(),llvm::InstCombinerImpl::foldICmpEquality(),foldSubOfMinMax(),foldToUnsignedSaturatedAdd(),foldUnsignedUnderflowCheck(),getKnownBitsFromAndXorOr(),llvm::ARMTTIImpl::instCombineIntrinsic(),llvm::AArch64TTIImpl::isExtPartOfAvgExpr(),isImpliedCondICmps(),isTruePredicate(),matchesAdd(),shouldExpandCmpArithRMWInIR(),llvm::InstCombinerImpl::SimplifyDemandedUseBits(),simplifyICmpWithIntrinsicOnLHS(),simplifyOrInst(),tryToRecognizePopCount(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitAnd(),llvm::InstCombinerImpl::visitLShr(), andllvm::InstCombinerImpl::visitSub().

◆ m_c_And()

template<typenameLHS , typenameRHS >

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 line2798 of filePatternMatch.h.

◆ m_c_BinOp()[1/2]

template<typenameLHS , typenameRHS >

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

inline

Matches aBinaryOperator with LHS and RHS in either order.

Definition at line2757 of filePatternMatch.h.

◆ m_c_BinOp()[2/2]

template<typenameLHS , typenameRHS >

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 line2778 of filePatternMatch.h.

◆ m_c_BitwiseLogic()

template<typenameLHS , typenameRHS >

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 line1547 of filePatternMatch.h.

◆ m_c_DisjointOr()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1400 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::visitOr().

◆ m_c_FAdd()

template<typenameLHS , typenameRHS >

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 line2880 of filePatternMatch.h.

Referenced byfactorizeLerp(),simplifyFSubInst(),llvm::InstCombinerImpl::visitFAdd(), andllvm::InstCombinerImpl::visitFSub().

◆ m_c_FMul()

template<typenameLHS , typenameRHS >

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 line2887 of filePatternMatch.h.

Referenced byfactorizeFAddFSub(),factorizeLerp(),llvm::InstCombinerImpl::foldFMulReassoc(),foldMulSelectToNegate(),llvm::InstCombinerImpl::foldPowiReassoc(),simplifyFDivInst(),llvm::InstCombinerImpl::visitFAdd(),llvm::InstCombinerImpl::visitFDiv(),llvm::InstCombinerImpl::visitFMul(), andllvm::InstCombinerImpl::visitFSub().

◆ m_c_ICmp()[1/2]

template<typenameLHS , typenameRHS >

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 line2765 of filePatternMatch.h.

Referenced bycomputeKnownBitsFromOperator(),foldAndOrOfICmpsWithConstEq(),foldAndOrOfICmpsWithPow2AndWithZero(),llvm::InstCombinerImpl::foldICmpEquality(),llvm::InstCombinerImpl::foldICmpTruncWithTruncOrExt(),llvm::InstCombinerImpl::foldICmpUsingBoolRange(),foldICmpWithHighBitMask(),foldICmpWithTruncSignExtendedVal(),foldICmpXNegX(),llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(),foldUnsignedUnderflowCheck(),llvm::isKnownInversion(),isKnownNonNullFromDominatingCondition(),isKnownNonZeroFromAssume(),isKnownNonZeroFromOperator(),shouldExpandCmpArithRMWInIR(),simplifyUnsignedRangeCheck(), andllvm::InstCombinerImpl::visitAdd().

◆ m_c_ICmp()[2/2]

template<typenameLHS , typenameRHS >

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

inline

Definition at line2770 of filePatternMatch.h.

◆ m_c_Intrinsic()

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

match_combine_or< typenamem_Intrinsic_Ty< T0,T1 >::Ty, typenamem_Intrinsic_Ty<T1, T0 >::Ty > llvm::PatternMatch::m_c_Intrinsic	(	const T0 &	Op0,
		const T1 &	Op1
	)

inline

Definition at line2872 of filePatternMatch.h.

Referencesm_CombineOr().

◆ m_c_LogicalAnd()

template<typenameLHS , typenameRHS >

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 line3086 of filePatternMatch.h.

Referenced bysimplifyOrLogic(), andsimplifySelectInst().

◆ m_c_LogicalOp()

template<typenameLHS , typenameRHS >

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 line3123 of filePatternMatch.h.

ReferencesLHS,m_LogicalOp(), andRHS.

◆ m_c_LogicalOr()

template<typenameLHS , typenameRHS >

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 line3104 of filePatternMatch.h.

Referenced bysimplifyOrLogic(), andsimplifySelectInst().

◆ m_c_MaxOrMin()

template<typenameLHS , typenameRHS >

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

inline

Definition at line2864 of filePatternMatch.h.

Referencesm_c_SMax(),m_c_SMin(),m_c_UMax(),m_c_UMin(), andm_CombineOr().

Referenced byfoldMinMaxSharedOp(),reassociateMinMaxWithConstantInOperand(),simplifyCmpSelOfMaxMin(), andllvm::InstCombinerImpl::visitSub().

◆ m_c_Mul()

template<typenameLHS , typenameRHS >

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 line2791 of filePatternMatch.h.

Referenced bycheckOuterLoopInsts(),llvm::InstCombinerImpl::commonIDivTransforms(),foldBoxMultiply(),llvm::InstCombinerImpl::foldICmpBinOp(),foldIDivShl(),foldMulSelectToNegate(),llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(),foldSelectZeroOrMul(),matchExpandedRem(),llvm::AArch64TargetLowering::optimizeExtendOrTruncateConversion(),simplifyDivRem(),simplifyRecipe(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitMul().

◆ m_c_NUWAdd()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1323 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoUnsignedWrap, andRHS.

Referenced bycomputeKnownBitsFromCmp(), andisRemOfLoopIncrementWithLoopInvariant().

◆ m_c_Or()

template<typenameLHS , typenameRHS >

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 line2805 of filePatternMatch.h.

◆ m_c_Select()

template<typenameLHS , typenameRHS >

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

inline

MatchSelect(C, LHS, RHS) orSelect(C, RHS, LHS)

Definition at line1815 of filePatternMatch.h.

ReferencesLHS,m_Value(), andRHS.

Referenced byfoldTwoEntryPHINode(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitFCmpInst().

◆ m_c_SMax()

template<typenameLHS , typenameRHS >

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

inline

Matches an SMax with LHS and RHS in either order.

Definition at line2842 of filePatternMatch.h.

Referenced byisTruePredicate(),m_c_MaxOrMin(), andllvm::InstCombinerImpl::visitSub().

◆ m_c_SMin()

template<typenameLHS , typenameRHS >

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

inline

Matches an SMin with LHS and RHS in either order.

Definition at line2836 of filePatternMatch.h.

Referenced byisTruePredicate(),m_c_MaxOrMin(), andllvm::InstCombinerImpl::visitSub().

◆ m_c_SpecificICmp()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1696 of filePatternMatch.h.

◆ m_c_UMax()

template<typenameLHS , typenameRHS >

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

inline

Matches a UMax with LHS and RHS in either order.

Definition at line2854 of filePatternMatch.h.

Referenced byisTruePredicate(),m_c_MaxOrMin(), andllvm::InstCombinerImpl::visitSub().

◆ m_c_UMin()

template<typenameLHS , typenameRHS >

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

inline

Matches a UMin with LHS and RHS in either order.

Definition at line2848 of filePatternMatch.h.

Referenced byfoldToUnsignedSaturatedAdd(),isTruePredicate(),m_c_MaxOrMin(), andllvm::InstCombinerImpl::visitSub().

◆ m_c_Xor()

template<typenameLHS , typenameRHS >

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 line2812 of filePatternMatch.h.

Referenced byfoldComplexAndOrPatterns(),llvm::InstCombinerImpl::foldICmpEquality(),foldICmpPow2Test(),llvm::InstCombinerImpl::foldICmpXorShiftConst(),foldICmpXorXX(),foldXorToXor(),getKnownBitsFromAndXorOr(),haveNoCommonBitsSetSpecialCases(),isMaskOrZero(),m_Not(),m_NotForbidPoison(),shouldExpandCmpArithRMWInIR(),simplifyAndInst(),simplifyOrLogic(),llvm::InstCombinerImpl::visitAnd(),llvm::InstCombinerImpl::visitCallInst(),visitMaskedMerge(),llvm::InstCombinerImpl::visitOr(),llvm::InstCombinerImpl::visitSub(), andllvm::InstCombinerImpl::visitXor().

◆ m_c_XorLike()

template<typenameLHS , typenameRHS >

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) iffR.isMask() Only commutative matcher as thesub will need to swap the L and R.

Definition at line1457 of filePatternMatch.h.

◆ 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 line498 of filePatternMatch.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 line493 of filePatternMatch.h.

◆ 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 line486 of filePatternMatch.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 line481 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpCommutative(),foldMinimumOverTrailingOrLeadingZeroCount(),simplifyRem(), andllvm::InstCombinerImpl::visitMul().

◆ m_Cmp()[1/3]

class_match<CmpInst > llvm::PatternMatch::m_Cmp

(

)

inline

Matches any compare instruction and ignore it.

Definition at line105 of filePatternMatch.h.

Referenced bycheapToScalarize(),llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(),foldSelectBinOpIdentity(),llvm::AArch64TTIImpl::getCmpSelInstrCost(),getHashValueImpl(),llvm::GCNTTIImpl::instCombineIntrinsic(),llvm::RecurrenceDescriptor::isAnyOfPattern(),isEqualImpl(),llvm::RecurrenceDescriptor::isFindLastIVPattern(),llvm::RecurrenceDescriptor::isMinMaxPattern(), andllvm::InstCombinerImpl::visitExtractElementInst().

◆ m_Cmp()[2/3]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1621 of filePatternMatch.h.

◆ m_Cmp()[3/3]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1639 of filePatternMatch.h.

◆ m_CombineAnd()

template<typename LTy , typename RTy >

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

inline

Combine two pattern matchers matching L && R.

Definition at line245 of filePatternMatch.h.

◆ m_CombineOr()

template<typename LTy , typename RTy >

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

inline

Combine two pattern matchers matching L || R.

Definition at line239 of filePatternMatch.h.

Referenced byaddValueAffectedByCondition(),collectUnswitchCandidates(),computeKnownBitsFromCmp(),llvm::ConstantFoldBinaryInstruction(),dropRedundantMaskingOfLeftShiftInput(),foldBoxMultiply(),llvm::InstCombinerImpl::foldICmpEquality(),foldICmpWithHighBitMask(),llvm::InstCombinerImpl::foldSelectShuffle(),foldShuffleOfUnaryOps(),foldTwoEntryPHINode(),foldVecTruncToExtElt(),llvm::slpvectorizer::BoUpSLP::LookAheadHeuristics::getShallowScore(),llvm::isCheckForZeroAndMulWithOverflow(),llvm::RecurrenceDescriptor::isFindLastIVPattern(),isKnownNonZeroFromAssume(),m_AddLike(),m_AnyAdd(),m_AnyMul(),m_c_Intrinsic(),m_c_MaxOrMin(),m_LogicalOp(),m_MaxOrMin(),m_NSWAddLike(),m_NUWAddLike(),m_OrdOrUnordFMax(),m_OrdOrUnordFMin(),m_SExtLike(),m_SExtOrSelf(),m_TruncOrSelf(),m_ZExtOrSelf(),m_ZExtOrSExt(),m_ZExtOrSExtOrSelf(),markAliveBlocks(),matchesSquareSum(),matchSelectPattern(),llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(),shouldCanonicalizeGEPToPtrAdd(),llvm::TargetTransformInfoImplBase::shouldTreatInstructionLikeSelect(),simplifyAndOrOfFCmps(),simplifySelectWithICmpCond(),tryToMoveFreeBeforeNullTest(),llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(),llvm::InstCombinerImpl::visitAnd(), andllvm::InstCombinerImpl::visitCallInst().

◆ m_Constant()[1/2]

class_match<Constant > llvm::PatternMatch::m_Constant

(

)

inline

Match an arbitraryConstant and ignore it.

Definition at line165 of filePatternMatch.h.

◆ m_Constant()[2/2]

bind_ty<Constant > llvm::PatternMatch::m_Constant

(

Constant *&

)

inline

Match aConstant, capturing the value if we match.

Definition at line844 of filePatternMatch.h.

Referencesllvm::CallingConv::C.

◆ m_ConstantExpr()[1/2]

constantexpr_match llvm::PatternMatch::m_ConstantExpr

(

)

inline

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

Definition at line186 of filePatternMatch.h.

Referenced bym_ImmConstant(),simplifyInstructionWithPHI(), andllvm::InstCombinerImpl::visitXor().

◆ m_ConstantExpr()[2/2]

bind_ty<ConstantExpr > llvm::PatternMatch::m_ConstantExpr

(

ConstantExpr *&

)

inline

Match aConstantExpr, capturing the value if we match.

Definition at line853 of filePatternMatch.h.

Referencesllvm::CallingConv::C.

◆ m_ConstantFP()[1/2]

class_match<ConstantFP > llvm::PatternMatch::m_ConstantFP

(

)

inline

Match an arbitraryConstantFP and ignore it.

Definition at line173 of filePatternMatch.h.

Referenced byllvm::GCNTTIImpl::instCombineIntrinsic(), andmatchFPExtFromF16().

◆ m_ConstantFP()[2/2]

bind_ty<ConstantFP > llvm::PatternMatch::m_ConstantFP

(

ConstantFP *&

)

inline

Match aConstantFP, capturing the value if we match.

Definition at line850 of filePatternMatch.h.

Referencesllvm::CallingConv::C.

◆ m_ConstantInt()[1/4]

class_match<ConstantInt > llvm::PatternMatch::m_ConstantInt

(

)

inline

Match an arbitraryConstantInt and ignore it.

Definition at line168 of filePatternMatch.h.

◆ m_ConstantInt()[2/4]

template<int64_t Val>

constantint_match< Val > llvm::PatternMatch::m_ConstantInt

(

)

inline

Match aConstantInt with a specific value.

Definition at line347 of filePatternMatch.h.

◆ m_ConstantInt()[3/4]

bind_ty<ConstantInt > llvm::PatternMatch::m_ConstantInt

(

ConstantInt *&

)

inline

Match aConstantInt, capturing the value if we match.

Definition at line847 of filePatternMatch.h.

◆ m_ConstantInt()[4/4]

bind_const_intval_ty llvm::PatternMatch::m_ConstantInt

(

uint64_t &

)

inline

Match aConstantInt and bind to its value.

This does not match ConstantInts wider than 64-bits.

Definition at line1000 of filePatternMatch.h.

◆ m_CopySign()

template<typename Opnd0 , typename Opnd1 >

m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty llvm::PatternMatch::m_CopySign	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1
	)

inline

Definition at line2741 of filePatternMatch.h.

Referenced byoptimizeSymmetricCall(),stripSignOnlyFPOps(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitFNeg().

◆ m_Deferred()[1/4]

deferredval_ty<BasicBlock > llvm::PatternMatch::m_Deferred

(

BasicBlock *const &

)

inline

A commutative-friendly version ofm_Specific().

Definition at line1020 of filePatternMatch.h.

◆ m_Deferred()[2/4]

deferredval_ty<const BasicBlock > llvm::PatternMatch::m_Deferred

(

const BasicBlock *const &

)

inline

Definition at line1024 of filePatternMatch.h.

◆ m_Deferred()[3/4]

deferredval_ty<const Value > llvm::PatternMatch::m_Deferred

(

const Value *const &

)

inline

Definition at line904 of filePatternMatch.h.

◆ m_Deferred()[4/4]

deferredval_ty<Value > llvm::PatternMatch::m_Deferred

(

Value *const &

)

inline

Likem_Specific(), but works if the specific value to match is determined as part of the samematch() expression.

For example: m_Add(m_Value(X), m_Specific(X)) is incorrect, becausem_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 line903 of filePatternMatch.h.

◆ m_Deinterleave2()

template<typename Opnd >

m_Intrinsic_Ty< Opnd >::Ty llvm::PatternMatch::m_Deinterleave2

(

const Opnd &

)

inline

Definition at line3021 of filePatternMatch.h.

◆ m_DisjointOr()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1395 of filePatternMatch.h.

Referenced bydecompose(),llvm::InstCombinerImpl::foldAddWithConstant(),m_AddLike(),m_NSWAddLike(),m_NUWAddLike(),llvm::InstCombinerImpl::tryFoldInstWithCtpopWithNot(), andllvm::InstCombinerImpl::visitXor().

◆ m_ElementWiseBitCast()

template<typename OpTy >

ElementWiseBitCast_match< OpTy > llvm::PatternMatch::m_ElementWiseBitCast

(

const OpTy &

)

inline

Definition at line2049 of filePatternMatch.h.

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

◆ m_Exact()

template<typenameT >

Exact_match<T > llvm::PatternMatch::m_Exact

(

const T &

SubPattern

)

inline

Definition at line1580 of filePatternMatch.h.

Referenced byfoldCttzCtlz(),simplifyMulInst(),simplifyShlInst(),llvm::InstCombinerImpl::visitMul(),llvm::InstCombinerImpl::visitShl(), andllvm::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

MatchesExtractElementInst.

Definition at line1837 of filePatternMatch.h.

ReferencesIdx.

Referenced bycanonicalizeBitCastExtElt(),foldInsEltIntoIdentityShuffle(),foldVecExtTruncToExtElt(),llvm::slpvectorizer::BoUpSLP::LookAheadHeuristics::getShallowScore(),isOperandOfVmullHighP64(),matchPMADDWD(),matchPMADDWD_2(),llvm::InstCombinerImpl::SimplifyDemandedVectorElts(),llvm::simplifyInsertElementInst(), andllvm::InstCombinerImpl::visitInsertElementInst().

◆ m_ExtractValue()[1/2]

template<int Ind, typename Val_t >

ExtractValue_match< Ind, Val_t > llvm::PatternMatch::m_ExtractValue

(

const Val_t &

)

inline

Match a single index ExtractValue instruction.

For example m_ExtractValue<1>(...)

Definition at line2950 of filePatternMatch.h.

Referenced bydirectlyImpliesPoison().

◆ m_ExtractValue()[2/2]

template<typename Val_t >

ExtractValue_match<-1, Val_t > llvm::PatternMatch::m_ExtractValue

(

const Val_t &

)

inline

Match an ExtractValue instruction with any index.

For example m_ExtractValue(...)

Definition at line2957 of filePatternMatch.h.

◆ m_FAbs()

template<typename Opnd0 >

m_Intrinsic_Ty< Opnd0 >::Ty llvm::PatternMatch::m_FAbs

(

const Opnd0 &

Op0

)

inline

Definition at line2702 of filePatternMatch.h.

Referenced byllvm::fcmpImpliesClass(),llvm::findValuesAffectedByCondition(),foldFabsWithFcmpZero(),foldShuffleOfUnaryOps(),llvm::GCNTTIImpl::isProfitableToSinkOperands(),optimizeSymmetricCall(),simplifyAndOrOfFCmps(),stripSignOnlyFPOps(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitFDiv().

◆ m_FAdd()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1108 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldFMulReassoc(),foldFNegIntoConstant(),llvm::RecurrenceDescriptor::isConditionalRdxPattern(),m_AnyAdd(), andllvm::InstCombinerImpl::visitFCmpInst().

◆ m_FCanonicalize()

template<typename Opnd0 >

m_Intrinsic_Ty< Opnd0 >::Ty llvm::PatternMatch::m_FCanonicalize

(

const Opnd0 &

Op0

)

inline

Definition at line2707 of filePatternMatch.h.

◆ m_FCmp()[1/2]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1633 of filePatternMatch.h.

Referenced bycomputeKnownFPClass(),computeKnownFPClassFromCond(),llvm::findValuesAffectedByCondition(),reassociateFCmps(),simplifySelectWithFCmp(), andllvm::InstCombinerImpl::visitBranchInst().

◆ m_FCmp()[2/2]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1649 of filePatternMatch.h.

◆ m_FDiv()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1192 of filePatternMatch.h.

Referenced byconvertFSqrtDivIntoFMul(),factorizeFAddFSub(),foldFDivConstantDividend(),foldFDivSqrtDivisor(),llvm::InstCombinerImpl::foldFMulReassoc(),foldFNegIntoConstant(),getFSqrtDivOptPattern(),llvm::InstCombinerImpl::visitFAdd(),llvm::InstCombinerImpl::visitFDiv(), andllvm::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 line742 of filePatternMatch.h.

◆ m_Finite()[2/2]

apf_pred_ty<is_finite > llvm::PatternMatch::m_Finite

(

const APFloat *&

)

inline

Definition at line745 of filePatternMatch.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 line752 of filePatternMatch.h.

Referenced byllvm::GCNTTIImpl::canSimplifyLegacyMulToMul().

◆ m_FiniteNonZero()[2/2]

apf_pred_ty<is_finitenonzero > llvm::PatternMatch::m_FiniteNonZero

(

const APFloat *&

)

inline

Definition at line755 of filePatternMatch.h.

◆ m_FMax()

template<typename Opnd0 , typename Opnd1 >

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

inline

Definition at line2718 of filePatternMatch.h.

◆ m_FMin()

template<typename Opnd0 , typename Opnd1 >

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

inline

Definition at line2712 of filePatternMatch.h.

◆ m_FMul()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1174 of filePatternMatch.h.

Referenced byfactorizeFAddFSub(),foldFDivConstantDividend(),foldFNegIntoConstant(),llvm::AArch64TTIImpl::getArithmeticInstrCost(),getFSqrtDivOptPattern(),llvm::RecurrenceDescriptor::isConditionalRdxPattern(),isInstructionPairMul(),m_AnyMul(),llvm::InstCombinerImpl::visitFAdd(),llvm::InstCombinerImpl::visitFMul(), andllvm::InstCombinerImpl::visitFSub().

◆ m_FNeg()

template<typename OpTy >

FNeg_match< OpTy > llvm::PatternMatch::m_FNeg

(

const OpTy &

)

inline

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

Definition at line1156 of filePatternMatch.h.

ReferencesX.

Referenced byllvm::findValuesAffectedByCondition(),foldFCmpFNegCommonOp(),foldFDivConstantDividend(),foldFNegIntoConstant(),llvm::InstCombinerImpl::foldSelectOpOp(),foldShuffleOfUnaryOps(),llvm::InstCombiner::getComplexity(),isNeg(),llvm::GCNTTIImpl::isProfitableToSinkOperands(),llvm::ARMTTIImpl::isProfitableToSinkOperands(),LinearizeExprTree(),NegateValue(),optimizeSymmetricCall(),ShouldBreakUpSubtract(),llvm::simplifyBinaryIntrinsic(),simplifyFAddInst(),simplifyFNegInst(),simplifyFSubInst(),stripSignOnlyFPOps(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitFAdd(),llvm::InstCombinerImpl::visitFCmpInst(),llvm::InstCombinerImpl::visitFMul(),llvm::InstCombinerImpl::visitFNeg(),llvm::InstCombinerImpl::visitFPTrunc(), andllvm::InstCombinerImpl::visitFSub().

◆ m_FNegNSZ()

template<typenameRHS >

BinaryOp_match<cstfp_pred_ty<is_any_zero_fp >,RHS, Instruction::FSub > llvm::PatternMatch::m_FNegNSZ

(

const RHS &

)

inline

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

Definition at line1163 of filePatternMatch.h.

Referencesm_AnyZeroFP(),m_FSub(), andX.

Referenced bysimplifyFDivInst().

◆ m_FPExt()

template<typename OpTy >

CastInst_match< OpTy,FPExtInst > llvm::PatternMatch::m_FPExt

(

const OpTy &

)

inline

Definition at line2176 of filePatternMatch.h.

Referenced bycanSafelyConvertTo16Bit(),llvm::InstCombinerImpl::foldICmpBitCast(),llvm::GCNTTIImpl::instCombineIntrinsic(),matchFPExtFromF16(),narrowInsElt(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitFCmpInst(),llvm::InstCombinerImpl::visitFPTrunc(), andllvm::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 line931 of filePatternMatch.h.

Referencesm_SpecificFP().

Referenced byfactorizeLerp(),llvm::GCNTTIImpl::getArithmeticInstrCost(),getFSqrtDivOptPattern(),instCombineSVEVectorMul(),simplifyFDivInst(), andsimplifyFMAFMul().

◆ m_FPToSI()

template<typename OpTy >

CastInst_match< OpTy,FPToSIInst > llvm::PatternMatch::m_FPToSI

(

const OpTy &

)

inline

Definition at line2166 of filePatternMatch.h.

Referenced byisKnownExactCastIntToFP(), andtryToFPToSat().

◆ m_FPToUI()

template<typename OpTy >

CastInst_match< OpTy,FPToUIInst > llvm::PatternMatch::m_FPToUI

(

const OpTy &

)

inline

Definition at line2161 of filePatternMatch.h.

Referenced byisKnownExactCastIntToFP().

◆ m_FPTrunc()

template<typename OpTy >

CastInst_match< OpTy,FPTruncInst > llvm::PatternMatch::m_FPTrunc

(

const OpTy &

)

inline

Definition at line2171 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpBitCast(), andllvm::InstCombinerImpl::visitFSub().

◆ m_Freeze()

template<typename OpTy >

OneOps_match< OpTy, Instruction::Freeze > llvm::PatternMatch::m_Freeze

(

const OpTy &

)

inline

MatchesFreezeInst.

Definition at line1822 of filePatternMatch.h.

◆ m_FRem()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1210 of filePatternMatch.h.

◆ m_FShl()

template<typename Opnd0 , typename Opnd1 , typename Opnd2 >

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

inline

Definition at line2725 of filePatternMatch.h.

Referenced bycollectBitParts(),foldCtpop(),llvm::recognizeBSwapOrBitReverseIdiom(), andsimplifySelectWithICmpCond().

◆ m_FShr()

template<typename Opnd0 , typename Opnd1 , typename Opnd2 >

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

inline

Definition at line2731 of filePatternMatch.h.

Referenced bycollectBitParts(),foldCtpop(),llvm::recognizeBSwapOrBitReverseIdiom(), andsimplifySelectWithICmpCond().

◆ m_FSub()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1120 of filePatternMatch.h.

Referenced byfactorizeLerp(),llvm::InstCombinerImpl::foldFMulReassoc(),llvm::RecurrenceDescriptor::isConditionalRdxPattern(),m_FNegNSZ(),simplifyFAddInst(),simplifyFSubInst(),llvm::InstCombinerImpl::visitFAdd(),llvm::InstCombinerImpl::visitFNeg(), andllvm::InstCombinerImpl::visitFSub().

◆ m_GEP()

template<typename... OperandTypes>

auto llvm::PatternMatch::m_GEP

(

const OperandTypes &...

Ops

)

inline

MatchesGetElementPtrInst.

Definition at line1937 of filePatternMatch.h.

Referenced byfoldDependentIVs().

◆ m_ICmp()[1/2]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1627 of filePatternMatch.h.

◆ m_ICmp()[2/2]

template<typenameLHS , typenameRHS >

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

inline

Definition at line1644 of filePatternMatch.h.

◆ m_IDiv()

template<typenameLHS , typenameRHS >

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

inline

Matches integer division operations.

Definition at line1553 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldMultiplicationOverflowCheck(),isKnownNonNullFromDominatingCondition(),matchExpandedRem(),simplifyMulInst(), andllvm::InstCombinerImpl::visitGetElementPtrInst().

◆ m_ImmConstant()[1/2]

match_combine_and<class_match<Constant >,match_unless<constantexpr_match > > llvm::PatternMatch::m_ImmConstant

(

)

inline

Match an arbitrary immediateConstant and ignore it.

Definition at line864 of filePatternMatch.h.

Referencesm_CombineAnd(),m_Constant(),m_ConstantExpr(), andm_Unless().

◆ m_ImmConstant()[2/2]

match_combine_and<bind_ty<Constant >,match_unless<constantexpr_match > > llvm::PatternMatch::m_ImmConstant

(

Constant *&

)

inline

Match an immediateConstant, capturing the value if we match.

Definition at line871 of filePatternMatch.h.

Referencesllvm::CallingConv::C,m_CombineAnd(),m_Constant(),m_ConstantExpr(), andm_Unless().

◆ m_Inf()

cstfp_pred_ty<is_inf > llvm::PatternMatch::m_Inf

(

)

inline

Match a positive or negative infinity FP constant.

For vectors, this includes constants with undefined elements.

Definition at line726 of filePatternMatch.h.

Referenced bymatchUnorderedInfCompare(),simplifyFAddInst(),simplifyFPOp(), andsimplifyFSubInst().

◆ 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

MatchesInsertElementInst.

Definition at line1829 of filePatternMatch.h.

ReferencesIdx.

Referenced bycanonicalizeInsertSplat(),cheapToScalarize(),foldIdentityExtractShuffle(),foldInsEltIntoSplat(),foldShuffleWithInsert(),foldTruncInsEltPair(),llvm::getSplatValue(),llvm::ARMTTIImpl::isProfitableToSinkOperands(),llvm::RISCVTTIImpl::isProfitableToSinkOperands(),llvm::WebAssemblyTTIImpl::isProfitableToSinkOperands(),replaceShuffleOfInsert(),simplifyShuffleVectorInst(),llvm::InstCombinerImpl::visitBitCast(),llvm::InstCombinerImpl::visitInsertElementInst(), andllvm::InstCombinerImpl::visitPtrToInt().

◆ m_InsertValue()

template<int Ind, typename Val_t , typename Elt_t >

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

inline

Matches a single index InsertValue instruction.

Definition at line2979 of filePatternMatch.h.

◆ m_Instruction()

bind_ty<Instruction > llvm::PatternMatch::m_Instruction

(

Instruction *&

)

inline

Match an instruction, capturing it if we match.

Definition at line826 of filePatternMatch.h.

ReferencesI.

◆ m_Interleave2()

template<typename Opnd0 , typename Opnd1 >

m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty llvm::PatternMatch::m_Interleave2	(	const Opnd0 &	Op0,
		const Opnd1 &	Op1
	)

inline

Definition at line3016 of filePatternMatch.h.

◆ m_Intrinsic()[1/7]

template<Intrinsic::ID IntrID>

IntrinsicID_match llvm::PatternMatch::m_Intrinsic

(

)

inline

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

Definition at line2628 of filePatternMatch.h.

◆ m_Intrinsic()[2/7]

template<Intrinsic::ID IntrID, typename T0 >

m_Intrinsic_Ty< T0 >::Ty llvm::PatternMatch::m_Intrinsic

(

const T0 &

Op0

)

inline

Definition at line2649 of filePatternMatch.h.

Referencesm_CombineAnd().

◆ m_Intrinsic()[3/7]

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

m_Intrinsic_Ty< T0,T1 >::Ty llvm::PatternMatch::m_Intrinsic	(	const T0 &	Op0,
		const T1 &	Op1
	)

inline

Definition at line2654 of filePatternMatch.h.

Referencesm_CombineAnd().

◆ m_Intrinsic()[4/7]

template<Intrinsic::ID IntrID, typename T0 , typenameT1 , typename T2 >

m_Intrinsic_Ty< T0,T1, T2 >::Ty llvm::PatternMatch::m_Intrinsic	(	const T0 &	Op0,
		const T1 &	Op1,
		const T2 &	Op2
	)

inline

Definition at line2661 of filePatternMatch.h.

Referencesm_CombineAnd().

◆ m_Intrinsic()[5/7]

template<Intrinsic::ID IntrID, typename T0 , typenameT1 , typename T2 , typename T3 >

m_Intrinsic_Ty< T0,T1, T2, T3 >::Ty llvm::PatternMatch::m_Intrinsic	(	const T0 &	Op0,
		const T1 &	Op1,
		const T2 &	Op2,
		const T3 &	Op3
	)

inline

Definition at line2668 of filePatternMatch.h.

Referencesm_CombineAnd().

◆ m_Intrinsic()[6/7]

template<Intrinsic::ID IntrID, typename T0 , typenameT1 , typename T2 , typename T3 , typename T4 >

m_Intrinsic_Ty< T0,T1, T2, T3, T4 >::Ty llvm::PatternMatch::m_Intrinsic	(	const T0 &	Op0,
		const T1 &	Op1,
		const T2 &	Op2,
		const T3 &	Op3,
		const T4 &	Op4
	)

inline

Definition at line2675 of filePatternMatch.h.

Referencesm_CombineAnd().

◆ m_Intrinsic()[7/7]

template<Intrinsic::ID IntrID, typename T0 , typenameT1 , typename T2 , typename T3 , typename T4 , typename T5 >

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

inline

Definition at line2684 of filePatternMatch.h.

Referencesm_CombineAnd().

◆ m_IntToPtr()

template<typename OpTy >

CastOperator_match< OpTy, Instruction::IntToPtr > llvm::PatternMatch::m_IntToPtr

(

const OpTy &

)

inline

Matches IntToPtr.

Definition at line2069 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::visitPtrToInt().

◆ m_IRem()

template<typenameLHS , typenameRHS >

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

inline

Matches integer remainder operations.

Definition at line1560 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldIRemByPowerOfTwoToBitTest(),isKnownNonNullFromDominatingCondition(), andllvm::InstCombinerImpl::SimplifyAddWithRemainder().

◆ m_Load()

template<typename OpTy >

OneOps_match< OpTy, Instruction::Load > llvm::PatternMatch::m_Load

(

const OpTy &

)

inline

MatchesLoadInst.

Definition at line1923 of filePatternMatch.h.

Referenced bycheapToScalarize(),llvm::findHistogram(),llvm::X86TTIImpl::getShuffleCost(), andllvm::AArch64TTIImpl::isProfitableToSinkOperands().

◆ m_LogicalAnd()[1/2]

auto llvm::PatternMatch::m_LogicalAnd

(

)

inline

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

Definition at line3081 of filePatternMatch.h.

Referencesm_LogicalAnd(), andm_Value().

Referenced bycheckOrAndOpImpliedByOther(),collectHomogenousInstGraphLoopInvariants(),collectUnswitchCandidates(),llvm::VPWidenSelectRecipe::computeCost(),computeKnownBitsFromCond(),computeKnownFPClassFromCond(),llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(),findBestNonTrivialUnswitchCandidate(),llvm::SelectionDAGBuilder::FindMergedConditions(),llvm::InstCombiner::getFreelyInvertedImpl(),llvm::TargetTransformInfoImplCRTPBase< T >::getInstructionCost(),llvm::LoopVectorizationCostModel::getInstructionCost(),hoistMinMax(),isImpliedCondAndOr(),llvm::isImpliedCondition(),isKnownNonNullFromDominatingCondition(),m_LogicalAnd(),optimizeLoopExitWithUnknownExitCount(),llvm::TargetTransformInfoImplBase::shouldTreatInstructionLikeSelect(),simplifyRecipe(),llvm::InstCombinerImpl::sinkNotIntoLogicalOp(),llvm::InstCombinerImpl::sinkNotIntoOtherHandOfLogicalOp(),llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(),unswitchNontrivialInvariants(),unswitchTrivialBranch(),llvm::InstCombinerImpl::visitAnd(),llvm::InstCombinerImpl::visitBranchInst(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitXor().

◆ m_LogicalAnd()[2/2]

template<typenameLHS , typenameRHS >

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 line3075 of filePatternMatch.h.

◆ 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 line3119 of filePatternMatch.h.

Referencesm_LogicalOp(), andm_Value().

Referenced bycomputeKnownBitsFromCond(),llvm::findValuesAffectedByCondition(),m_c_LogicalOp(),m_LogicalOp(),llvm::InstCombinerImpl::sinkNotIntoLogicalOp(), andllvm::InstCombinerImpl::sinkNotIntoOtherHandOfLogicalOp().

◆ m_LogicalOp()[2/2]

template<typenameLHS , typenameRHS ,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 line3112 of filePatternMatch.h.

Referencesm_CombineOr().

◆ m_LogicalOr()[1/2]

auto llvm::PatternMatch::m_LogicalOr

(

)

inline

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

Definition at line3099 of filePatternMatch.h.

Referencesm_LogicalOr(), andm_Value().

Referenced bycheckOrAndOpImpliedByOther(),collectHomogenousInstGraphLoopInvariants(),collectUnswitchCandidates(),llvm::VPWidenSelectRecipe::computeCost(),computeKnownBitsFromCond(),computeKnownFPClassFromCond(),llvm::JumpThreadingPass::computeValueKnownInPredecessorsImpl(),findBestNonTrivialUnswitchCandidate(),llvm::SelectionDAGBuilder::FindMergedConditions(),llvm::InstCombiner::getFreelyInvertedImpl(),llvm::TargetTransformInfoImplCRTPBase< T >::getInstructionCost(),llvm::LoopVectorizationCostModel::getInstructionCost(),hoistMinMax(),isImpliedCondAndOr(),llvm::isImpliedCondition(),m_LogicalOr(),optimizeLoopExitWithUnknownExitCount(),llvm::TargetTransformInfoImplBase::shouldTreatInstructionLikeSelect(),llvm::JumpThreadingPass::tryToUnfoldSelectInCurrBB(),unswitchNontrivialInvariants(),unswitchTrivialBranch(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitOr(), andllvm::InstCombinerImpl::visitXor().

◆ m_LogicalOr()[2/2]

template<typenameLHS , typenameRHS >

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 line3093 of filePatternMatch.h.

◆ m_LogicalShift()

template<typenameLHS , typenameRHS >

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 line1533 of filePatternMatch.h.

Referenced bycollectBitParts(),llvm::InstCombinerImpl::convertOrOfShiftsToFunnelShift(),foldShiftIntoShiftInAnotherHandOfAndInICmp(),llvm::InstCombinerImpl::visitAnd(), andllvm::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 line673 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpBinOp(),llvm::InstCombinerImpl::foldICmpEquality(),llvm::PatternMatch::XorLike_match< LHS, RHS >::match(),processAnd(),llvm::InstCombinerImpl::SimplifyDemandedUseBits(),simplifySubInst(), andsimplifyXorInst().

◆ m_LowBitMask()[2/2]

api_pred_ty<is_lowbit_mask > llvm::PatternMatch::m_LowBitMask

(

const APInt *&

)

inline

Definition at line676 of filePatternMatch.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 line683 of filePatternMatch.h.

Referenced byisMaskOrZero().

◆ m_LowBitMaskOrZero()[2/2]

api_pred_ty<is_lowbit_mask_or_zero > llvm::PatternMatch::m_LowBitMaskOrZero

(

const APInt *&

)

inline

Definition at line686 of filePatternMatch.h.

◆ m_LShr()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1240 of filePatternMatch.h.

◆ m_MaskedGather()

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

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

inline

Matches MaskedGatherIntrinsic.

Definition at line2643 of filePatternMatch.h.

◆ m_MaskedLoad()

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

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

inline

Matches MaskedLoadIntrinsic.

Definition at line2635 of filePatternMatch.h.

◆ m_MaxOrMin()

template<typenameLHS , typenameRHS >

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

inline

Definition at line2371 of filePatternMatch.h.

Referencesm_CombineOr(),m_SMax(),m_SMin(),m_UMax(), andm_UMin().

Referenced byllvm::InstCombinerImpl::foldICmpUsingKnownBits(),llvm::InstCombinerImpl::foldICmpWithDominatingICmp(),foldMinMaxSharedOp(),llvm::InstCombinerImpl::foldSelectOpOp(),llvm::InstCombiner::getFreelyInvertedImpl(), andreassociateMinMaxWithConstantInOperand().

◆ 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 line538 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::visitAnd().

◆ m_MaxSignedValue()[2/2]

api_pred_ty<is_maxsignedvalue > llvm::PatternMatch::m_MaxSignedValue

(

const APInt *&

)

inline

Definition at line541 of filePatternMatch.h.

◆ m_Mul()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1168 of filePatternMatch.h.

◆ 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 line710 of filePatternMatch.h.

Referenced byllvm::GCNTTIImpl::instCombineIntrinsic(),llvm::simplifyBinaryIntrinsic(), andsimplifyFPOp().

◆ m_Neg()

template<typename ValTy >

BinaryOp_match<cst_pred_ty<is_zero_int >, ValTy, Instruction::Sub > llvm::PatternMatch::m_Neg

(

const ValTy &

)

inline

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

Definition at line2820 of filePatternMatch.h.

Referencesm_Sub(), andm_ZeroInt().

◆ m_NegatedPower2()[1/2]

cst_pred_ty<is_negated_power2 > llvm::PatternMatch::m_NegatedPower2

(

)

inline

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

For vectors, this includes constants with undefined elements.

Definition at line627 of filePatternMatch.h.

Referenced byfoldNegativePower2AndShiftedMask(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitMul(), andllvm::InstCombinerImpl::visitSDiv().

◆ m_NegatedPower2()[2/2]

api_pred_ty<is_negated_power2 > llvm::PatternMatch::m_NegatedPower2

(

const APInt *&

)

inline

Definition at line630 of filePatternMatch.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 line639 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpBinOp(), andisMaskOrZero().

◆ m_NegatedPower2OrZero()[2/2]

api_pred_ty<is_negated_power2_or_zero > llvm::PatternMatch::m_NegatedPower2OrZero

(

const APInt *&

)

inline

Definition at line643 of filePatternMatch.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 line550 of filePatternMatch.h.

Referenced byllvm::simplifyBinaryIntrinsic(),simplifyShlInst(),llvm::InstCombinerImpl::visitSRem(),llvm::InstCombinerImpl::visitUDiv(), andllvm::InstCombinerImpl::visitURem().

◆ m_Negative()[2/2]

api_pred_ty<is_negative > llvm::PatternMatch::m_Negative

(

const APInt *&

)

inline

Definition at line553 of filePatternMatch.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 line782 of filePatternMatch.h.

Referenced byllvm::ConstantFoldBinaryInstruction(),simplifyFAddInst(),simplifyFRemInst(),simplifyFSubInst(), andllvm::InstCombinerImpl::visitCallInst().

◆ m_NNegZExt()

template<typename OpTy >

NNegZExt_match< OpTy > llvm::PatternMatch::m_NNegZExt

(

const OpTy &

)

inline

Definition at line2112 of filePatternMatch.h.

Referenced bydecompose(), andm_SExtLike().

◆ 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 line733 of filePatternMatch.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 line717 of filePatternMatch.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 line560 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpBinOp(),foldICmpWithLowBitMaskedVal(),getBinOpsForFactorization(),instCombineSVESrshl(),isImpliedCondICmps(), andllvm::InstCombinerImpl::visitSDiv().

◆ m_NonNegative()[2/2]

api_pred_ty<is_nonnegative > llvm::PatternMatch::m_NonNegative

(

const APInt *&

)

inline

Definition at line563 of filePatternMatch.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 line582 of filePatternMatch.h.

Referenced byisImpliedCondICmps().

◆ m_NonPositive()[2/2]

api_pred_ty<is_nonpositive > llvm::PatternMatch::m_NonPositive

(

const APInt *&

)

inline

Definition at line585 of filePatternMatch.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 line791 of filePatternMatch.h.

◆ 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 line801 of filePatternMatch.h.

Referenced byhasNonZeroFPOperands().

◆ m_Not()

template<typename ValTy >

BinaryOp_match<cst_pred_ty<is_all_ones >, ValTy, Instruction::Xor,true > llvm::PatternMatch::m_Not

(

const ValTy &

)

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 line2467 of filePatternMatch.h.

Referencesm_AllOnes(), andm_c_Xor().

◆ m_NotForbidPoison()

template<typename ValTy >

BinaryOp_match<cst_pred_ty<is_all_ones, false >, ValTy, Instruction::Xor,true > llvm::PatternMatch::m_NotForbidPoison

(

const ValTy &

)

inline

Definition at line2474 of filePatternMatch.h.

Referencesm_AllOnesForbidPoison(), andm_c_Xor().

Referenced bycanonicalizeSaturatedAdd().

◆ m_NSWAdd()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1281 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoSignedWrap, andRHS.

Referenced bydecompose(),foldURemOfLoopIncrement(),hoistAdd(),isTruePredicate(),m_NSWAddLike(),trySimplifyICmpWithAdds(), andllvm::InstCombinerImpl::visitGetElementPtrInst().

◆ m_NSWAddLike()

template<typenameLHS , typenameRHS >

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 line1419 of filePatternMatch.h.

Referencesm_CombineOr(),m_DisjointOr(), andm_NSWAdd().

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),foldNoWrapAdd(),isTruePredicate(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitSub().

◆ m_NSWMul()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1297 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoSignedWrap, andRHS.

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),decompose(),simplifyDiv(),simplifyICmpWithConstant(),simplifyRem(),llvm::InstCombinerImpl::visitAShr(), andllvm::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 &

)

inline

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

Definition at line2829 of filePatternMatch.h.

Referencesm_NSWSub(), andm_ZeroInt().

Referenced byfoldICmpXNegX(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitSDiv(), andllvm::InstCombinerImpl::visitSRem().

◆ m_NSWShl()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1305 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoSignedWrap, andRHS.

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),decompose(),simplifyAShrInst(),simplifyRem(),llvm::InstCombinerImpl::visitAShr(), andllvm::InstCombinerImpl::visitSDiv().

◆ m_NSWSub()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1289 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoSignedWrap, andRHS.

Referenced byllvm::computeOverflowForSignedSub(),decompose(),llvm::InstCombinerImpl::foldAddLikeCommutative(),foldSubOfMinMax(),getKnownSign(),getKnownSignOrZero(),hoistSub(),isImpliedCondICmps(),llvm::isKnownNegation(),m_NSWNeg(),llvm::InstCombinerImpl::visitAShr(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitLShr(), andllvm::InstCombinerImpl::visitOr().

◆ m_NSWTrunc()

template<typename OpTy >

NoWrapTrunc_match< OpTy,TruncInst::NoSignedWrap > llvm::PatternMatch::m_NSWTrunc

(

const OpTy &

)

inline

Matches trunc nsw.

Definition at line2089 of filePatternMatch.h.

Referenced bydecompose(), andllvm::InstCombinerImpl::foldICmpTruncWithTruncOrExt().

◆ m_NUWAdd()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1314 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoUnsignedWrap, andRHS.

Referenced bydecompose(),llvm::findValuesAffectedByCondition(),llvm::InstCombinerImpl::foldICmpBinOpEqualityWithConstant(),hoistAdd(),isRemOfLoopIncrementWithLoopInvariant(), andm_NUWAddLike().

◆ m_NUWAddLike()

template<typenameLHS , typenameRHS >

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 line1429 of filePatternMatch.h.

Referencesm_CombineOr(),m_DisjointOr(), andm_NUWAdd().

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),llvm::InstCombinerImpl::commonShiftTransforms(),foldNoWrapAdd(),isTruePredicate(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitSub().

◆ m_NUWMul()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1340 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoUnsignedWrap, andRHS.

◆ m_NUWShl()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1348 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoUnsignedWrap, andRHS.

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),decompose(),foldCttzCtlz(),foldICmpShlLHSC(),simplifyAndInst(),simplifyLShrInst(),simplifyRem(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitLShr().

◆ m_NUWSub()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1332 of filePatternMatch.h.

ReferencesLHS,llvm::OverflowingBinaryOperator::NoUnsignedWrap, andRHS.

Referenced bycomputeKnownBitsFromCmp(),llvm::computeOverflowForUnsignedSub(),decompose(),llvm::findValuesAffectedByCondition(),llvm::InstCombinerImpl::foldAddLikeCommutative(),hoistSub(),simplifyXorInst(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitLShr().

◆ m_NUWTrunc()

template<typename OpTy >

NoWrapTrunc_match< OpTy,TruncInst::NoUnsignedWrap > llvm::PatternMatch::m_NUWTrunc

(

const OpTy &

)

inline

Matches trunc nuw.

Definition at line2082 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpTruncWithTruncOrExt().

◆ 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 line592 of filePatternMatch.h.

◆ m_OneUse()

template<typenameT >

OneUse_match<T > llvm::PatternMatch::m_OneUse

(

const T &

SubPattern

)

inline

Definition at line67 of filePatternMatch.h.

◆ m_Or()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1222 of filePatternMatch.h.

◆ m_OrdFMax()

template<typenameLHS , typenameRHS >

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

inline

Match an 'ordered' floating point maximum function.

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

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

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

Definition at line2386 of filePatternMatch.h.

◆ m_OrdFMin()

template<typenameLHS , typenameRHS >

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

inline

Match an 'ordered' floating point minimum function.

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

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

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

Definition at line2401 of filePatternMatch.h.

◆ m_OrdOrUnordFMax()

template<typenameLHS , typenameRHS >

match_combine_or<MaxMin_match<FCmpInst,LHS,RHS,ofmax_pred_ty >,MaxMin_match<FCmpInst,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.

Definition at line2444 of filePatternMatch.h.

Referencesm_CombineOr().

Referenced byllvm::RecurrenceDescriptor::isMinMaxPattern(), andmatchFastFloatClamp().

◆ m_OrdOrUnordFMin()

template<typenameLHS , typenameRHS >

match_combine_or<MaxMin_match<FCmpInst,LHS,RHS,ofmin_pred_ty >,MaxMin_match<FCmpInst,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.

Definition at line2457 of filePatternMatch.h.

Referencesm_CombineOr().

Referenced byllvm::RecurrenceDescriptor::isMinMaxPattern(), andmatchFastFloatClamp().

◆ m_Poison()

class_match<PoisonValue > llvm::PatternMatch::m_Poison

(

)

inline

Match an arbitrary poison constant.

Definition at line160 of filePatternMatch.h.

Referenced bycanonicalizeInsertSplat(),collectShuffleElements(),collectSingleShuffleElements(),foldIdentityExtractShuffle(),foldInsEltIntoIdentityShuffle(),foldInsSequenceIntoSplat(),foldShuffleOfUnaryOps(),foldTruncShuffle(),llvm::InstCombinerImpl::foldVectorBinop(),narrowVectorSelect(),llvm::InstCombinerImpl::simplifyBinOpSplats(),llvm::InstCombinerImpl::SimplifyDemandedVectorElts(),simplifyFPOp(), andllvm::InstCombinerImpl::visitShuffleVectorInst().

◆ 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 line773 of filePatternMatch.h.

Referenced byfoldSqrtWithFcmpZero(),simplifyAndOrOfFCmps(),simplifyFAddInst(),simplifyFRemInst(),simplifyFSubInst(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitFCmpInst().

◆ m_Power2()[1/2]

cst_pred_ty<is_power2 > llvm::PatternMatch::m_Power2

(

)

inline

Match an integer or vector power-of-2.

For vectors, this includes constants with undefined elements.

Definition at line619 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::commonShiftTransforms(),computeKnownBitsFromCmp(),detectShiftUntilBitTestIdiom(),foldAddToAshr(),llvm::InstCombinerImpl::foldICmpSRemConstant(),llvm::InstCombinerImpl::foldICmpUsingKnownBits(),foldSelectICmpAnd(),foldSelectICmpAndBinOp(),foldSignedTruncationCheck(),llvm::isKnownToBeAPowerOfTwo(),isPowerOfTwoRecurrence(),simplifyAndInst(),simplifyICmpWithBinOp(),llvm::InstCombinerImpl::takeLog2(),llvm::InstCombinerImpl::visitAnd(),llvm::InstCombinerImpl::visitSDiv(), andllvm::InstCombinerImpl::visitTrunc().

◆ m_Power2()[2/2]

api_pred_ty<is_power2 > llvm::PatternMatch::m_Power2

(

const APInt *&

)

inline

Definition at line620 of filePatternMatch.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 line652 of filePatternMatch.h.

Referenced byllvm::isKnownToBeAPowerOfTwo().

◆ m_Power2OrZero()[2/2]

api_pred_ty<is_power2_or_zero > llvm::PatternMatch::m_Power2OrZero

(

const APInt *&

)

inline

Definition at line655 of filePatternMatch.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 line1944 of filePatternMatch.h.

Referenced bycanonicalizeGEPOfConstGEPI8(),simplifyCastInst(), andllvm::InstCombinerImpl::SimplifyDemandedUseBits().

◆ m_PtrToInt()

template<typename OpTy >

CastOperator_match< OpTy, Instruction::PtrToInt > llvm::PatternMatch::m_PtrToInt

(

const OpTy &

)

inline

Matches PtrToInt.

Definition at line2056 of filePatternMatch.h.

Referenced byaddValueAffectedByCondition(),llvm::InstCombinerImpl::foldICmpOrConstant(),isKnownNonZeroFromAssume(),llvm::PatternMatch::VScaleVal_match::match(),llvm::simplifyBinaryIntrinsic(),simplifyCastInst(),simplifyGEPInst(),simplifySubInst(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitGetElementPtrInst(), andllvm::InstCombinerImpl::visitSub().

◆ m_PtrToIntSameSize()

template<typename OpTy >

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

inline

Definition at line2061 of filePatternMatch.h.

ReferencesDL.

Referenced bycomputeKnownBitsFromCmp(),isKnownNonEqual(), andllvm::InstCombinerImpl::visitSub().

◆ m_SDiv()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1186 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),llvm::InstCombinerImpl::foldAddLikeCommutative(),foldAddToAshr(),llvm::InstCombinerImpl::foldICmpCommutative(),llvm::InstCombinerImpl::FoldShiftByConstant(),MatchDiv(),simplifyDivRem(),simplifyGEPInst(),llvm::InstCombinerImpl::visitGetElementPtrInst(),llvm::InstCombinerImpl::visitMul(), andllvm::InstCombinerImpl::visitSDiv().

◆ m_Select()

template<typenameCond , typenameLHS , typenameRHS >

ThreeOps_match<Cond,LHS,RHS, Instruction::Select > llvm::PatternMatch::m_Select	(	const Cond &	C,
		const LHS &	L,
		const RHS &	R
	)

inline

MatchesSelectInst.

Definition at line1799 of filePatternMatch.h.

Referencesllvm::CallingConv::C.

◆ m_SelectCst()

template<int64_t L, int64_t R, typenameCond >

ThreeOps_match<Cond,constantint_match< L >,constantint_match< R >, Instruction::Select > llvm::PatternMatch::m_SelectCst

(

const Cond &

)

inline

This matches a select of two constants, e.g.: m_SelectCst<-1, 0>(m_Value(V))

Definition at line1808 of filePatternMatch.h.

Referencesllvm::CallingConv::C, andm_Select().

◆ m_SExt()

template<typename OpTy >

CastInst_match< OpTy,SExtInst > llvm::PatternMatch::m_SExt

(

const OpTy &

)

inline

Matches SExt.

Definition at line2101 of filePatternMatch.h.

◆ m_SExtLike()

template<typename OpTy >

match_combine_or<CastInst_match< OpTy,SExtInst >,NNegZExt_match< OpTy > > llvm::PatternMatch::m_SExtLike

(

const OpTy &

)

inline

Match either "sext" or "zext nneg".

Definition at line2131 of filePatternMatch.h.

Referencesm_CombineOr(),m_NNegZExt(), andm_SExt().

Referenced byfoldLogicCastConstant(),foldNoWrapAdd(),llvm::InstCombiner::getFreelyInvertedImpl(), andllvm::InstCombinerImpl::visitGetElementPtrInst().

◆ m_SExtOrSelf()

template<typename OpTy >

match_combine_or<CastInst_match< OpTy,SExtInst >, OpTy > llvm::PatternMatch::m_SExtOrSelf

(

const OpTy &

)

inline

Definition at line2124 of filePatternMatch.h.

Referencesm_CombineOr(), andm_SExt().

Referenced byllvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(),llvm::InstCombinerImpl::simplifyRangeCheck(), andllvm::InstCombinerImpl::visitAnd().

◆ m_Shift()

template<typenameLHS , typenameRHS >

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

inline

Matches shift operations.

Definition at line1518 of filePatternMatch.h.

Referenced bydetectShiftUntilZeroIdiom(),dropRedundantMaskingOfLeftShiftInput(),llvm::findValuesAffectedByCondition(),llvm::InstCombinerImpl::foldBinOpShiftWithShift(),foldCttzCtlz(),llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(), andllvm::InstCombinerImpl::visitZExt().

◆ m_ShiftedMask()

cst_pred_ty<is_shifted_mask > llvm::PatternMatch::m_ShiftedMask

(

)

inline

Definition at line515 of filePatternMatch.h.

Referenced byfoldNegativePower2AndShiftedMask().

◆ m_Shl()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1234 of filePatternMatch.h.

◆ m_Shr()

template<typenameLHS , typenameRHS >

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 line1525 of filePatternMatch.h.

◆ 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

MatchesShuffleVectorInst independently of mask value.

Definition at line1911 of filePatternMatch.h.

Referenced byareExtractShuffleVectors(),llvm::InstCombinerImpl::commonCastTransforms(),llvm::InstCombinerImpl::foldICmpBitCast(),foldIdentityExtractShuffle(),foldShuffledIntrinsicOperands(),llvm::InstCombinerImpl::foldVectorBinop(),foldVectorCmp(),llvm::getSplatValue(),llvm::X86TTIImpl::instCombineIntrinsic(),llvm::ARMTTIImpl::isProfitableToSinkOperands(),llvm::RISCVTTIImpl::isProfitableToSinkOperands(),llvm::WebAssemblyTTIImpl::isProfitableToSinkOperands(),narrowVectorSelect(),llvm::InstCombinerImpl::simplifyBinOpSplats(),llvm::InstCombinerImpl::SimplifyDemandedVectorElts(), andsimplifyReductionOperand().

◆ 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 line1917 of filePatternMatch.h.

◆ 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 line664 of filePatternMatch.h.

Referenced byfoldCopySignIdioms(),llvm::InstCombinerImpl::foldICmpBinOp(),llvm::isKnownToBeAPowerOfTwo(),isPowerOfTwoRecurrence(),simplifyAddInst(),simplifyICmpWithBinOp(),llvm::InstCombinerImpl::visitAnd(),llvm::InstCombinerImpl::visitOr(),llvm::InstCombinerImpl::visitSDiv(), andllvm::InstCombinerImpl::visitXor().

◆ m_Signum()

template<typename Val_t >

Signum_match< Val_t > llvm::PatternMatch::m_Signum

(

const Val_t &

)

inline

Matches a signum pattern.

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

Definition at line2927 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpOrConstant(), andllvm::InstCombinerImpl::foldICmpTruncConstant().

◆ m_SIToFP()

template<typename OpTy >

CastInst_match< OpTy,SIToFPInst > llvm::PatternMatch::m_SIToFP

(

const OpTy &

)

inline

Definition at line2156 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpBitCast(), andsimplifyUnaryIntrinsic().

◆ m_SMax()

template<typenameLHS , typenameRHS >

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

inline

Definition at line2342 of filePatternMatch.h.

Referenced bydetectSSatPattern(),detectSSatSPattern(),detectSSatUPattern(),detectUSatPattern(),foldClampRangeOfTwo(),llvm::InstCombinerImpl::foldSelectOpOp(),llvm::RecurrenceDescriptor::isMinMaxPattern(),m_MaxOrMin(),matchClamp(),simplifyICmpWithMinMax(), andtryToFPToSat().

◆ m_SMin()

template<typenameLHS , typenameRHS >

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

inline

Definition at line2348 of filePatternMatch.h.

Referenced bydetectSSatPattern(),detectSSatSPattern(),detectSSatUPattern(),detectUSatPattern(),foldClampRangeOfTwo(),llvm::InstCombinerImpl::foldICmpWithZero(),llvm::InstCombinerImpl::foldSelectOpOp(),llvm::RecurrenceDescriptor::isMinMaxPattern(),m_MaxOrMin(),matchClamp(),simplifyICmpWithMinMax(), andtryToFPToSat().

◆ m_Specific()

specificval_ty llvm::PatternMatch::m_Specific

(

const Value *

)

inline

Match if we have a specific specified value.

Definition at line885 of filePatternMatch.h.

◆ m_SpecificBB()

specific_bbval llvm::PatternMatch::m_SpecificBB

(

BasicBlock *

)

inline

Match a specific basic block value.

Definition at line1015 of filePatternMatch.h.

Referenced byfoldGuardedFunnelShift().

◆ m_SpecificCmp()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1684 of filePatternMatch.h.

◆ m_SpecificFCmp()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1702 of filePatternMatch.h.

Referenced byreassociateFCmps().

◆ m_SpecificFP()

specific_fpval llvm::PatternMatch::m_SpecificFP

(

double

)

inline

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

Definition at line928 of filePatternMatch.h.

Referenced byconvertFSqrtDivIntoFMul(),llvm::InstCombinerImpl::foldFMulReassoc(),foldMulSelectToNegate(),llvm::InstCombinerImpl::foldSquareSumFP(),getFSqrtDivOptPattern(),m_FPOne(),simplifyUnaryIntrinsic(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitFDiv(), andllvm::InstCombinerImpl::visitFMul().

◆ m_SpecificICmp()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1690 of filePatternMatch.h.

Referenced byfixReductionScalarResumeWhenVectorizingEpilog(),foldGuardedFunnelShift(),foldIsPowerOf2(),llvm::InstCombinerImpl::foldOpIntoPhi(),foldSignedTruncationCheck(),llvm::X86TargetLowering::getJumpConditionMergingParams(),matchOpWithOpEqZero(),processUse(),shouldExpandCmpArithRMWInIR(),simplifyOperationIntoSelectOperand(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitOr().

◆ m_SpecificInt()[1/2]

specific_intval< false > llvm::PatternMatch::m_SpecificInt

(

const APInt &

)

inline

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

Definition at line982 of filePatternMatch.h.

◆ m_SpecificInt()[2/2]

specific_intval64< false > llvm::PatternMatch::m_SpecificInt

(

uint64_t

)

inline

Definition at line986 of filePatternMatch.h.

◆ 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 line698 of filePatternMatch.h.

ReferencesP.

Referenced bycanNarrowShiftAmt(),llvm::InstCombinerImpl::convertOrOfShiftsToFunnelShift(),foldSelectICmpAndAnd(),foldSelectICmpLshrAshr(),foldShiftIntoShiftInAnotherHandOfAndInICmp(),foldShiftOfShiftedBinOp(),llvm::InstCombinerImpl::foldSignBitTest(),llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(),llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(),llvm::InstCombinerImpl::visitAnd(), andllvm::InstCombinerImpl::visitTrunc().

◆ m_SpecificIntAllowPoison()[1/2]

specific_intval<true > llvm::PatternMatch::m_SpecificIntAllowPoison

(

const APInt &

)

inline

Definition at line990 of filePatternMatch.h.

Referenced bycanonicalizeSaturatedAdd(),llvm::InstCombinerImpl::convertOrOfShiftsToFunnelShift(),llvm::InstCombinerImpl::foldAddWithConstant(),foldAndOrOfICmpEqConstantAndICmp(),llvm::InstCombinerImpl::foldICmpBinOp(),llvm::InstCombinerImpl::FoldShiftByConstant(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitAShr(),llvm::InstCombinerImpl::visitICmpInst(),llvm::InstCombinerImpl::visitLShr(),llvm::InstCombinerImpl::visitMul(), andllvm::InstCombinerImpl::visitSExt().

◆ m_SpecificIntAllowPoison()[2/2]

specific_intval64<true > llvm::PatternMatch::m_SpecificIntAllowPoison

(

uint64_t

)

inline

Definition at line994 of filePatternMatch.h.

◆ m_Sqrt()

template<typename Opnd0 >

m_Intrinsic_Ty< Opnd0 >::Ty llvm::PatternMatch::m_Sqrt

(

const Opnd0 &

Op0

)

inline

Definition at line2736 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldFMulReassoc(),foldSqrtWithFcmpZero(),getFSqrtDivOptPattern(), andsimplifyFMAFMul().

◆ m_SRem()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1204 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),llvm::InstCombinerImpl::commonShiftTransforms(),llvm::computeOverflowForSignedSub(),isDivZero(),MatchRem(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitLShr(), andllvm::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

MatchesStoreInst.

Definition at line1930 of filePatternMatch.h.

Referenced byllvm::findHistogram(), andllvm::slpvectorizer::BoUpSLP::isLoadCombineCandidate().

◆ m_StrictlyPositive()[1/2]

cst_pred_ty<is_strictlypositive > llvm::PatternMatch::m_StrictlyPositive

(

)

inline

Match an integer or vector of strictly positive values.

For vectors, this includes constants with undefined elements.

Definition at line570 of filePatternMatch.h.

◆ m_StrictlyPositive()[2/2]

api_pred_ty<is_strictlypositive > llvm::PatternMatch::m_StrictlyPositive

(

const APInt *&

)

inline

Definition at line573 of filePatternMatch.h.

◆ m_Sub()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1114 of filePatternMatch.h.

◆ m_Trunc()

template<typename OpTy >

CastInst_match< OpTy,TruncInst > llvm::PatternMatch::m_Trunc

(

const OpTy &

)

inline

Matches Trunc.

Definition at line2075 of filePatternMatch.h.

◆ m_TruncOrSelf()

template<typename OpTy >

match_combine_or<CastInst_match< OpTy,TruncInst >, OpTy > llvm::PatternMatch::m_TruncOrSelf

(

const OpTy &

)

inline

Definition at line2095 of filePatternMatch.h.

Referencesm_CombineOr(), andm_Trunc().

Referenced byllvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(),foldShiftIntoShiftInAnotherHandOfAndInICmp(),llvm::InstCombinerImpl::foldSignBitTest(),llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(),llvm::InstCombinerImpl::visitAdd(), andllvm::InstCombinerImpl::visitXor().

◆ m_UAddWithOverflow()

template<typenameLHS_t , typenameRHS_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 line2548 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::visitICmpInst().

◆ m_UDiv()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1180 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::commonIDivTransforms(),llvm::InstCombinerImpl::foldICmpCommutative(),llvm::InstCombinerImpl::foldMultiplicationOverflowCheck(),isTruePredicate(),MatchDiv(),simplifyDivRem(),simplifyICmpWithBinOpOnLHS(),llvm::InstCombinerImpl::visitGetElementPtrInst(), andllvm::InstCombinerImpl::visitMul().

◆ m_UIToFP()

template<typename OpTy >

CastInst_match< OpTy,UIToFPInst > llvm::PatternMatch::m_UIToFP

(

const OpTy &

)

inline

Definition at line2151 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpBitCast(),llvm::AArch64TargetLowering::lowerInterleavedLoad(),simplifyICmpWithConstant(),simplifyUnaryIntrinsic(), andllvm::InstCombinerImpl::visitFMul().

◆ m_UMax()

template<typenameLHS , typenameRHS >

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

inline

Definition at line2354 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldAddWithConstant(),foldClampRangeOfTwo(),llvm::InstCombinerImpl::foldSelectOpOp(),llvm::RecurrenceDescriptor::isMinMaxPattern(),m_MaxOrMin(),matchClamp(), andsimplifyICmpWithMinMax().

◆ m_UMin()

template<typenameLHS , typenameRHS >

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

inline

Definition at line2360 of filePatternMatch.h.

Referenced bycombineShiftRightArithmetic(),detectSSatUPattern(),detectUSatPattern(),detectUSatUPattern(),foldClampRangeOfTwo(),llvm::InstCombinerImpl::foldSelectOpOp(),foldSubOfMinMax(),foldToUnsignedSaturatedAdd(),llvm::RecurrenceDescriptor::isMinMaxPattern(),m_MaxOrMin(),matchClamp(),processUse(), andsimplifyICmpWithMinMax().

◆ m_UnconditionalBr()

br_match llvm::PatternMatch::m_UnconditionalBr

(

BasicBlock *&

Succ

)

inline

Definition at line2199 of filePatternMatch.h.

Referenced bytryToMoveFreeBeforeNullTest().

◆ 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 line152 of filePatternMatch.h.

◆ m_UndefValue()[1/2]

class_match<UndefValue > llvm::PatternMatch::m_UndefValue

(

)

inline

Match an arbitraryUndefValue constant.

Definition at line155 of filePatternMatch.h.

◆ m_UndefValue()[2/2]

bind_ty<UndefValue > llvm::PatternMatch::m_UndefValue

(

UndefValue *&

)

inline

Match anUndefValue, capturing the value if we match.

Definition at line841 of filePatternMatch.h.

◆ m_Unless()

template<typename Ty >

match_unless< Ty > llvm::PatternMatch::m_Unless

(

const Ty &

)

inline

Match if the inner matcher doesNOT match.

Definition at line203 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldICmpEquality(),getBundleFromUse(),m_ImmConstant(), andllvm::InstCombinerImpl::visitXor().

◆ m_UnOp()[1/3]

class_match<UnaryOperator > llvm::PatternMatch::m_UnOp

(

)

inline

Match an arbitrary unary operation and ignore it.

Definition at line95 of filePatternMatch.h.

Referenced bycheapToScalarize(),llvm::InstCombinerImpl::visitCallInst(), andllvm::InstCombinerImpl::visitExtractElementInst().

◆ m_UnOp()[2/3]

template<typename OP_t >

AnyUnaryOp_match< OP_t > llvm::PatternMatch::m_UnOp

(

const OP_t &

)

inline

Definition at line1070 of filePatternMatch.h.

ReferencesX.

◆ m_UnOp()[3/3]

bind_ty<UnaryOperator > llvm::PatternMatch::m_UnOp

(

UnaryOperator *&

)

inline

Match a unary operator, capturing it if we match.

Definition at line828 of filePatternMatch.h.

ReferencesI.

◆ m_UnordFMax()

template<typenameLHS , typenameRHS >

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

inline

Match an 'unordered' floating point maximum function.

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

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

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

Definition at line2417 of filePatternMatch.h.

◆ m_UnordFMin()

template<typenameLHS , typenameRHS >

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

inline

Match an 'unordered' floating point minimum function.

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

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

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

Definition at line2432 of filePatternMatch.h.

◆ m_URem()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1198 of filePatternMatch.h.

Referenced bycanScalarizeAccess(),llvm::InstCombinerImpl::commonIDivTransforms(),llvm::computeOverflowForUnsignedSub(),llvm::InstCombinerImpl::foldICmpWithZero(),isRemOfLoopIncrementWithLoopInvariant(),MatchRem(), andsimplifyICmpWithBinOpOnLHS().

◆ m_Value()[1/3]

class_match<Value > llvm::PatternMatch::m_Value

(

)

inline

Match an arbitrary value and ignore it.

Definition at line92 of filePatternMatch.h.

◆ m_Value()[2/3]

bind_ty<const Value > llvm::PatternMatch::m_Value

(

const Value *&

)

inline

Definition at line823 of filePatternMatch.h.

◆ m_Value()[3/3]

bind_ty<Value > llvm::PatternMatch::m_Value

(

Value *&

)

inline

Match a value, capturing it if we match.

Definition at line822 of filePatternMatch.h.

◆ m_VecReverse()

template<typename Opnd0 >

m_Intrinsic_Ty< Opnd0 >::Ty llvm::PatternMatch::m_VecReverse

(

const Opnd0 &

Op0

)

inline

Definition at line2747 of filePatternMatch.h.

Referenced byllvm::InstCombinerImpl::foldVectorBinop(),foldVectorCmp(),simplifyReductionOperand(),simplifyUnaryIntrinsic(), andllvm::InstCombinerImpl::visitCallInst().

◆ m_VScale()

VScaleVal_match llvm::PatternMatch::m_VScale

(

)

inline

Definition at line3010 of filePatternMatch.h.

Referenced byareBothVScale(),llvm::VPIntrinsic::canIgnoreVectorLengthParam(),llvm::SelectionDAGBuilder::getValueImpl(),llvm::isKnownToBeAPowerOfTwo(),shouldSinkVScale(),llvm::InstCombinerImpl::visitSExt(),llvm::InstCombinerImpl::visitTrunc(), andllvm::InstCombinerImpl::visitZExt().

◆ m_WithOverflowInst()[1/2]

bind_ty<const WithOverflowInst > llvm::PatternMatch::m_WithOverflowInst

(

const WithOverflowInst *&

)

inline

Definition at line836 of filePatternMatch.h.

ReferencesI.

◆ m_WithOverflowInst()[2/2]

bind_ty<WithOverflowInst > llvm::PatternMatch::m_WithOverflowInst

(

WithOverflowInst *&

)

inline

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

Definition at line832 of filePatternMatch.h.

ReferencesI.

Referenced bydirectlyImpliesPoison(),isKnownNonZeroFromOperator(),llvm::patchReplacementInstruction(), andllvm::InstCombinerImpl::visitOr().

◆ m_Xor()

template<typenameLHS , typenameRHS >

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

inline

Definition at line1228 of filePatternMatch.h.

◆ 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 line612 of filePatternMatch.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 line599 of filePatternMatch.h.

Referenced byllvm::AMDGPURegisterBankInfo::applyMappingMAD_64_32(),BitOp3_Op(),foldGuardedFunnelShift(),foldICmpOfUAddOv(),foldICmpPow2Test(),foldInsEltIntoSplat(),foldIsPowerOf2(),foldIsPowerOf2OrZero(),foldSubOfMinMax(),getAlternateBinop(),llvm::getSplatValue(),instCombineSVEAllOrNoActive(),instCombineSVENoActiveReplace(),instCombineSVENoActiveUnaryErase(),instCombineSVENoActiveZero(),llvm::ARMTTIImpl::isProfitableToSinkOperands(),llvm::RISCVTTIImpl::isProfitableToSinkOperands(),llvm::WebAssemblyTTIImpl::isProfitableToSinkOperands(),m_Neg(),m_NSWNeg(),llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(),matchSelectPattern(),matchUAddWithOverflowConstantEdgeCases(),matchZeroExtendFromS32(),shouldExpandCmpArithRMWInIR(),simplifyAndOrOfICmpsWithCtpop(),simplifyLdexp(),simplifySelectInst(),simplifyX86addcarry(),tryToRecognizeTableBasedCttz(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitCallInst(),llvm::InstCombinerImpl::visitOr(), andllvm::InstCombinerImpl::visitSub().

◆ m_ZExt()

template<typename OpTy >

CastInst_match< OpTy,ZExtInst > llvm::PatternMatch::m_ZExt

(

const OpTy &

)

inline

Matches ZExt.

Definition at line2107 of filePatternMatch.h.

◆ m_ZExtOrSelf()

template<typename OpTy >

match_combine_or<CastInst_match< OpTy,ZExtInst >, OpTy > llvm::PatternMatch::m_ZExtOrSelf

(

const OpTy &

)

inline

Definition at line2118 of filePatternMatch.h.

Referencesm_CombineOr(), andm_ZExt().

Referenced byllvm::InstCombinerImpl::canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(),dropRedundantMaskingOfLeftShiftInput(),foldShiftIntoShiftInAnotherHandOfAndInICmp(),llvm::InstCombinerImpl::foldVariableSignZeroExtensionOfVariableHighBitExtract(),llvm::InstCombinerImpl::reassociateShiftAmtsOfTwoSameDirectionShifts(),tryToRecognizeTableBasedCttz(),llvm::InstCombinerImpl::visitAdd(),llvm::InstCombinerImpl::visitAnd(), andllvm::InstCombinerImpl::visitSub().

◆ m_ZExtOrSExt()

template<typename OpTy >

match_combine_or<CastInst_match< OpTy,ZExtInst >,CastInst_match< OpTy,SExtInst > > llvm::PatternMatch::m_ZExtOrSExt

(

const OpTy &

)

inline

Definition at line2138 of filePatternMatch.h.

Referencesm_CombineOr(),m_SExt(), andm_ZExt().

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

)

inline

Definition at line2146 of filePatternMatch.h.

Referencesm_CombineOr(), andm_ZExtOrSExt().

Referenced byllvm::findHistogram(), andllvm::InstCombinerImpl::visitCallInst().

◆ match()[1/2]

template<typenamePattern >

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

Definition at line53 of filePatternMatch.h.

Referencesmatch(), andP.

◆ match()[2/2]

template<typename Val , typenamePattern >

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

Definition at line49 of filePatternMatch.h.

Referencesmatch(), andP.

Movatterモバイル変換

Classes

Typedefs

Functions

Typedef Documentation

◆ cst_pred_ty

◆ cstfp_pred_ty

Function Documentation

◆ m_Add()

◆ m_AddLike()

◆ m_AllOnes()

◆ m_AllOnesForbidPoison()

◆ m_AllowReassoc()

◆ m_And()

◆ m_AnyIntegralConstant()

◆ m_AnyZeroFP()

◆ m_APFloat()

◆ m_APFloatAllowPoison()

◆ m_APFloatForbidPoison()

◆ m_APInt()

◆ m_APIntAllowPoison()

◆ m_APIntForbidPoison()

◆ m_Argument()

◆ m_AShr()

◆ m_BasicBlock()[1/3]

◆ m_BasicBlock()[2/3]

◆ m_BasicBlock()[3/3]

◆ m_BinOp()[1/4]

◆ m_BinOp()[2/4]

◆ m_BinOp()[3/4]

◆ m_BinOp()[4/4]

◆ m_BitCast()

◆ m_BitReverse()

◆ m_BitwiseLogic()

◆ m_Br()[1/2]

◆ m_Br()[2/2]

◆ m_BSwap()

◆ m_c_Add()

◆ m_c_And()

◆ m_c_BinOp()[1/2]

◆ m_c_BinOp()[2/2]

◆ m_c_BitwiseLogic()

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

◆ m_CheckedFp()[2/2]

◆ m_CheckedInt()[1/2]

◆ m_CheckedInt()[2/2]

◆ m_Cmp()[1/3]

◆ m_Cmp()[2/3]

◆ m_Cmp()[3/3]

◆ m_CombineAnd()

◆ m_CombineOr()

◆ m_Constant()[1/2]

◆ m_Constant()[2/2]

◆ m_ConstantExpr()[1/2]

◆ m_ConstantExpr()[2/2]

◆ m_ConstantFP()[1/2]

◆ m_ConstantFP()[2/2]

◆ m_ConstantInt()[1/4]

◆ m_ConstantInt()[2/4]