Classes
struct	AnyBinaryOp_match

struct	apfloat_match

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

struct	apint_match

struct	Argument_match

struct	BinaryOp_match

struct	bind_const_intval_ty

struct	bind_ty

struct	BinOpPred_match

struct	br_match

struct	brc_match

struct	CastClass_match

struct	class_match

struct	CmpClass_match

struct	constantint_match

struct	cst_pred_ty
	This helper class is used to match scalar and vector integer constants that satisfy a specified predicate. More...

struct	cstfp_pred_ty
	This helper class is used to match scalar and vector floating-point constants that satisfy a specified predicate. More...

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

struct	Exact_match

struct	FNeg_match

struct	IntrinsicID_match
	Intrinsic matchers. More...

struct	is_all_ones

struct	is_any_zero_fp

struct	is_bitwiselogic_op

struct	is_idiv_op

struct	is_logical_shift_op

struct	is_lowbit_mask

struct	is_maxsignedvalue

struct	is_nan

struct	is_neg_zero_fp

struct	is_negative

struct	is_nonnegative

struct	is_one

struct	is_pos_zero_fp

struct	is_power2

struct	is_power2_or_zero

struct	is_right_shift_op

struct	is_shift_op

struct	is_sign_mask

struct	is_zero

struct	is_zero_int

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

struct	m_Intrinsic_Ty< T0 >

struct	m_Intrinsic_Ty< T0, T1 >

struct	m_Intrinsic_Ty< T0, T1, T2 >

struct	m_Intrinsic_Ty< T0, T1, T2, T3 >

struct	match_combine_and

struct	match_combine_or
	Matching combinators. More...

struct	MaxMin_match

struct	ofmax_pred_ty
	Helper class for identifying ordered max predicates. More...

struct	ofmin_pred_ty
	Helper class for identifying ordered min predicates. More...

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

struct	OneUse_match

struct	OverflowingBinaryOp_match

struct	Signum_match

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

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

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

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

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

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

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

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

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

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

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

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

class_match< UndefValue >	m_Undef ()
	Match an arbitrary undef constant. More...

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

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

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

apint_match	m_APInt (const APInt *&Res)
	Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt. More...

apfloat_match	m_APFloat (const APFloat *&Res)
	Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat. More...

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

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

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

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

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

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

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

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

cst_pred_ty< is_zero_int >	m_ZeroInt ()
	Match an integer 0 or a vector with all elements equal to 0. More...

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

cst_pred_ty< is_power2 >	m_Power2 ()
	Match an integer or vector power-of-2. More...

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

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

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

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

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

cstfp_pred_ty< is_nan >	m_NaN ()
	Match an arbitrary NaN constant. More...

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

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

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

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

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

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

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

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

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

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

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

deferredval_ty< Value >	m_Deferred (Value *const &V)
	A commutative-friendly version of m_Specific(). More...

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

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

specific_fpval	m_FPOne ()
	Match a float 1.0 or vector with all elements equal to 1.0. More...

specific_intval	m_SpecificInt (uint64_t V)
	Match a specific integer value or vector with all elements equal to the value. More...

bind_const_intval_ty	m_ConstantInt (uint64_t &V)
	Match a ConstantInt and bind to its value. More...

template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS >	m_BinOp (const LHS &L, const RHS &R)

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

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

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

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

template<typename OpTy >
FNeg_match< OpTy >	m_FNeg (const OpTy &X)
	Match 'fneg X' as 'fsub -0.0, X'. More...

template<typename RHS >
BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub >	m_FNegNSZ (const RHS &X)
	Match 'fneg X' as 'fsub +-0.0, X'. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename Cond , typename LHS , typename RHS >
ThreeOps_match< Cond, LHS, RHS, Instruction::Select >	m_Select (const Cond &C, const LHS &L, const RHS &R)
	Matches SelectInst. More...

template<int64_t L, int64_t R, typename Cond >
ThreeOps_match< Cond, constantint_match< L >, constantint_match< R >, Instruction::Select >	m_SelectCst (const Cond &C)
	This matches a select of two constants, e.g. More...

template<typename Val_t , typename Elt_t , typename Idx_t >
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement >	m_InsertElement (const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
	Matches InsertElementInst. More...

template<typename Val_t , typename Idx_t >
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement >	m_ExtractElement (const Val_t &Val, const Idx_t &Idx)
	Matches ExtractElementInst. More...

template<typename V1_t , typename V2_t , typename Mask_t >
ThreeOps_match< V1_t, V2_t, Mask_t, Instruction::ShuffleVector >	m_ShuffleVector (const V1_t &v1, const V2_t &v2, const Mask_t &m)
	Matches ShuffleVectorInst. More...

template<typename OpTy >
OneOps_match< OpTy, Instruction::Load >	m_Load (const OpTy &Op)
	Matches LoadInst. More...

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

template<typename OpTy >
CastClass_match< OpTy, Instruction::BitCast >	m_BitCast (const OpTy &Op)
	Matches BitCast. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::PtrToInt >	m_PtrToInt (const OpTy &Op)
	Matches PtrToInt. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::Trunc >	m_Trunc (const OpTy &Op)
	Matches Trunc. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::SExt >	m_SExt (const OpTy &Op)
	Matches SExt. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::ZExt >	m_ZExt (const OpTy &Op)
	Matches ZExt. More...

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

template<typename OpTy >
CastClass_match< OpTy, Instruction::UIToFP >	m_UIToFP (const OpTy &Op)
	Matches UIToFP. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::SIToFP >	m_SIToFP (const OpTy &Op)
	Matches SIToFP. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::FPTrunc >	m_FPTrunc (const OpTy &Op)
	Matches FPTrunc. More...

template<typename OpTy >
CastClass_match< OpTy, Instruction::FPExt >	m_FPExt (const OpTy &Op)
	Matches FPExt. More...

br_match	m_UnconditionalBr (BasicBlock *&Succ)

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

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

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

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

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

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

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

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

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

template<typename LHS_t , typename RHS_t , typename Sum_t >
UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >	m_UAddWithOverflow (const LHS_t &L, const RHS_t &R, const Sum_t &S)
	Match an icmp instruction checking for unsigned overflow on addition. More...

template<unsigned OpI, typename Opnd_t >
Argument_match< Opnd_t >	m_Argument (const Opnd_t &Op)
	Match an argument. More...

template<Intrinsic::ID IntrID>
IntrinsicID_match	m_Intrinsic ()
	Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X)) More...

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

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

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

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

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

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

