|
| template<typename Val , typename Pattern > |
| bool | llvm::PatternMatch::match (Val *V, const Pattern &P) |
| |
| template<typename Pattern > |
| bool | llvm::PatternMatch::match (ArrayRef< int > Mask, const Pattern &P) |
| |
| template<typename T > |
| OneUse_match< T > | llvm::PatternMatch::m_OneUse (const T &SubPattern) |
| |
| template<typename T > |
| AllowReassoc_match< T > | llvm::PatternMatch::m_AllowReassoc (const T &SubPattern) |
| |
| class_match< Value > | llvm::PatternMatch::m_Value () |
| | Match an arbitrary value and ignore it.
|
| |
| class_match< UnaryOperator > | llvm::PatternMatch::m_UnOp () |
| | Match an arbitrary unary operation and ignore it.
|
| |
| class_match< BinaryOperator > | llvm::PatternMatch::m_BinOp () |
| | Match an arbitrary binary operation and ignore it.
|
| |
| class_match< CmpInst > | llvm::PatternMatch::m_Cmp () |
| | Matches any compare instruction and ignore it.
|
| |
| auto | llvm::PatternMatch::m_Undef () |
| | Match an arbitrary undef constant.
|
| |
| class_match< UndefValue > | llvm::PatternMatch::m_UndefValue () |
| | Match an arbitrary UndefValue constant.
|
| |
| class_match< PoisonValue > | llvm::PatternMatch::m_Poison () |
| | Match an arbitrary poison constant.
|
| |
| class_match< Constant > | llvm::PatternMatch::m_Constant () |
| | Match an arbitrary Constant and ignore it.
|
| |
| class_match< ConstantInt > | llvm::PatternMatch::m_ConstantInt () |
| | Match an arbitrary ConstantInt and ignore it.
|
| |
| class_match< ConstantFP > | llvm::PatternMatch::m_ConstantFP () |
| | Match an arbitrary ConstantFP and ignore it.
|
| |
| constantexpr_match | llvm::PatternMatch::m_ConstantExpr () |
| | Match a constant expression or a constant that contains a constant expression.
|
| |
| class_match< BasicBlock > | llvm::PatternMatch::m_BasicBlock () |
| | Match an arbitrary basic block value and ignore it.
|
| |
| template<typename Ty > |
| match_unless< Ty > | llvm::PatternMatch::m_Unless (const Ty &M) |
| | Match if the inner matcher does NOT match.
|
| |
| template<typename LTy , typename RTy > |
| match_combine_or< LTy, RTy > | llvm::PatternMatch::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 > | llvm::PatternMatch::m_CombineAnd (const LTy &L, const RTy &R) |
| | Combine two pattern matchers matching L && R.
|
| |
| apint_match | llvm::PatternMatch::m_APInt (const APInt *&Res) |
| | Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
|
| |
| apint_match | llvm::PatternMatch::m_APIntAllowPoison (const APInt *&Res) |
| | Match APInt while allowing poison in splat vector constants.
|
| |
| apint_match | llvm::PatternMatch::m_APIntForbidPoison (const APInt *&Res) |
| | Match APInt while forbidding poison in splat vector constants.
|
| |
| apfloat_match | llvm::PatternMatch::m_APFloat (const APFloat *&Res) |
| | Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat.
|
| |
| apfloat_match | llvm::PatternMatch::m_APFloatAllowPoison (const APFloat *&Res) |
| | Match APFloat while allowing poison in splat vector constants.
|
| |
| apfloat_match | llvm::PatternMatch::m_APFloatForbidPoison (const APFloat *&Res) |
| | Match APFloat while forbidding poison in splat vector constants.
|
| |
| template<int64_t Val> |
| constantint_match< Val > | llvm::PatternMatch::m_ConstantInt () |
| | Match a ConstantInt with a specific value.
|
| |
| cst_pred_ty< custom_checkfn< APInt > > | llvm::PatternMatch::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 > > | llvm::PatternMatch::m_CheckedInt (const Constant *&V, function_ref< bool(const APInt &)> CheckFn) |
| |
| cstfp_pred_ty< custom_checkfn< APFloat > > | llvm::PatternMatch::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 > > | llvm::PatternMatch::m_CheckedFp (const Constant *&V, function_ref< bool(const APFloat &)> CheckFn) |
| |
| cst_pred_ty< is_any_apint > | llvm::PatternMatch::m_AnyIntegralConstant () |
| | Match an integer or vector with any integral constant.
|
| |
| cst_pred_ty< is_shifted_mask > | llvm::PatternMatch::m_ShiftedMask () |
| |
| cst_pred_ty< is_all_ones > | llvm::PatternMatch::m_AllOnes () |
| | Match an integer or vector with all bits set.
|
| |
| cst_pred_ty< is_all_ones, false > | llvm::PatternMatch::m_AllOnesForbidPoison () |
| |
| cst_pred_ty< is_maxsignedvalue > | llvm::PatternMatch::m_MaxSignedValue () |
| | Match an integer or vector with values having all bits except for the high bit set (0x7f...).
|
| |
| api_pred_ty< is_maxsignedvalue > | llvm::PatternMatch::m_MaxSignedValue (const APInt *&V) |
| |
| cst_pred_ty< is_negative > | llvm::PatternMatch::m_Negative () |
| | Match an integer or vector of negative values.
|
| |
| api_pred_ty< is_negative > | llvm::PatternMatch::m_Negative (const APInt *&V) |
| |
| cst_pred_ty< is_nonnegative > | llvm::PatternMatch::m_NonNegative () |
| | Match an integer or vector of non-negative values.
|
| |
| api_pred_ty< is_nonnegative > | llvm::PatternMatch::m_NonNegative (const APInt *&V) |
| |
| cst_pred_ty< is_strictlypositive > | llvm::PatternMatch::m_StrictlyPositive () |
| | Match an integer or vector of strictly positive values.
|
| |
| api_pred_ty< is_strictlypositive > | llvm::PatternMatch::m_StrictlyPositive (const APInt *&V) |
| |
| cst_pred_ty< is_nonpositive > | llvm::PatternMatch::m_NonPositive () |
| | Match an integer or vector of non-positive values.
|
| |
| api_pred_ty< is_nonpositive > | llvm::PatternMatch::m_NonPositive (const APInt *&V) |
| |
| cst_pred_ty< is_one > | llvm::PatternMatch::m_One () |
| | Match an integer 1 or a vector with all elements equal to 1.
|
| |
| cst_pred_ty< is_zero_int > | llvm::PatternMatch::m_ZeroInt () |
| | Match an integer 0 or a vector with all elements equal to 0.
|
| |
| is_zero | llvm::PatternMatch::m_Zero () |
| | Match any null constant or a vector with all elements equal to 0.
|
| |
| cst_pred_ty< is_power2 > | llvm::PatternMatch::m_Power2 () |
| | Match an integer or vector power-of-2.
|
| |
| api_pred_ty< is_power2 > | llvm::PatternMatch::m_Power2 (const APInt *&V) |
| |
| cst_pred_ty< is_negated_power2 > | llvm::PatternMatch::m_NegatedPower2 () |
| | Match a integer or vector negated power-of-2.
|
| |
| api_pred_ty< is_negated_power2 > | llvm::PatternMatch::m_NegatedPower2 (const APInt *&V) |
| |
| cst_pred_ty< is_negated_power2_or_zero > | llvm::PatternMatch::m_NegatedPower2OrZero () |
| | Match a integer or vector negated power-of-2.
|
| |
| api_pred_ty< is_negated_power2_or_zero > | llvm::PatternMatch::m_NegatedPower2OrZero (const APInt *&V) |
| |
| cst_pred_ty< is_power2_or_zero > | llvm::PatternMatch::m_Power2OrZero () |
| | Match an integer or vector of 0 or power-of-2 values.
|
| |
| api_pred_ty< is_power2_or_zero > | llvm::PatternMatch::m_Power2OrZero (const APInt *&V) |
| |
| cst_pred_ty< is_sign_mask > | llvm::PatternMatch::m_SignMask () |
| | Match an integer or vector with only the sign bit(s) set.
|
| |
| cst_pred_ty< is_lowbit_mask > | llvm::PatternMatch::m_LowBitMask () |
| | Match an integer or vector with only the low bit(s) set.
|
| |
| api_pred_ty< is_lowbit_mask > | llvm::PatternMatch::m_LowBitMask (const APInt *&V) |
| |
| cst_pred_ty< is_lowbit_mask_or_zero > | llvm::PatternMatch::m_LowBitMaskOrZero () |
| | Match an integer or vector with only the low bit(s) set.
|
| |
| api_pred_ty< is_lowbit_mask_or_zero > | llvm::PatternMatch::m_LowBitMaskOrZero (const APInt *&V) |
| |
| cst_pred_ty< icmp_pred_with_threshold > | llvm::PatternMatch::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 > | llvm::PatternMatch::m_NaN () |
| | Match an arbitrary NaN constant.
|
| |
| cstfp_pred_ty< is_nonnan > | llvm::PatternMatch::m_NonNaN () |
| | Match a non-NaN FP constant.
|
| |
| cstfp_pred_ty< is_inf > | llvm::PatternMatch::m_Inf () |
| | Match a positive or negative infinity FP constant.
|
| |
| cstfp_pred_ty< is_noninf > | llvm::PatternMatch::m_NonInf () |
| | Match a non-infinity FP constant, i.e.
|
| |
| cstfp_pred_ty< is_finite > | llvm::PatternMatch::m_Finite () |
| | Match a finite FP constant, i.e.
|
| |
| apf_pred_ty< is_finite > | llvm::PatternMatch::m_Finite (const APFloat *&V) |
| |
| cstfp_pred_ty< is_finitenonzero > | llvm::PatternMatch::m_FiniteNonZero () |
| | Match a finite non-zero FP constant.
|
| |
| apf_pred_ty< is_finitenonzero > | llvm::PatternMatch::m_FiniteNonZero (const APFloat *&V) |
| |
| cstfp_pred_ty< is_any_zero_fp > | llvm::PatternMatch::m_AnyZeroFP () |
| | Match a floating-point negative zero or positive zero.
|
| |
| cstfp_pred_ty< is_pos_zero_fp > | llvm::PatternMatch::m_PosZeroFP () |
| | Match a floating-point positive zero.
|
| |
| cstfp_pred_ty< is_neg_zero_fp > | llvm::PatternMatch::m_NegZeroFP () |
| | Match a floating-point negative zero.
|
| |
| cstfp_pred_ty< is_non_zero_fp > | llvm::PatternMatch::m_NonZeroFP () |
| | Match a floating-point non-zero.
|
| |
| cstfp_pred_ty< is_non_zero_not_denormal_fp > | llvm::PatternMatch::m_NonZeroNotDenormalFP () |
| | Match a floating-point non-zero that is not a denormal.
|
| |
| bind_ty< Value > | llvm::PatternMatch::m_Value (Value *&V) |
| | Match a value, capturing it if we match.
|
| |
| bind_ty< const Value > | llvm::PatternMatch::m_Value (const Value *&V) |
| |
| bind_ty< Instruction > | llvm::PatternMatch::m_Instruction (Instruction *&I) |
| | Match an instruction, capturing it if we match.
|
| |
| bind_ty< UnaryOperator > | llvm::PatternMatch::m_UnOp (UnaryOperator *&I) |
| | Match a unary operator, capturing it if we match.
|
| |
| bind_ty< BinaryOperator > | llvm::PatternMatch::m_BinOp (BinaryOperator *&I) |
| | Match a binary operator, capturing it if we match.
|
| |
| bind_ty< WithOverflowInst > | llvm::PatternMatch::m_WithOverflowInst (WithOverflowInst *&I) |
| | Match a with overflow intrinsic, capturing it if we match.
|
| |
| bind_ty< const WithOverflowInst > | llvm::PatternMatch::m_WithOverflowInst (const WithOverflowInst *&I) |
| |
| bind_ty< UndefValue > | llvm::PatternMatch::m_UndefValue (UndefValue *&U) |
| | Match an UndefValue, capturing the value if we match.
|
| |
| bind_ty< Constant > | llvm::PatternMatch::m_Constant (Constant *&C) |
| | Match a Constant, capturing the value if we match.
|
| |
| bind_ty< ConstantInt > | llvm::PatternMatch::m_ConstantInt (ConstantInt *&CI) |
| | Match a ConstantInt, capturing the value if we match.
|
| |
| bind_ty< ConstantFP > | llvm::PatternMatch::m_ConstantFP (ConstantFP *&C) |
| | Match a ConstantFP, capturing the value if we match.
|
| |
| bind_ty< ConstantExpr > | llvm::PatternMatch::m_ConstantExpr (ConstantExpr *&C) |
| | Match a ConstantExpr, capturing the value if we match.
|
| |
| bind_ty< BasicBlock > | llvm::PatternMatch::m_BasicBlock (BasicBlock *&V) |
| | Match a basic block value, capturing it if we match.
|
| |
| bind_ty< const BasicBlock > | llvm::PatternMatch::m_BasicBlock (const BasicBlock *&V) |
| |
| match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > | llvm::PatternMatch::m_ImmConstant () |
| | Match an arbitrary immediate Constant and ignore it.
|
| |
| match_combine_and< bind_ty< Constant >, match_unless< constantexpr_match > > | llvm::PatternMatch::m_ImmConstant (Constant *&C) |
| | Match an immediate Constant, capturing the value if we match.
|
| |
| specificval_ty | llvm::PatternMatch::m_Specific (const Value *V) |
| | Match if we have a specific specified value.
|
| |
| deferredval_ty< Value > | llvm::PatternMatch::m_Deferred (Value *const &V) |
| | Like m_Specific(), but works if the specific value to match is determined as part of the same match() expression.
|
| |
| deferredval_ty< const Value > | llvm::PatternMatch::m_Deferred (const Value *const &V) |
| |
| specific_fpval | llvm::PatternMatch::m_SpecificFP (double V) |
| | Match a specific floating point value or vector with all elements equal to the value.
|
| |
| specific_fpval | llvm::PatternMatch::m_FPOne () |
| | Match a float 1.0 or vector with all elements equal to 1.0.
|
| |
| specific_intval< false > | llvm::PatternMatch::m_SpecificInt (const APInt &V) |
| | Match a specific integer value or vector with all elements equal to the value.
|
| |
| specific_intval64< false > | llvm::PatternMatch::m_SpecificInt (uint64_t V) |
| |
| specific_intval< true > | llvm::PatternMatch::m_SpecificIntAllowPoison (const APInt &V) |
| |
| specific_intval64< true > | llvm::PatternMatch::m_SpecificIntAllowPoison (uint64_t V) |
| |
| bind_const_intval_ty | llvm::PatternMatch::m_ConstantInt (uint64_t &V) |
| | Match a ConstantInt and bind to its value.
|
| |
| specific_bbval | llvm::PatternMatch::m_SpecificBB (BasicBlock *BB) |
| | Match a specific basic block value.
|
| |
| deferredval_ty< BasicBlock > | llvm::PatternMatch::m_Deferred (BasicBlock *const &BB) |
| | A commutative-friendly version of m_Specific().
|
| |
| deferredval_ty< const BasicBlock > | llvm::PatternMatch::m_Deferred (const BasicBlock *const &BB) |
| |
| template<typename LHS , typename RHS > |
| AnyBinaryOp_match< LHS, RHS > | llvm::PatternMatch::m_BinOp (const LHS &L, const RHS &R) |
| |
| template<typename OP_t > |
| AnyUnaryOp_match< OP_t > | llvm::PatternMatch::m_UnOp (const OP_t &X) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Add > | llvm::PatternMatch::m_Add (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FAdd > | llvm::PatternMatch::m_FAdd (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Sub > | llvm::PatternMatch::m_Sub (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FSub > | llvm::PatternMatch::m_FSub (const LHS &L, const RHS &R) |
| |
| template<typename OpTy > |
| FNeg_match< OpTy > | llvm::PatternMatch::m_FNeg (const OpTy &X) |
| | Match 'fneg X' as 'fsub -0.0, X'.
|
| |
| template<typename RHS > |
| BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub > | llvm::PatternMatch::m_FNegNSZ (const RHS &X) |
| | Match 'fneg X' as 'fsub +-0.0, X'.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Mul > | llvm::PatternMatch::m_Mul (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FMul > | llvm::PatternMatch::m_FMul (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::UDiv > | llvm::PatternMatch::m_UDiv (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::SDiv > | llvm::PatternMatch::m_SDiv (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FDiv > | llvm::PatternMatch::m_FDiv (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::URem > | llvm::PatternMatch::m_URem (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::SRem > | llvm::PatternMatch::m_SRem (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FRem > | llvm::PatternMatch::m_FRem (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::And > | llvm::PatternMatch::m_And (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Or > | llvm::PatternMatch::m_Or (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Xor > | llvm::PatternMatch::m_Xor (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Shl > | llvm::PatternMatch::m_Shl (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::LShr > | llvm::PatternMatch::m_LShr (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::AShr > | llvm::PatternMatch::m_AShr (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > | llvm::PatternMatch::m_NSWAdd (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > | llvm::PatternMatch::m_NSWSub (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > | llvm::PatternMatch::m_NSWMul (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > | llvm::PatternMatch::m_NSWShl (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > | llvm::PatternMatch::m_NUWAdd (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > | llvm::PatternMatch::m_c_NUWAdd (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > | llvm::PatternMatch::m_NUWSub (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > | llvm::PatternMatch::m_NUWMul (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > | llvm::PatternMatch::m_NUWShl (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| SpecificBinaryOp_match< LHS, RHS > | llvm::PatternMatch::m_BinOp (unsigned Opcode, const LHS &L, const RHS &R) |
| | Matches a specific opcode.
|
| |
| template<typename LHS , typename RHS > |
| DisjointOr_match< LHS, RHS > | llvm::PatternMatch::m_DisjointOr (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| DisjointOr_match< LHS, RHS, true > | llvm::PatternMatch::m_c_DisjointOr (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > | llvm::PatternMatch::m_AddLike (const LHS &L, const RHS &R) |
| | Match either "add" or "or disjoint".
|
| |
| template<typename LHS , typename RHS > |
| match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > | llvm::PatternMatch::m_NSWAddLike (const LHS &L, const RHS &R) |
| | Match either "add nsw" or "or disjoint".
|
| |
| template<typename LHS , typename RHS > |
| match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > | llvm::PatternMatch::m_NUWAddLike (const LHS &L, const RHS &R) |
| | Match either "add nuw" or "or disjoint".
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_shift_op > | llvm::PatternMatch::m_Shift (const LHS &L, const RHS &R) |
| | Matches shift operations.
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_right_shift_op > | llvm::PatternMatch::m_Shr (const LHS &L, const RHS &R) |
| | Matches logical shift operations.
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_logical_shift_op > | llvm::PatternMatch::m_LogicalShift (const LHS &L, const RHS &R) |
| | Matches logical shift operations.
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_bitwiselogic_op > | llvm::PatternMatch::m_BitwiseLogic (const LHS &L, const RHS &R) |
| | Matches bitwise logic operations.
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_bitwiselogic_op, true > | llvm::PatternMatch::m_c_BitwiseLogic (const LHS &L, const RHS &R) |
| | Matches bitwise logic operations in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_idiv_op > | llvm::PatternMatch::m_IDiv (const LHS &L, const RHS &R) |
| | Matches integer division operations.
|
| |
| template<typename LHS , typename RHS > |
| BinOpPred_match< LHS, RHS, is_irem_op > | llvm::PatternMatch::m_IRem (const LHS &L, const RHS &R) |
| | Matches integer remainder operations.
|
| |
| template<typename T > |
| Exact_match< T > | llvm::PatternMatch::m_Exact (const T &SubPattern) |
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, CmpInst > | llvm::PatternMatch::m_Cmp (CmpPredicate &Pred, const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, ICmpInst > | llvm::PatternMatch::m_ICmp (CmpPredicate &Pred, const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, FCmpInst > | llvm::PatternMatch::m_FCmp (CmpPredicate &Pred, const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, CmpInst > | llvm::PatternMatch::m_Cmp (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, ICmpInst > | llvm::PatternMatch::m_ICmp (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, FCmpInst > | llvm::PatternMatch::m_FCmp (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| SpecificCmpClass_match< LHS, RHS, CmpInst > | llvm::PatternMatch::m_SpecificCmp (CmpPredicate MatchPred, const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| SpecificCmpClass_match< LHS, RHS, ICmpInst > | llvm::PatternMatch::m_SpecificICmp (CmpPredicate MatchPred, const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| SpecificCmpClass_match< LHS, RHS, ICmpInst, true > | llvm::PatternMatch::m_c_SpecificICmp (CmpPredicate MatchPred, const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| SpecificCmpClass_match< LHS, RHS, FCmpInst > | llvm::PatternMatch::m_SpecificFCmp (CmpPredicate MatchPred, const LHS &L, const RHS &R) |
| |
| 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) |
| | Matches SelectInst.
|
| |
| 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) |
| | This matches a select of two constants, e.g.: m_SelectCst<-1, 0>(m_Value(V))
|
| |
| template<typename LHS , typename RHS > |
| ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true > | llvm::PatternMatch::m_c_Select (const LHS &L, const RHS &R) |
| | Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
|
| |
| template<typename OpTy > |
| OneOps_match< OpTy, Instruction::Freeze > | llvm::PatternMatch::m_Freeze (const OpTy &Op) |
| | Matches FreezeInst.
|
| |
| template<typename Val_t , typename Elt_t , typename Idx_t > |
| ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > | llvm::PatternMatch::m_InsertElt (const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) |
| | Matches InsertElementInst.
|
| |
| template<typename Val_t , typename Idx_t > |
| TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > | llvm::PatternMatch::m_ExtractElt (const Val_t &Val, const Idx_t &Idx) |
| | Matches ExtractElementInst.
|
| |
| template<typename V1_t , typename V2_t > |
| TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > | llvm::PatternMatch::m_Shuffle (const V1_t &v1, const V2_t &v2) |
| | Matches ShuffleVectorInst independently of mask value.
|
| |
| template<typename V1_t , typename V2_t , typename Mask_t > |
| Shuffle_match< V1_t, V2_t, Mask_t > | llvm::PatternMatch::m_Shuffle (const V1_t &v1, const V2_t &v2, const Mask_t &mask) |
| |
| template<typename OpTy > |
| OneOps_match< OpTy, Instruction::Load > | llvm::PatternMatch::m_Load (const OpTy &Op) |
| | Matches LoadInst.
|
| |
| template<typename ValueOpTy , typename PointerOpTy > |
| TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store > | llvm::PatternMatch::m_Store (const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) |
| | Matches StoreInst.
|
| |
| template<typename... OperandTypes> |
| auto | llvm::PatternMatch::m_GEP (const OperandTypes &...Ops) |
| | Matches GetElementPtrInst.
|
| |
| template<typename PointerOpTy , typename OffsetOpTy > |
| PtrAdd_match< PointerOpTy, OffsetOpTy > | llvm::PatternMatch::m_PtrAdd (const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp) |
| | Matches GEP with i8 source element type.
|
| |
| template<typename OpTy > |
| CastOperator_match< OpTy, Instruction::BitCast > | llvm::PatternMatch::m_BitCast (const OpTy &Op) |
| | Matches BitCast.
|
| |
| template<typename OpTy > |
| ElementWiseBitCast_match< OpTy > | llvm::PatternMatch::m_ElementWiseBitCast (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastOperator_match< OpTy, Instruction::PtrToInt > | llvm::PatternMatch::m_PtrToInt (const OpTy &Op) |
| | Matches PtrToInt.
|
| |
| template<typename OpTy > |
| PtrToIntSameSize_match< OpTy > | llvm::PatternMatch::m_PtrToIntSameSize (const DataLayout &DL, const OpTy &Op) |
| |
| template<typename OpTy > |
| CastOperator_match< OpTy, Instruction::IntToPtr > | llvm::PatternMatch::m_IntToPtr (const OpTy &Op) |
| | Matches IntToPtr.
|
| |
| template<typename OpTy > |
| CastInst_match< OpTy, TruncInst > | llvm::PatternMatch::m_Trunc (const OpTy &Op) |
| | Matches Trunc.
|
| |
| template<typename OpTy > |
| NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap > | llvm::PatternMatch::m_NUWTrunc (const OpTy &Op) |
| | Matches trunc nuw.
|
| |
| template<typename OpTy > |
| NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap > | llvm::PatternMatch::m_NSWTrunc (const OpTy &Op) |
| | Matches trunc nsw.
|
| |
| template<typename OpTy > |
| match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy > | llvm::PatternMatch::m_TruncOrSelf (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, SExtInst > | llvm::PatternMatch::m_SExt (const OpTy &Op) |
| | Matches SExt.
|
| |
| template<typename OpTy > |
| CastInst_match< OpTy, ZExtInst > | llvm::PatternMatch::m_ZExt (const OpTy &Op) |
| | Matches ZExt.
|
| |
| template<typename OpTy > |
| NNegZExt_match< OpTy > | llvm::PatternMatch::m_NNegZExt (const OpTy &Op) |
| |
| template<typename OpTy > |
| match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy > | llvm::PatternMatch::m_ZExtOrSelf (const OpTy &Op) |
| |
| template<typename OpTy > |
| match_combine_or< CastInst_match< OpTy, SExtInst >, OpTy > | llvm::PatternMatch::m_SExtOrSelf (const OpTy &Op) |
| |
| template<typename OpTy > |
| match_combine_or< CastInst_match< OpTy, SExtInst >, NNegZExt_match< OpTy > > | llvm::PatternMatch::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 > > | llvm::PatternMatch::m_ZExtOrSExt (const OpTy &Op) |
| |
| template<typename OpTy > |
| match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy > | llvm::PatternMatch::m_ZExtOrSExtOrSelf (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, UIToFPInst > | llvm::PatternMatch::m_UIToFP (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, SIToFPInst > | llvm::PatternMatch::m_SIToFP (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, FPToUIInst > | llvm::PatternMatch::m_FPToUI (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, FPToSIInst > | llvm::PatternMatch::m_FPToSI (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, FPTruncInst > | llvm::PatternMatch::m_FPTrunc (const OpTy &Op) |
| |
| template<typename OpTy > |
| CastInst_match< OpTy, FPExtInst > | llvm::PatternMatch::m_FPExt (const OpTy &Op) |
| |
| br_match | llvm::PatternMatch::m_UnconditionalBr (BasicBlock *&Succ) |
| |
| 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) |
| |
| 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) |
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > | llvm::PatternMatch::m_SMax (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > | llvm::PatternMatch::m_SMin (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > | llvm::PatternMatch::m_UMax (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > | llvm::PatternMatch::m_UMin (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > > | llvm::PatternMatch::m_MaxOrMin (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > | llvm::PatternMatch::m_OrdFMax (const LHS &L, const RHS &R) |
| | Match an 'ordered' floating point maximum function.
|
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > | llvm::PatternMatch::m_OrdFMin (const LHS &L, const RHS &R) |
| | Match an 'ordered' floating point minimum function.
|
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > | llvm::PatternMatch::m_UnordFMax (const LHS &L, const RHS &R) |
| | Match an 'unordered' floating point maximum function.
|
| |
| template<typename LHS , typename RHS > |
| MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > | llvm::PatternMatch::m_UnordFMin (const LHS &L, const RHS &R) |
| | Match an 'unordered' floating point minimum function.
|
| |
| template<typename LHS , typename RHS > |
| 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) |
| | Match an 'ordered' or 'unordered' floating point maximum function.
|
| |
| template<typename LHS , typename RHS > |
| 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) |
| | Match an 'ordered' or 'unordered' floating point minimum function.
|
| |
| template<typename ValTy > |
| BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > | llvm::PatternMatch::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 > | llvm::PatternMatch::m_NotForbidPoison (const ValTy &V) |
| |
| 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.
|
| |
| template<unsigned OpI, typename Opnd_t > |
| Argument_match< Opnd_t > | llvm::PatternMatch::m_Argument (const Opnd_t &Op) |
| | Match an argument.
|
| |
| template<Intrinsic::ID IntrID> |
| IntrinsicID_match | llvm::PatternMatch::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 | llvm::PatternMatch::m_MaskedLoad (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3) |
| | Matches MaskedLoad Intrinsic.
|
| |
| 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) |
| | Matches MaskedGather Intrinsic.
|
| |
| template<Intrinsic::ID IntrID, typename T0 > |
| m_Intrinsic_Ty< T0 >::Ty | llvm::PatternMatch::m_Intrinsic (const T0 &Op0) |
| |
| template<Intrinsic::ID IntrID, typename T0 , typename T1 > |
| m_Intrinsic_Ty< T0, T1 >::Ty | llvm::PatternMatch::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 | llvm::PatternMatch::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 | llvm::PatternMatch::m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) |
| |
| template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > |
| m_Intrinsic_Ty< T0, T1, T2, T3, T4 >::Ty | llvm::PatternMatch::m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3, const T4 &Op4) |
| |
| template<Intrinsic::ID IntrID, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > |
| m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >::Ty | llvm::PatternMatch::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 | llvm::PatternMatch::m_BitReverse (const Opnd0 &Op0) |
| |
| template<typename Opnd0 > |
| m_Intrinsic_Ty< Opnd0 >::Ty | llvm::PatternMatch::m_BSwap (const Opnd0 &Op0) |
| |
| template<typename Opnd0 > |
| m_Intrinsic_Ty< Opnd0 >::Ty | llvm::PatternMatch::m_FAbs (const Opnd0 &Op0) |
| |
| template<typename Opnd0 > |
| m_Intrinsic_Ty< Opnd0 >::Ty | llvm::PatternMatch::m_FCanonicalize (const Opnd0 &Op0) |
| |
| template<typename Opnd0 , typename Opnd1 > |
| m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty | llvm::PatternMatch::m_FMin (const Opnd0 &Op0, const Opnd1 &Op1) |
| |
| template<typename Opnd0 , typename Opnd1 > |
| m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty | llvm::PatternMatch::m_FMax (const Opnd0 &Op0, const Opnd1 &Op1) |
| |
| 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) |
| |
| 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) |
| |
| template<typename Opnd0 > |
| m_Intrinsic_Ty< Opnd0 >::Ty | llvm::PatternMatch::m_Sqrt (const Opnd0 &Op0) |
| |
| template<typename Opnd0 , typename Opnd1 > |
| m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty | llvm::PatternMatch::m_CopySign (const Opnd0 &Op0, const Opnd1 &Op1) |
| |
| template<typename Opnd0 > |
| m_Intrinsic_Ty< Opnd0 >::Ty | llvm::PatternMatch::m_VecReverse (const Opnd0 &Op0) |
| |
| template<typename LHS , typename RHS > |
| AnyBinaryOp_match< LHS, RHS, true > | llvm::PatternMatch::m_c_BinOp (const LHS &L, const RHS &R) |
| | Matches a BinaryOperator with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, ICmpInst, true > | llvm::PatternMatch::m_c_ICmp (CmpPredicate &Pred, const LHS &L, const RHS &R) |
| | Matches an ICmp with a predicate over LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| CmpClass_match< LHS, RHS, ICmpInst, true > | llvm::PatternMatch::m_c_ICmp (const LHS &L, const RHS &R) |
| |
| template<typename LHS , typename RHS > |
| SpecificBinaryOp_match< LHS, RHS, true > | llvm::PatternMatch::m_c_BinOp (unsigned Opcode, const LHS &L, const RHS &R) |
| | Matches a specific opcode with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Add, true > | llvm::PatternMatch::m_c_Add (const LHS &L, const RHS &R) |
| | Matches a Add with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Mul, true > | llvm::PatternMatch::m_c_Mul (const LHS &L, const RHS &R) |
| | Matches a Mul with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::And, true > | llvm::PatternMatch::m_c_And (const LHS &L, const RHS &R) |
| | Matches an And with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Or, true > | llvm::PatternMatch::m_c_Or (const LHS &L, const RHS &R) |
| | Matches an Or with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::Xor, true > | llvm::PatternMatch::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 > | llvm::PatternMatch::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 > | llvm::PatternMatch::m_NSWNeg (const ValTy &V) |
| | Matches a 'Neg' as 'sub nsw 0, V'.
|
| |
| 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) |
| | Matches an SMin with LHS and RHS in either order.
|
| |
| 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) |
| | Matches an SMax with LHS and RHS in either order.
|
| |
| 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) |
| | Matches a UMin with LHS and RHS in either order.
|
| |
| 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) |
| | Matches a UMax with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > | llvm::PatternMatch::m_c_MaxOrMin (const LHS &L, const RHS &R) |
| |
| template<Intrinsic::ID IntrID, typename T0 , typename T1 > |
| match_combine_or< typename m_Intrinsic_Ty< T0, T1 >::Ty, typename m_Intrinsic_Ty< T1, T0 >::Ty > | llvm::PatternMatch::m_c_Intrinsic (const T0 &Op0, const T1 &Op1) |
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FAdd, true > | llvm::PatternMatch::m_c_FAdd (const LHS &L, const RHS &R) |
| | Matches FAdd with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| BinaryOp_match< LHS, RHS, Instruction::FMul, true > | llvm::PatternMatch::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 > | llvm::PatternMatch::m_Signum (const Val_t &V) |
| | Matches a signum pattern.
|
| |
| template<int Ind, typename Val_t > |
| ExtractValue_match< Ind, Val_t > | llvm::PatternMatch::m_ExtractValue (const Val_t &V) |
| | Match a single index ExtractValue instruction.
|
| |
| template<typename Val_t > |
| ExtractValue_match<-1, Val_t > | llvm::PatternMatch::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 > | llvm::PatternMatch::m_InsertValue (const Val_t &Val, const Elt_t &Elt) |
| | Matches a single index InsertValue instruction.
|
| |
| VScaleVal_match | llvm::PatternMatch::m_VScale () |
| |
| template<typename Opnd0 , typename Opnd1 > |
| m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty | llvm::PatternMatch::m_Interleave2 (const Opnd0 &Op0, const Opnd1 &Op1) |
| |
| template<typename Opnd > |
| m_Intrinsic_Ty< Opnd >::Ty | llvm::PatternMatch::m_Deinterleave2 (const Opnd &Op) |
| |
| template<typename LHS , typename RHS > |
| LogicalOp_match< LHS, RHS, Instruction::And > | llvm::PatternMatch::m_LogicalAnd (const LHS &L, const RHS &R) |
| | Matches L && R either in the form of L & R or L ? R : false.
|
| |
| auto | llvm::PatternMatch::m_LogicalAnd () |
| | Matches L && R where L and R are arbitrary values.
|
| |
| template<typename LHS , typename RHS > |
| LogicalOp_match< LHS, RHS, Instruction::And, true > | llvm::PatternMatch::m_c_LogicalAnd (const LHS &L, const RHS &R) |
| | Matches L && R with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS > |
| LogicalOp_match< LHS, RHS, Instruction::Or > | llvm::PatternMatch::m_LogicalOr (const LHS &L, const RHS &R) |
| | Matches L || R either in the form of L | R or L ? true : R.
|
| |
| auto | llvm::PatternMatch::m_LogicalOr () |
| | Matches L || R where L and R are arbitrary values.
|
| |
| template<typename LHS , typename RHS > |
| LogicalOp_match< LHS, RHS, Instruction::Or, true > | llvm::PatternMatch::m_c_LogicalOr (const LHS &L, const RHS &R) |
| | Matches L || R with LHS and RHS in either order.
|
| |
| template<typename LHS , typename RHS , bool Commutable = false> |
| auto | llvm::PatternMatch::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 | llvm::PatternMatch::m_LogicalOp () |
| | Matches either L && R or L || R where L and R are arbitrary values.
|
| |
| template<typename LHS , typename RHS > |
| auto | llvm::PatternMatch::m_c_LogicalOp (const LHS &L, const RHS &R) |
| | Matches either L && R or L || R with LHS and RHS in either order.
|
| |