template<typename Opnd0 >
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 LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS, true >	m_c_BinOp (const LHS &L, const RHS &R)
	Matches a BinaryOperator with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true >	m_c_ICmp (ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
	Matches an ICmp with a predicate over LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Add, true >	m_c_Add (const LHS &L, const RHS &R)
	Matches a Add with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Mul, true >	m_c_Mul (const LHS &L, const RHS &R)
	Matches a Mul with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::And, true >	m_c_And (const LHS &L, const RHS &R)
	Matches an And with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Or, true >	m_c_Or (const LHS &L, const RHS &R)
	Matches an Or with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Xor, true >	m_c_Xor (const LHS &L, const RHS &R)
	Matches an Xor with LHS and RHS in either order. More...

template<typename ValTy >
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub >	m_Neg (const ValTy &V)
	Matches a 'Neg' as 'sub 0, V'. More...

template<typename ValTy >
BinaryOp_match< ValTy, cst_pred_ty< is_all_ones >, Instruction::Xor, true >	m_Not (const ValTy &V)
	Matches a 'Not' as 'xor V, -1' or 'xor -1, V'. More...

template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true >	m_c_SMin (const LHS &L, const RHS &R)
	Matches an SMin with LHS and RHS in either order. More...

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

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

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

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FAdd, true >	m_c_FAdd (const LHS &L, const RHS &R)
	Matches FAdd with LHS and RHS in either order. More...

template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FMul, true >	m_c_FMul (const LHS &L, const RHS &R)
	Matches FMul with LHS and RHS in either order. More...

template<typename Val_t >
Signum_match< Val_t >	m_Signum (const Val_t &V)
	Matches a signum pattern. More...

Function Documentation

◆ m_Add()

template<typename LHS , typename RHS >

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

inline

Definition at line 641 of file PatternMatch.h.

Referenced by canNarrowShiftAmt(), canonicalizeLowbitMask(), canonicalizeSaturatedAdd(), checkForNegativeOperand(), llvm::InstCombiner::commonShiftTransforms(), computeKnownBitsFromOperator(), llvm::JumpThreadingPass::ComputeValueKnownInPredecessorsImpl(), llvm::createSeparateConstOffsetFromGEPPass(), llvm::findScalarElement(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), foldSignedTruncationCheck(), foldToUnsignedSaturatedAdd(), getValueFromICmpCondition(), isGEPFoldable(), isKnownNonZero(), isKnownToBeAPowerOfTwo(), isSupportedGuardInstruction(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), matchesAdd(), matchUAddWithOverflowConstantEdgeCases(), processUGT_ADDCST_ADD(), simplifyAndOfICmpsWithAdd(), simplifyOrOfICmpsWithAdd(), SimplifySubInst(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitXor().

◆ m_AllOnes()

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

inline

Match an integer or vector with all bits set.

For vectors, this includes constants with undefined elements.

Definition at line 308 of file PatternMatch.h.

Referenced by areInverseVectorBitmasks(), canonicalizeLowbitMask(), canonicalizeSaturatedAdd(), foldICmpBitCast(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), foldNoWrapAdd(), foldSelectICmpAndOr(), foldXorToXor(), m_Not(), matchSelectPattern(), matchUAddWithOverflowConstantEdgeCases(), SimplifyAddInst(), SimplifyAndInst(), SimplifyAShrInst(), simplifyBinaryIntrinsic(), SimplifyGEPInst(), simplifyICmpWithConstant(), SimplifyOrInst(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitSDiv(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitXor(), and llvm::InstCombiner::visitZExt().

◆ m_And()

template<typename LHS , typename RHS >

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

inline

Definition at line 756 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAdd(), checkForNegativeOperand(), foldAndOrOfEqualityCmpsWithConstants(), foldAnyOrAllBitsSet(), foldICmpWithMinMax(), foldOrToXor(), foldSelectICmpAnd(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), llvm::InstCombiner::FoldShiftByConstant(), foldSignedTruncationCheck(), foldVecTruncToExtElt(), foldXorToXor(), getMaskedTypeForICmpPair(), isImpliedCondAndOr(), isKnownToBeAPowerOfTwo(), isOnlyReachableViaThisEdge(), isSupportedGuardInstruction(), matchAndOrChain(), MatchRem(), matchRotate(), normalizePredicate(), llvm::parseWidenableBranch(), processUMulZExtIdiom(), replaceAllUsesOfWithIn(), llvm::InstCombiner::replacedSelectWithOperand(), scaleWeights(), SimplifyOrInst(), simplifySelectBitTest(), simplifySelectWithICmpCond(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitXor(), and llvm::InstCombiner::visitZExt().

◆ m_AnyZeroFP()

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

inline

Match a floating-point negative zero or positive zero.

For vectors, this includes constants with undefined elements.

Definition at line 435 of file PatternMatch.h.

Referenced by foldFCmpReciprocalAndZero(), foldSelectBinOpIdentity(), m_FNegNSZ(), matchSelectPattern(), reassociateFCmps(), SimplifyFAddInst(), SimplifyFCmpInst(), SimplifyFDivInst(), SimplifyFMulInst(), SimplifyFSubInst(), and llvm::InstCombiner::visitFCmpInst().

◆ m_APFloat()

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

inline

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

Definition at line 179 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), foldFCmpReciprocalAndZero(), getPow(), getSqrtCall(), matchFastFloatClamp(), simplifyBinaryIntrinsic(), SimplifyFCmpInst(), llvm::InstCombiner::visitCallInst(), and llvm::InstCombiner::visitFCmpInst().

◆ m_APInt()

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

inline

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

Definition at line 175 of file PatternMatch.h.

◆ m_Argument()

template<unsigned OpI, typename Opnd_t >

Argument_match<Opnd_t> llvm::PatternMatch::m_Argument ( const Opnd_t & Op )

inline

Match an argument.

Definition at line 1518 of file PatternMatch.h.

◆ m_AShr()

template<typename LHS , typename RHS >

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

inline

Definition at line 786 of file PatternMatch.h.

Referenced by EvaluateConstantChrecAtConstant(), foldICmpWithMinMax(), foldICmpWithTruncSignExtendedVal(), foldNoWrapAdd(), GetLoopInvariantInsertPosition(), llvm::PatternMatch::Signum_match< Opnd_t >::match(), SimplifyGEPInst(), llvm::InstCombiner::visitAShr(), llvm::InstCombiner::visitGetElementPtrInst(), llvm::InstCombiner::visitSExt(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitXor().

◆ m_BinOp() [1/3]

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

inline

Match an arbitrary binary operation and ignore it.

Definition at line 73 of file PatternMatch.h.

Referenced by cheapToScalarize(), createRdxShuffleMask(), foldAndToXor(), foldBitCastBitwiseLogic(), foldSelectBinOpIdentity(), foldSelectShuffle(), foldSelectShuffleWith1Binop(), foldVecTruncToExtElt(), getReductionData(), llvm::isSplatValue(), matchRotate(), matchUAddWithOverflowConstantEdgeCases(), reassociateFCmps(), scaleWeights(), ShrinkDemandedConstant(), simplifyAssocCastAssoc(), llvm::InstCombiner::visitExtractElementInst(), and llvm::InstCombiner::visitXor().

◆ m_BinOp() [2/3]

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

inline

Match a binary operator, capturing it if we match.

Definition at line 480 of file PatternMatch.h.

References I.

◆ m_BinOp() [3/3]

template<typename LHS , typename RHS >

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

inline

Definition at line 606 of file PatternMatch.h.

References llvm::MCID::Commutable.

◆ m_BitCast()

template<typename OpTy >

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

inline

Matches BitCast.

Definition at line 1157 of file PatternMatch.h.

Referenced by combineLoadToNewType(), findAffectedValues(), foldBitCastBitwiseLogic(), foldBitcastExtElt(), foldVecTruncToExtElt(), removeBitcastsFromLoadStoreOnMinMax(), simplifyICmpWithConstant(), and llvm::InstCombiner::visitInsertElementInst().

◆ m_BitReverse()

template<typename Opnd0 >

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

inline

Definition at line 1597 of file PatternMatch.h.

Referenced by foldCtpop(), foldCttzCtlz(), foldICmpWithMinMax(), and simplifyUnaryIntrinsic().

◆ m_BitwiseLogic()

template<typename LHS , typename RHS >

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

inline

Matches bitwise logic operations.

Definition at line 955 of file PatternMatch.h.

◆ m_Br()

template<typename Cond_t >

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

inline

Definition at line 1256 of file PatternMatch.h.

References C, F(), and T.

Referenced by foldGuardedRotateToFunnelShift(), llvm::SCEVExpander::getRelatedExistingExpansion(), llvm::parseWidenableBranch(), processUGT_ADDCST_ADD(), scaleWeights(), tryToMoveFreeBeforeNullTest(), and llvm::InstCombiner::visitBranchInst().

◆ m_BSwap()

template<typename Opnd0 >

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

inline

Definition at line 1602 of file PatternMatch.h.

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

◆ m_c_Add()

template<typename LHS , typename RHS >

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

inline

Matches a Add with LHS and RHS in either order.

Definition at line 1649 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAdd(), foldICmpWithTruncSignExtendedVal(), foldToUnsignedSaturatedAdd(), SimplifyOrInst(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitXor().

◆ m_c_And()

template<typename LHS , typename RHS >

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

inline

Matches an And with LHS and RHS in either order.

Definition at line 1663 of file PatternMatch.h.

Referenced by llvm::collectCmpOps(), computeKnownBitsFromAssume(), foldAndToXor(), foldAnyOrAllBitsSet(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), foldOrToXor(), foldSelectICmpAndAnd(), foldXorToXor(), llvm::haveNoCommonBitsSet(), lookThroughAnd(), simplifyAndOrOfICmpsWithZero(), simplifyICmpWithBinOp(), SimplifyOrInst(), llvm::InstCombiner::visitAdd(), visitMaskedMerge(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitXor().

◆ m_c_BinOp()

template<typename LHS , typename RHS >

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

inline

Matches a BinaryOperator with LHS and RHS in either order.

Definition at line 1634 of file PatternMatch.h.

Referenced by computeKnownBitsFromOperator(), foldSelectBinOpIdentity(), shouldMergeGEPs(), llvm::InstCombiner::visitAdd(), and llvm::InstCombiner::visitAnd().

◆ m_c_FAdd()

template<typename LHS , typename RHS >

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

inline

Matches FAdd with LHS and RHS in either order.

Definition at line 1724 of file PatternMatch.h.

Referenced by SimplifyFSubInst(), and llvm::InstCombiner::visitFSub().

◆ m_c_FMul()

template<typename LHS , typename RHS >

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

inline

Matches FMul with LHS and RHS in either order.

Definition at line 1731 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), SimplifyFDivInst(), llvm::InstCombiner::visitFDiv(), and llvm::InstCombiner::visitFMul().

◆ m_c_ICmp()

template<typename LHS , typename RHS >

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

inline

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

Does not swap the predicate.

Definition at line 1642 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), and isKnownNonNullFromDominatingCondition().

◆ m_c_Mul()

template<typename LHS , typename RHS >

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

inline

Matches a Mul with LHS and RHS in either order.

Definition at line 1656 of file PatternMatch.h.

Referenced by llvm::InstCombiner::commonIDivTransforms(), simplifyDiv(), llvm::InstCombiner::visitMul(), and llvm::InstCombiner::visitSub().

◆ m_c_Or()

template<typename LHS , typename RHS >

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

inline

Matches an Or with LHS and RHS in either order.

Definition at line 1670 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), foldAndToXor(), foldGuardedRotateToFunnelShift(), foldOrToXor(), foldXorToXor(), SimplifyAndInst(), simplifyICmpWithBinOp(), SimplifyLShrInst(), splitMergedValStore(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitTrunc(), and llvm::InstCombiner::visitXor().

◆ m_c_SMax()

template<typename LHS , typename RHS >

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

inline

Matches an SMax with LHS and RHS in either order.

Definition at line 1705 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_SMin()

template<typename LHS , typename RHS >

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

inline

Matches an SMin with LHS and RHS in either order.

Definition at line 1699 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_UMax()

template<typename LHS , typename RHS >

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

inline

Matches a UMax with LHS and RHS in either order.

Definition at line 1717 of file PatternMatch.h.

Referenced by foldICmpWithMinMax().

◆ m_c_UMin()

template<typename LHS , typename RHS >

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

inline

Matches a UMin with LHS and RHS in either order.

Definition at line 1711 of file PatternMatch.h.

Referenced by foldICmpWithMinMax(), and foldToUnsignedSaturatedAdd().

◆ m_c_Xor()

template<typename LHS , typename RHS >

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

inline

Matches an Xor with LHS and RHS in either order.

Definition at line 1677 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), foldXorToXor(), m_Not(), SimplifyOrInst(), llvm::InstCombiner::visitAnd(), visitMaskedMerge(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitXor().

◆ m_Cmp() [1/2]

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

inline

Matches any compare instruction and ignore it.

Definition at line 78 of file PatternMatch.h.

Referenced by cheapToScalarize(), llvm::collectCmpOps(), foldSelectBinOpIdentity(), isEqualImpl(), isMinMaxWithLoads(), scaleWeights(), llvm::InstCombiner::visitBranchInst(), llvm::InstCombiner::visitExtractElementInst(), and llvm::InstCombiner::visitXor().

◆ m_Cmp() [2/2]

template<typename LHS , typename RHS >

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

inline

Definition at line 1015 of file PatternMatch.h.

◆ m_CombineAnd()

template<typename LTy , typename RTy >

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

inline

Combine two pattern matchers matching L && R.

Definition at line 129 of file PatternMatch.h.

Referenced by foldICmpWithLowBitMaskedVal(), m_Intrinsic(), SimplifyAndInst(), and visitMaskedMerge().

◆ m_CombineOr()

template<typename LTy , typename RTy >

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

inline

Combine two pattern matchers matching L || R.

Definition at line 123 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldVecTruncToExtElt(), m_ZExtOrSExt(), markAliveBlocks(), matchFastFloatClamp(), matchSelectPattern(), scaleWeights(), SimplifyMulInst(), simplifySelectWithICmpCond(), and tryToMoveFreeBeforeNullTest().

◆ m_Constant() [1/2]

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

inline

Match an arbitrary Constant and ignore it.

Definition at line 89 of file PatternMatch.h.

◆ m_Constant() [2/2]

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

inline

Match a Constant, capturing the value if we match.

Definition at line 486 of file PatternMatch.h.

References C.

◆ m_ConstantFP()

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

inline

Match a ConstantFP, capturing the value if we match.

Definition at line 489 of file PatternMatch.h.

References C.

◆ m_ConstantInt() [1/3]

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

inline

Match an arbitrary ConstantInt and ignore it.

Match a ConstantInt with a specific value.

Definition at line 81 of file PatternMatch.h.

◆ m_ConstantInt() [2/3]

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

inline

Match a ConstantInt, capturing the value if we match.

Definition at line 483 of file PatternMatch.h.

◆ m_ConstantInt() [3/3]

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

inline

Match a ConstantInt and bind to its value.

This does not match ConstantInts wider than 64-bits.

Definition at line 582 of file PatternMatch.h.

◆ m_Deferred() [1/2]

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

inline

A commutative-friendly version of m_Specific().

Definition at line 514 of file PatternMatch.h.

Referenced by computeKnownBitsFromOperator(), foldAndToXor(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), foldToUnsignedSaturatedAdd(), foldXorToXor(), simplifySelectWithICmpCond(), llvm::InstCombiner::visitAdd(), visitMaskedMerge(), llvm::InstCombiner::visitTrunc(), and llvm::InstCombiner::visitXor().

◆ m_Deferred() [2/2]

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

inline

Definition at line 515 of file PatternMatch.h.

◆ m_Exact()

template<typename T >

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

inline

Definition at line 981 of file PatternMatch.h.

References llvm::PatternMatch::OneUse_match< SubPattern_t >::SubPattern.

Referenced by isKnownNonZero(), isKnownToBeAPowerOfTwo(), SimplifyMulInst(), SimplifyShlInst(), llvm::InstCombiner::visitShl(), and llvm::InstCombiner::visitUDiv().

◆ m_ExtractElement()

template<typename Val_t , typename Idx_t >

TwoOps_match<Val_t, Idx_t, Instruction::ExtractElement> llvm::PatternMatch::m_ExtractElement	(	const Val_t &	Val,
		const Idx_t &	Idx
	)

inline

Matches ExtractElementInst.

Definition at line 1113 of file PatternMatch.h.

Referenced by llvm::SimplifyInsertElementInst(), and llvm::InstCombiner::visitInsertElementInst().

◆ m_FAbs()

template<typename Opnd0 >

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

inline

Definition at line 1607 of file PatternMatch.h.

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

◆ m_FAdd()

template<typename LHS , typename RHS >

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

inline

Definition at line 647 of file PatternMatch.h.

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

◆ m_FCanonicalize()

template<typename Opnd0 >

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

inline

Definition at line 1612 of file PatternMatch.h.

◆ m_FCmp()

template<typename LHS , typename RHS >

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

inline

Definition at line 1027 of file PatternMatch.h.

Referenced by reassociateFCmps().

◆ m_FDiv()

template<typename LHS , typename RHS >

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

inline

Definition at line 732 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), foldFDivConstantDividend(), foldFNegIntoConstant(), llvm::InstCombiner::visitFDiv(), and llvm::InstCombiner::visitFMul().

◆ m_FMax()

template<typename Opnd0 , typename Opnd1 >

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

inline

Definition at line 1623 of file PatternMatch.h.

◆ m_FMin()

template<typename Opnd0 , typename Opnd1 >

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

inline

Definition at line 1617 of file PatternMatch.h.

◆ m_FMul()

template<typename LHS , typename RHS >

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

inline

Definition at line 714 of file PatternMatch.h.

Referenced by factorizeFAddFSub(), foldFDivConstantDividend(), foldFNegIntoConstant(), getSqrtCall(), llvm::RecurrenceDescriptor::isConditionalRdxPattern(), llvm::InstCombiner::visitFMul(), and llvm::InstCombiner::visitFSub().

◆ m_FNeg()

template<typename OpTy >

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

inline

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

Definition at line 696 of file PatternMatch.h.

References X.

Referenced by buildMultiplyTree(), createAndInstr(), foldFDivConstantDividend(), foldFDivConstantDivisor(), foldFNegIntoConstant(), llvm::getComplexity(), isReassociableOp(), LinearizeExprTree(), NegateValue(), optimizeTrigReflections(), llvm::FastISel::selectOperator(), ShouldBreakUpSubtract(), SimplifyFAddInst(), simplifyFNegInst(), SimplifyFSubInst(), llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitFAdd(), llvm::InstCombiner::visitFCmpInst(), llvm::InstCombiner::visitFDiv(), llvm::InstCombiner::visitFMul(), llvm::InstCombiner::visitFPTrunc(), and llvm::InstCombiner::visitFSub().

◆ m_FNegNSZ()

template<typename RHS >

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

inline

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

Definition at line 703 of file PatternMatch.h.

References m_AnyZeroFP(), and m_FSub().

Referenced by SimplifyFDivInst().

◆ m_FPExt()

template<typename OpTy >

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

inline

Matches FPExt.

Definition at line 1212 of file PatternMatch.h.

Referenced by llvm::InstCombiner::visitFCmpInst(), and llvm::InstCombiner::visitFSub().

◆ m_FPOne()

specific_fpval llvm::PatternMatch::m_FPOne ( )

inline

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

Definition at line 542 of file PatternMatch.h.

References m_SpecificFP().

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

◆ m_FPTrunc()

template<typename OpTy >

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

inline

Matches FPTrunc.

Definition at line 1206 of file PatternMatch.h.

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

◆ m_FRem()

template<typename LHS , typename RHS >

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

inline

Definition at line 750 of file PatternMatch.h.

◆ m_FSub()

template<typename LHS , typename RHS >

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

inline

Definition at line 659 of file PatternMatch.h.

Referenced by llvm::RecurrenceDescriptor::isConditionalRdxPattern(), m_FNegNSZ(), SimplifyFAddInst(), SimplifyFSubInst(), llvm::InstCombiner::visitFMul(), llvm::InstCombiner::visitFNeg(), and llvm::InstCombiner::visitFSub().

◆ m_ICmp()

template<typename LHS , typename RHS >

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

inline

◆ m_IDiv()

template<typename LHS , typename RHS >

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

inline

Matches integer division operations.

Definition at line 961 of file PatternMatch.h.

Referenced by isKnownNonZero(), and SimplifyMulInst().

◆ m_InsertElement()

template<typename Val_t , typename Elt_t , typename Idx_t >

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

inline

Matches InsertElementInst.

Definition at line 1105 of file PatternMatch.h.

Referenced by cheapToScalarize(), foldBitcastExtElt(), foldShuffleWithInsert(), and llvm::getSplatValue().

◆ m_Instruction()

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

inline

Match an instruction, capturing it if we match.

Definition at line 478 of file PatternMatch.h.

References I.

Referenced by canonicalizeSaturatedAdd(), llvm::SCEVExpander::getRelatedExistingExpansion(), isMinMaxWithLoads(), lookThroughAnd(), and llvm::InstCombiner::visitFCmpInst().

◆ m_Intrinsic() [1/5]

template<Intrinsic::ID IntrID>

IntrinsicID_match llvm::PatternMatch::m_Intrinsic ( )

inline

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

Definition at line 1567 of file PatternMatch.h.

◆ m_Intrinsic() [2/5]

template<Intrinsic::ID IntrID, typename T0 >

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

inline

Definition at line 1572 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [3/5]

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

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

inline

Definition at line 1577 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Intrinsic() [4/5]

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

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

inline

Definition at line 1584 of file PatternMatch.h.

References m_CombineAnd(), and T1.

◆ m_Intrinsic() [5/5]

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

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

inline

Definition at line 1591 of file PatternMatch.h.

References m_CombineAnd().

◆ m_Load()

template<typename OpTy >

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

inline

Matches LoadInst.

Definition at line 1127 of file PatternMatch.h.

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

◆ m_LogicalShift()

template<typename LHS , typename RHS >

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

inline

Matches logical shift operations.

Definition at line 948 of file PatternMatch.h.

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

◆ m_LowBitMask()

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 417 of file PatternMatch.h.

Referenced by foldICmpWithLowBitMaskedVal().

◆ m_LShr()

template<typename LHS , typename RHS >

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

inline

◆ m_MaxSignedValue() [1/2]

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 318 of file PatternMatch.h.

◆ m_MaxSignedValue() [2/2]

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

inline

Definition at line 321 of file PatternMatch.h.

◆ m_Mul()

template<typename LHS , typename RHS >

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

inline

Definition at line 708 of file PatternMatch.h.

Referenced by canNarrowShiftAmt(), hasOnlyOneNonZeroIndex(), isGEPFoldable(), isKnownNonZero(), MatchMul(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitShl(), and llvm::InstCombiner::visitSub().

◆ m_NaN()

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

inline

Match an arbitrary NaN constant.

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

Definition at line 426 of file PatternMatch.h.

Referenced by simplifyBinaryIntrinsic(), SimplifyFCmpInst(), and simplifyFPBinop().

◆ m_Neg()

template<typename ValTy >

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

inline

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

Definition at line 1685 of file PatternMatch.h.

References m_Sub(), and m_ZeroInt().

Referenced by buildMultiplyTree(), canonicalizeSaturatedAdd(), createAndInstr(), foldICmpWithTruncSignExtendedVal(), foldVecTruncToExtElt(), getBinOpsForFactorization(), llvm::getComplexity(), isKnownToBeAPowerOfTwo(), isReassociableOp(), LinearizeExprTree(), llvm::PatternMatch::Signum_match< Opnd_t >::match(), matchRotate(), matchSelectPattern(), NegateValue(), ShouldBreakUpSubtract(), SimplifyAndInst(), simplifyICmpWithBinOp(), unifyBitWidth(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitGetElementPtrInst(), llvm::InstCombiner::visitMul(), and llvm::InstCombiner::visitSub().

◆ m_Negative() [1/2]

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

inline

Match an integer or vector of negative values.

For vectors, this includes constants with undefined elements.

Definition at line 330 of file PatternMatch.h.

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

◆ m_Negative() [2/2]

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

inline

Definition at line 333 of file PatternMatch.h.

◆ m_NegZeroFP()

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

inline

Match a floating-point negative zero.

For vectors, this includes constants with undefined elements.

Definition at line 453 of file PatternMatch.h.

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

◆ m_NonNegative() [1/2]

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

inline

Match an integer or vector of nonnegative values.

For vectors, this includes constants with undefined elements.

Definition at line 342 of file PatternMatch.h.

Referenced by foldICmpWithLowBitMaskedVal(), and llvm::InstCombiner::visitXor().

◆ m_NonNegative() [2/2]

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

inline

Definition at line 345 of file PatternMatch.h.

◆ m_Not()

template<typename ValTy >

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

inline

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

Definition at line 1692 of file PatternMatch.h.

References m_AllOnes(), and m_c_Xor().

Referenced by areInverseVectorBitmasks(), canonicalizeSaturatedAdd(), computeKnownBitsFromAssume(), createAndInstr(), findAffectedValues(), foldAndToXor(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldNoWrapAdd(), foldOrToXor(), foldToUnsignedSaturatedAdd(), foldXorToXor(), llvm::getComplexity(), llvm::haveNoCommonBitsSet(), llvm::IsFreeToInvert(), isReassociableOp(), matchDeMorgansLaws(), matchMinMax(), matchMinMaxOfMinMax(), OptimizeAndOrXor(), SimplifyAddInst(), SimplifyAndInst(), SimplifyOrInst(), SimplifyXorInst(), sinkNotIntoXor(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitBranchInst(), visitMaskedMerge(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitXor().

◆ m_NSWAdd()

template<typename LHS , typename RHS >

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

inline

Definition at line 819 of file PatternMatch.h.

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

Referenced by llvm::createSeparateConstOffsetFromGEPPass(), foldNoWrapAdd(), isTruePredicate(), truncateIVUse(), and llvm::InstCombiner::visitCallInst().

◆ m_NSWMul()

template<typename LHS , typename RHS >

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

inline

Definition at line 835 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoSignedWrap.

Referenced by llvm::InstCombiner::commonIDivTransforms(), and matchesOr().

◆ m_NSWShl()

template<typename LHS , typename RHS >

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

inline

Definition at line 843 of file PatternMatch.h.

References llvm::MCID::Add, llvm::OverflowingBinaryOperator::NoSignedWrap, and llvm::OverflowingBinaryOperator::NoUnsignedWrap.

Referenced by llvm::InstCombiner::commonIDivTransforms(), matchesOr(), SimplifyAShrInst(), simplifyRem(), and llvm::InstCombiner::visitAShr().

◆ m_NSWSub()

template<typename LHS , typename RHS >

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

inline

Definition at line 827 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoSignedWrap.

Referenced by llvm::createSeparateConstOffsetFromGEPPass(), llvm::isKnownNegation(), matchMinMax(), llvm::InstCombiner::visitSDiv(), and llvm::InstCombiner::visitSRem().

◆ m_NUWAdd()

template<typename LHS , typename RHS >

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

inline

Definition at line 852 of file PatternMatch.h.

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

Referenced by foldNoWrapAdd(), isTruePredicate(), and llvm::InstCombiner::visitCallInst().

◆ m_NUWMul()

template<typename LHS , typename RHS >

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

inline

Definition at line 868 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoUnsignedWrap.

Referenced by llvm::InstCombiner::commonIDivTransforms(), and llvm::InstCombiner::visitUDiv().

◆ m_NUWShl()

template<typename LHS , typename RHS >

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

inline

Definition at line 876 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoUnsignedWrap.

Referenced by llvm::InstCombiner::commonIDivTransforms(), SimplifyAndInst(), SimplifyLShrInst(), and simplifyRem().

◆ m_NUWSub()

template<typename LHS , typename RHS >

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

inline

Definition at line 860 of file PatternMatch.h.

References llvm::OverflowingBinaryOperator::NoUnsignedWrap.

◆ m_One()

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 354 of file PatternMatch.h.

Referenced by canonicalizeICmpBool(), canonicalizeLowbitMask(), canonicalizeSaturatedAdd(), checkForNegativeOperand(), llvm::InstCombiner::commonIDivTransforms(), llvm::ConstantFoldBinaryInstruction(), despeculateCountZeros(), foldAnyOrAllBitsSet(), foldCttzCtlz(), foldICmpBitCast(), foldICmpShlOne(), foldICmpWithHighBitMask(), foldICmpWithLowBitMaskedVal(), foldICmpWithTruncSignExtendedVal(), foldSelectICmpAndAnd(), isKnownToBeAPowerOfTwo(), isNeutralValue(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), matchAndOrChain(), matchSelectPattern(), processUGT_ADDCST_ADD(), replaceAllUsesOfWithIn(), llvm::InstCombiner::replacedSelectWithOperand(), simplifyDivRem(), simplifyICmpOfBools(), SimplifyMulInst(), simplifyValueKnownNonZero(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitMul(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitURem().

◆ m_OneUse()

template<typename T >

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

inline

Definition at line 61 of file PatternMatch.h.

References llvm::PatternMatch::OneUse_match< SubPattern_t >::SubPattern.

◆ m_Or()

template<typename LHS , typename RHS >

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

inline

◆ m_OrdFMax()

template<typename LHS , typename RHS >

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

inline

Match an 'ordered' floating point maximum function.

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

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

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

Definition at line 1392 of file PatternMatch.h.

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

◆ m_OrdFMin()

template<typename LHS , typename RHS >

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

inline

Match an 'ordered' floating point minimum function.

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

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

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

Definition at line 1407 of file PatternMatch.h.

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

◆ m_PosZeroFP()

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

inline

Match a floating-point positive zero.

For vectors, this includes constants with undefined elements.

Definition at line 444 of file PatternMatch.h.

Referenced by llvm::CannotBeNegativeZero(), foldFabsWithFcmpZero(), foldSignedTruncationCheck(), SimplifyFAddInst(), SimplifyFRemInst(), SimplifyFSubInst(), llvm::InstCombiner::visitFCmpInst(), and llvm::InstCombiner::visitFSub().

◆ m_Power2() [1/2]

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

inline

Match an integer or vector power-of-2.

For vectors, this includes constants with undefined elements.

Definition at line 384 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAdd(), llvm::InstCombiner::commonShiftTransforms(), foldSelectICmpAnd(), foldSelectICmpAndOr(), foldSignedTruncationCheck(), isKnownToBeAPowerOfTwo(), PickMostRelevantLoop(), llvm::InstCombiner::replacedSelectWithOperand(), and visitUDivOperand().

◆ m_Power2() [2/2]

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

inline

Definition at line 387 of file PatternMatch.h.

◆ m_Power2OrZero() [1/2]

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 396 of file PatternMatch.h.

Referenced by isKnownToBeAPowerOfTwo().

◆ m_Power2OrZero() [2/2]

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

inline

Definition at line 399 of file PatternMatch.h.

◆ m_PtrToInt()

template<typename OpTy >

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

inline

Matches PtrToInt.

Definition at line 1163 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), findAffectedValues(), processUGT_ADDCST_ADD(), simplifyAndOrOfICmpsWithZero(), SimplifyGEPInst(), SimplifySubInst(), llvm::InstCombiner::visitGetElementPtrInst(), and llvm::InstCombiner::visitSub().

◆ m_SDiv()

template<typename LHS , typename RHS >

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

inline

Definition at line 726 of file PatternMatch.h.

Referenced by llvm::InstCombiner::commonIDivTransforms(), IsKnownPredicateViaMinOrMax(), MatchDiv(), simplifyDiv(), SimplifyGEPInst(), llvm::InstCombiner::visitGetElementPtrInst(), llvm::InstCombiner::visitSDiv(), and llvm::InstCombiner::visitSub().

◆ m_Select()

template<typename Cond , typename LHS , typename RHS >

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

inline

Matches SelectInst.

Definition at line 1089 of file PatternMatch.h.

Referenced by foldICmpShlOne(), getBinOpsForFactorization(), getRangeForAffineARHelper(), llvm::IsFreeToInvert(), isMinMaxWithLoads(), llvm::isSplatValue(), and llvm::InstCombiner::visitOr().

◆ m_SelectCst()

template<int64_t L, int64_t R, typename Cond >

ThreeOps_match<Cond, constantint_match<L>, constantint_match<R>, Instruction::Select> llvm::PatternMatch::m_SelectCst ( const Cond & C )

inline

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

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

Definition at line 1098 of file PatternMatch.h.

◆ m_SExt()

template<typename OpTy >

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

inline

◆ m_Shift()

template<typename LHS , typename RHS >

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

inline

Matches shift operations.

Definition at line 933 of file PatternMatch.h.

◆ m_Shl()

template<typename LHS , typename RHS >

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

inline

Definition at line 774 of file PatternMatch.h.

◆ m_Shr()

template<typename LHS , typename RHS >

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

inline

Matches logical shift operations.

Definition at line 940 of file PatternMatch.h.

Referenced by computeKnownBitsFromAssume(), llvm::InstCombiner::FoldShiftByConstant(), isKnownNonZero(), ShrinkDemandedConstant(), SimplifyShlInst(), llvm::InstCombiner::visitShl(), and llvm::InstCombiner::visitTrunc().

◆ m_ShuffleVector()

template<typename V1_t , typename V2_t , typename Mask_t >

ThreeOps_match<V1_t, V2_t, Mask_t, Instruction::ShuffleVector> llvm::PatternMatch::m_ShuffleVector	(	const V1_t &	v1,
		const V2_t &	v2,
		const Mask_t &	m
	)

inline

Matches ShuffleVectorInst.

Definition at line 1120 of file PatternMatch.h.

Referenced by areExtractShuffleVectors(), foldICmpBitCast(), foldIdentityExtractShuffle(), foldVectorCmp(), llvm::getSplatValue(), llvm::isSplatValue(), and shouldMergeGEPs().

◆ m_SignMask()

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 408 of file PatternMatch.h.

Referenced by isKnownToBeAPowerOfTwo(), SimplifyAddInst(), and llvm::InstCombiner::visitSDiv().

◆ m_Signum()

template<typename Val_t >

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

inline

Matches a signum pattern.

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

Definition at line 1771 of file PatternMatch.h.

Referenced by processUGT_ADDCST_ADD().

◆ m_SIToFP()

template<typename OpTy >

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

inline

Matches SIToFP.

Definition at line 1200 of file PatternMatch.h.

Referenced by foldICmpBitCast(), and simplifyUnaryIntrinsic().

◆ m_SMax()

template<typename LHS , typename RHS >

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

inline

Definition at line 1359 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), getSelectFoldableConstant(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), matchClamp(), and simplifyICmpWithMinMax().

◆ m_SMin()

template<typename LHS , typename RHS >

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

inline

Definition at line 1365 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), getSelectFoldableConstant(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), matchClamp(), and simplifyICmpWithMinMax().

◆ m_Specific()

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

inline

Match if we have a specific specified value.

Definition at line 501 of file PatternMatch.h.

◆ m_SpecificFP()

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

inline

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

Definition at line 539 of file PatternMatch.h.

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

◆ m_SpecificInt()

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

inline

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

Definition at line 578 of file PatternMatch.h.

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

◆ m_SRem()

template<typename LHS , typename RHS >

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

inline

Definition at line 744 of file PatternMatch.h.

Referenced by llvm::InstCombiner::commonIDivTransforms(), llvm::InstCombiner::commonShiftTransforms(), MatchRem(), simplifyDiv(), simplifyRem(), and llvm::InstCombiner::visitSRem().

◆ m_Store()

template<typename ValueOpTy , typename PointerOpTy >

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

inline

Matches StoreInst.

Definition at line 1134 of file PatternMatch.h.

◆ m_Sub()

template<typename LHS , typename RHS >

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

inline

◆ m_Trunc()

template<typename OpTy >

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

inline

Matches Trunc.

Definition at line 1169 of file PatternMatch.h.

Referenced by canAlwaysEvaluateInType(), canonicalizeSaturatedAdd(), llvm::decomposeBitTestICmp(), foldICmpWithMinMax(), foldSelectICmpAndOr(), foldSignedTruncationCheck(), processUGT_ADDCST_ADD(), SimplifySubInst(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitSExt(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitZExt().

◆ m_UAddWithOverflow()

template<typename LHS_t , typename RHS_t , typename Sum_t >

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

Match an icmp instruction checking for unsigned overflow on addition.

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

Definition at line 1498 of file PatternMatch.h.

Referenced by matchUAddWithOverflowConstantEdgeCases().

◆ m_UDiv()

template<typename LHS , typename RHS >

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

inline

Definition at line 720 of file PatternMatch.h.

Referenced by llvm::InstCombiner::commonIDivTransforms(), isKnownToBeAPowerOfTwo(), MatchDiv(), simplifyDiv(), and simplifyICmpWithBinOp().

◆ m_UIToFP()

template<typename OpTy >

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

inline

Matches UIToFP.

Definition at line 1194 of file PatternMatch.h.

Referenced by foldICmpBitCast(), simplifyICmpWithConstant(), and simplifyUnaryIntrinsic().

◆ m_UMax()

template<typename LHS , typename RHS >

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

inline

Definition at line 1371 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), getReductionData(), getSelectFoldableConstant(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), matchClamp(), and simplifyICmpWithMinMax().

◆ m_UMin()

template<typename LHS , typename RHS >

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

inline

Definition at line 1377 of file PatternMatch.h.

Referenced by createRdxShuffleMask(), foldToUnsignedSaturatedAdd(), getReductionData(), getSelectFoldableConstant(), llvm::RecurrenceDescriptor::isMinMaxSelectCmpPattern(), matchClamp(), and simplifyICmpWithMinMax().

◆ m_UnconditionalBr()

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

inline

Definition at line 1235 of file PatternMatch.h.

Referenced by tryToMoveFreeBeforeNullTest().

◆ m_Undef()

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

inline

Match an arbitrary undef constant.

Definition at line 86 of file PatternMatch.h.

Referenced by areExtractShuffleVectors(), llvm::ConstantFoldBinaryInstruction(), foldICmpBitCast(), foldVectorCmp(), markAliveBlocks(), narrowVectorSelect(), shouldMergeGEPs(), SimplifyAddInst(), SimplifyAndInst(), simplifyBinaryIntrinsic(), simplifyDivRem(), SimplifyInsertValueInst(), simplifyIntrinsic(), SimplifyMulInst(), SimplifyOrInst(), SimplifyRightShift(), SimplifyShlInst(), SimplifySubInst(), SimplifyXorInst(), and llvm::InstCombiner::visitCallInst().

◆ m_UnordFMax()

template<typename LHS , typename RHS >

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

inline

Match an 'unordered' floating point maximum function.

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

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

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

Definition at line 1423 of file PatternMatch.h.

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

◆ m_UnordFMin()

template<typename LHS , typename RHS >

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

inline

Match an 'unordered' floating point minimum function.

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

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

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

Definition at line 1438 of file PatternMatch.h.

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

◆ m_URem()

template<typename LHS , typename RHS >

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

inline

Definition at line 738 of file PatternMatch.h.

Referenced by llvm::InstCombiner::commonIDivTransforms(), MatchRem(), simplifyDiv(), simplifyICmpWithBinOp(), and simplifyRem().

◆ m_Value() [1/3]

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

inline

Match an arbitrary value and ignore it.

Definition at line 70 of file PatternMatch.h.

◆ m_Value() [2/3]

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

inline

Match a value, capturing it if we match.

Definition at line 474 of file PatternMatch.h.

◆ m_Value() [3/3]

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

inline

Definition at line 475 of file PatternMatch.h.

◆ m_Xor()

template<typename LHS , typename RHS >

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

inline

Definition at line 768 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAdd(), checkForNegativeOperand(), foldICmpWithMinMax(), foldNoWrapAdd(), foldXorToXor(), processUGT_ADDCST_ADD(), replaceAllUsesOfWithIn(), SimplifyAddInst(), SimplifyGEPInst(), SimplifyOrInst(), sinkNotIntoXor(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitAnd(), llvm::InstCombiner::visitOr(), llvm::InstCombiner::visitSub(), llvm::InstCombiner::visitXor(), and llvm::InstCombiner::visitZExt().

◆ m_Zero()

is_zero llvm::PatternMatch::m_Zero ( )

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 375 of file PatternMatch.h.

Referenced by areInverseVectorBitmasks(), canonicalizeICmpBool(), canonicalizeSaturatedAdd(), canonicalizeSaturatedSubtract(), llvm::ConstantFoldBinaryInstruction(), foldICmpBitCast(), foldSelectICmpAnd(), foldSelectICmpAndAnd(), foldSelectICmpAndOr(), foldSignedTruncationCheck(), foldXorToXor(), llvm::getGEPInductionOperand(), isKnownNonNullFromDominatingCondition(), isNeutralValue(), markAliveBlocks(), matchMinMax(), processUGT_ADDCST_ADD(), replaceAllUsesOfWithIn(), shouldMergeGEPs(), SimplifyAddInst(), SimplifyAndInst(), simplifyAndOrOfICmpsWithZero(), simplifyBinaryIntrinsic(), simplifyDivRem(), llvm::InstCombiner::simplifyDivRemOfSelectWithZeroOp(), SimplifyGEPInst(), simplifyICmpOfBools(), simplifyICmpWithConstant(), simplifyICmpWithZero(), SimplifyMulInst(), SimplifyOrInst(), simplifySelectWithICmpCond(), SimplifyShift(), SimplifySubInst(), simplifyUnsignedRangeCheck(), SimplifyXorInst(), tryToMoveFreeBeforeNullTest(), llvm::InstCombiner::visitAdd(), llvm::InstCombiner::visitICmpInst(), llvm::InstCombiner::visitPHINode(), llvm::InstCombiner::visitSDiv(), llvm::InstCombiner::visitSRem(), and llvm::InstCombiner::visitSub().

◆ m_ZeroInt()

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

inline

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

For vectors, this includes constants with undefined elements.

Definition at line 363 of file PatternMatch.h.

Referenced by canonicalizeSaturatedAdd(), foldGuardedRotateToFunnelShift(), llvm::getSplatValue(), llvm::isKnownNegation(), m_Neg(), llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >::match(), matchSelectPattern(), matchUAddWithOverflowConstantEdgeCases(), simplifyX86addcarry(), llvm::InstCombiner::visitCallInst(), llvm::InstCombiner::visitSub(), and llvm::InstCombiner::visitZExt().

◆ m_ZExt()

template<typename OpTy >

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

inline

◆ m_ZExtOrSExt()

template<typename OpTy >

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

inline

Definition at line 1188 of file PatternMatch.h.

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

Referenced by areExtractExts(), canAlwaysEvaluateInType(), foldVecTruncToExtElt(), and shouldMergeGEPs().

◆ match()

template<typename Val , typename Pattern >

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

Definition at line 47 of file PatternMatch.h.

References P.

Classes

Functions

Function Documentation

◆ m_Add()

◆ m_AllOnes()

◆ m_And()

◆ m_AnyZeroFP()

◆ m_APFloat()

◆ m_APInt()

◆ m_Argument()

◆ m_AShr()

◆ m_BinOp() [1/3]

◆ m_BinOp() [2/3]

◆ m_BinOp() [3/3]

◆ m_BitCast()

◆ m_BitReverse()

◆ m_BitwiseLogic()

◆ m_Br()

◆ m_BSwap()

◆ m_c_Add()

◆ m_c_And()

◆ m_c_BinOp()

◆ m_c_FAdd()

◆ m_c_FMul()

◆ m_c_ICmp()

◆ m_c_Mul()

◆ m_c_Or()

◆ m_c_SMax()

◆ m_c_SMin()

◆ m_c_UMax()

◆ m_c_UMin()

◆ m_c_Xor()

◆ m_Cmp() [1/2]

◆ m_Cmp() [2/2]

◆ m_CombineAnd()

◆ m_CombineOr()

◆ m_Constant() [1/2]

◆ m_Constant() [2/2]

◆ m_ConstantFP()

◆ m_ConstantInt() [1/3]

◆ m_ConstantInt() [2/3]

◆ m_ConstantInt() [3/3]

◆ m_Deferred() [1/2]

◆ m_Deferred() [2/2]

◆ m_Exact()

◆ m_ExtractElement()

◆ m_FAbs()

◆ m_FAdd()

◆ m_FCanonicalize()

◆ m_FCmp()

◆ m_FDiv()

◆ m_FMax()

◆ m_FMin()

◆ m_FMul()

◆ m_FNeg()

◆ m_FNegNSZ()

◆ m_FPExt()

◆ m_FPOne()

◆ m_FPTrunc()

◆ m_FRem()

◆ m_FSub()

◆ m_ICmp()

◆ m_IDiv()

◆ m_InsertElement()

◆ m_Instruction()

◆ m_Intrinsic() [1/5]

◆ m_Intrinsic() [2/5]

◆ m_Intrinsic() [3/5]

◆ m_Intrinsic() [4/5]

◆ m_Intrinsic() [5/5]

◆ m_Load()

◆ m_LogicalShift()

◆ m_LowBitMask()

◆ m_LShr()

◆ m_MaxSignedValue() [1/2]

◆ m_MaxSignedValue() [2/2]

◆ m_Mul()

◆ m_NaN()

◆ m_Neg()

◆ m_Negative() [1/2]