LLVM: llvm::PatternMatch Namespace Reference (original) (raw)
Classes
struct
struct
struct
Matches instructions with Opcode and any number of operands. More...
struct
struct
struct
This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APFloat. More...
struct
This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APInt. More...
struct
struct
struct
Check whether the value has the given Class and matches the nested pattern. More...
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
CommutativeBinaryIntrinsic_match
struct
struct
struct
This helper class is used to match constant scalars, vector splats, and fixed width vectors that satisfy a specified predicate. More...
struct
struct
Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers. More...
struct
struct
struct
struct
struct
struct
struct
struct
Matcher for a single index InsertValue instruction. More...
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
struct
Intrinsic matches are combinations of ID matchers, and argument matchers. More...
struct
struct
struct
struct
m_Intrinsic_Ty< T0, T1, T2, T3 >
struct
m_Intrinsic_Ty< T0, T1, T2, T3, T4 >
struct
m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >
struct
struct
struct
struct
struct
struct
Matching combinators. More...
struct
struct
Inverting matcher. More...
struct
struct
struct
struct
struct
Helper class for identifying ordered max predicates. More...
struct
Helper class for identifying ordered min predicates. More...
struct
Matches instructions with Opcode and three operands. More...
struct
struct
struct
struct
struct
struct
Matches shuffle. More...
struct
struct
Helper class for identifying signed max predicates. More...
struct
Helper class for identifying signed min predicates. More...
struct
Match a specified basic block value. More...
struct
Match a specified floating point value or vector of all elements of that value. More...
struct
Match a specified integer value or vector of all elements of that value. More...
struct
struct
struct
struct
Match a specified Value*. More...
struct
struct
Matches instructions with Opcode and three operands. More...
struct
Matches instructions with Opcode and three operands. More...
struct
struct
Helper class for identifying unordered max predicates. More...
struct
Helper class for identifying unordered min predicates. More...
struct
Helper class for identifying unsigned max predicates. More...
struct
Helper class for identifying unsigned min predicates. More...
struct
struct
Functions
template<typename Val, typename Pattern>
match (Val *V, const Pattern &P)
template<typename Val = const Value, typename Pattern>
MatchFunctor< Val, Pattern >
A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.
template<typename Pattern>
match (ArrayRef< int > Mask, const Pattern &P)
template<typename T>
OneUse_match< T >
m_OneUse (const T &SubPattern)
template<typename T>
m_AllowReassoc (const T &SubPattern)
class_match< Value >
m_Value ()
Match an arbitrary value and ignore it.
m_UnOp ()
Match an arbitrary unary operation and ignore it.
m_BinOp ()
Match an arbitrary binary operation and ignore it.
m_Cmp ()
Matches any compare instruction and ignore it.
auto
m_Undef ()
Match an arbitrary undef constant.
m_UndefValue ()
Match an arbitrary UndefValue constant.
m_Poison ()
Match an arbitrary poison constant.
m_Constant ()
Match an arbitrary Constant and ignore it.
Match an arbitrary ConstantInt and ignore it.
m_ConstantFP ()
Match an arbitrary ConstantFP and ignore it.
Match a constant expression or a constant that contains a constant expression.
template<typename T>
Splat_match< T >
m_ConstantSplat (const T &SubPattern)
Match a constant splat. TODO: Extend this to non-constant splats.
m_BasicBlock ()
Match an arbitrary basic block value and ignore it.
template
match_unless< Ty >
Match if the inner matcher does NOT match.
template<typename LTy, typename RTy>
match_combine_or< LTy, RTy >
m_CombineOr (const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
template<typename LTy, typename RTy>
match_combine_and< LTy, RTy >
m_CombineAnd (const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
m_APIntAllowPoison (const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
m_APIntForbidPoison (const APInt *&Res)
Match APInt while forbidding poison in splat vector constants.
m_APFloat (const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat.
m_APFloatAllowPoison (const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
m_APFloatForbidPoison (const APFloat *&Res)
Match APFloat while forbidding poison in splat vector constants.
template<int64_t Val>
constantint_match< Val >
Match a ConstantInt with a specific value.
cst_pred_ty< custom_checkfn< APInt > >
m_CheckedInt (function_ref< bool(const APInt &)> CheckFn)
Match an integer or vector where CheckFn(ele) for each element is true.
cst_pred_ty< custom_checkfn< APInt > >
m_CheckedInt (const Constant *&V, function_ref< bool(const APInt &)> CheckFn)
cstfp_pred_ty< custom_checkfn< APFloat > >
m_CheckedFp (function_ref< bool(const APFloat &)> CheckFn)
Match a float or vector where CheckFn(ele) for each element is true.
cstfp_pred_ty< custom_checkfn< APFloat > >
m_CheckedFp (const Constant *&V, function_ref< bool(const APFloat &)> CheckFn)
Match an integer or vector with any integral constant.
cst_pred_ty< is_shifted_mask >
m_AllOnes ()
Match an integer or vector with all bits set.
cst_pred_ty< is_all_ones, false >
cst_pred_ty< is_maxsignedvalue >
Match an integer or vector with values having all bits except for the high bit set (0x7f...).
api_pred_ty< is_maxsignedvalue >
m_MaxSignedValue (const APInt *&V)
m_Negative ()
Match an integer or vector of negative values.
m_Negative (const APInt *&V)
Match an integer or vector of non-negative values.
m_NonNegative (const APInt *&V)
cst_pred_ty< is_strictlypositive >
Match an integer or vector of strictly positive values.
api_pred_ty< is_strictlypositive >
m_StrictlyPositive (const APInt *&V)
Match an integer or vector of non-positive values.
m_NonPositive (const APInt *&V)
m_One ()
Match an integer 1 or a vector with all elements equal to 1.
m_ZeroInt ()
Match an integer 0 or a vector with all elements equal to 0.
m_Zero ()
Match any null constant or a vector with all elements equal to 0.
m_Power2 ()
Match an integer or vector power-of-2.
cst_pred_ty< is_negated_power2 >
Match a integer or vector negated power-of-2.
api_pred_ty< is_negated_power2 >
m_NegatedPower2 (const APInt *&V)
cst_pred_ty< is_negated_power2_or_zero >
Match a integer or vector negated power-of-2.
api_pred_ty< is_negated_power2_or_zero >
m_NegatedPower2OrZero (const APInt *&V)
cst_pred_ty< is_power2_or_zero >
Match an integer or vector of 0 or power-of-2 values.
api_pred_ty< is_power2_or_zero >
m_Power2OrZero (const APInt *&V)
m_SignMask ()
Match an integer or vector with only the sign bit(s) set.
m_LowBitMask ()
Match an integer or vector with only the low bit(s) set.
m_LowBitMask (const APInt *&V)
cst_pred_ty< is_lowbit_mask_or_zero >
Match an integer or vector with only the low bit(s) set.
api_pred_ty< is_lowbit_mask_or_zero >
m_LowBitMaskOrZero (const APInt *&V)
cst_pred_ty< icmp_pred_with_threshold >
m_SpecificInt_ICMP (ICmpInst::Predicate Predicate, const APInt &Threshold)
Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.
m_NaN ()
Match an arbitrary NaN constant.
m_NonNaN ()
Match a non-NaN FP constant.
m_Inf ()
Match a positive or negative infinity FP constant.
m_NonInf ()
Match a non-infinity FP constant, i.e.
m_Finite ()
Match a finite FP constant, i.e.
cstfp_pred_ty< is_finitenonzero >
Match a finite non-zero FP constant.
apf_pred_ty< is_finitenonzero >
m_FiniteNonZero (const APFloat *&V)
cstfp_pred_ty< is_any_zero_fp >
m_AnyZeroFP ()
Match a floating-point negative zero or positive zero.
cstfp_pred_ty< is_pos_zero_fp >
m_PosZeroFP ()
Match a floating-point positive zero.
cstfp_pred_ty< is_neg_zero_fp >
m_NegZeroFP ()
Match a floating-point negative zero.
cstfp_pred_ty< is_non_zero_fp >
m_NonZeroFP ()
Match a floating-point non-zero.
cstfp_pred_ty< is_non_zero_not_denormal_fp >
Match a floating-point non-zero that is not a denormal.
Match a value, capturing it if we match.
template
bind_and_match_ty< Value, MatchTy >
m_Value (Value *&V, const MatchTy &Match)
Match against the nested pattern, and capture the value if we match.
template
bind_and_match_ty< const Value, MatchTy >
m_Value (const Value *&V, const MatchTy &Match)
Match against the nested pattern, and capture the value if we match.
m_Instruction (Instruction *&I)
Match an instruction, capturing it if we match.
m_Instruction (const Instruction *&I)
template
bind_and_match_ty< Instruction, MatchTy >
m_Instruction (Instruction *&I, const MatchTy &Match)
Match against the nested pattern, and capture the instruction if we match.
template
bind_and_match_ty< const Instruction, MatchTy >
m_Instruction (const Instruction *&I, const MatchTy &Match)
m_UnOp (UnaryOperator *&I)
Match a unary operator, capturing it if we match.
bind_ty< const UnaryOperator >
m_UnOp (const UnaryOperator *&I)
m_BinOp (BinaryOperator *&I)
Match a binary operator, capturing it if we match.
bind_ty< const BinaryOperator >
m_BinOp (const BinaryOperator *&I)
m_WithOverflowInst (WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
bind_ty< const WithOverflowInst >
m_WithOverflowInst (const WithOverflowInst *&I)
m_UndefValue (UndefValue *&U)
Match an UndefValue, capturing the value if we match.
m_Constant (Constant *&C)
Match a Constant, capturing the value if we match.
m_ConstantInt (ConstantInt *&CI)
Match a ConstantInt, capturing the value if we match.
m_ConstantFP (ConstantFP *&C)
Match a ConstantFP, capturing the value if we match.
m_ConstantExpr (ConstantExpr *&C)
Match a ConstantExpr, capturing the value if we match.
m_BasicBlock (BasicBlock *&V)
Match a basic block value, capturing it if we match.
m_BasicBlock (const BasicBlock *&V)
Match an arbitrary immediate Constant and ignore it.
m_ImmConstant (Constant *&C)
Match an immediate Constant, capturing the value if we match.
m_Specific (const Value *V)
Match if we have a specific specified value.
m_Deferred (Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match() expression.
m_Deferred (const Value *const &V)
m_SpecificFP (double V)
Match a specific floating point value or vector with all elements equal to the value.
m_FPOne ()
Match a float 1.0 or vector with all elements equal to 1.0.
specific_intval< false >
m_SpecificInt (const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
specific_intval64< false >
specific_intval< true >
m_SpecificIntAllowPoison (const APInt &V)
specific_intval64< true >
m_SpecificIntAllowPoison (uint64_t V)
m_ConstantInt (uint64_t &V)
Match a ConstantInt and bind to its value.
m_SpecificBB (BasicBlock *BB)
Match a specific basic block value.
m_Deferred (BasicBlock *const &BB)
A commutative-friendly version of m_Specific().
deferredval_ty< const BasicBlock >
m_Deferred (const BasicBlock *const &BB)
template<typename LHS, typename RHS>
AnyBinaryOp_match< LHS, RHS >
m_BinOp (const LHS &L, const RHS &R)
template<typename OP_t>
AnyUnaryOp_match< OP_t >
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
FNeg_match< OpTy >
Match 'fneg X' as 'fsub -0.0, X'.
template<typename RHS>
BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub >
Match 'fneg X' as 'fsub +-0.0, X'.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Mul >
m_Mul (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::FMul >
m_FMul (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::UDiv >
m_UDiv (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::SDiv >
m_SDiv (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::FDiv >
m_FDiv (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::URem >
m_URem (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::SRem >
m_SRem (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::FRem >
m_FRem (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::And >
m_And (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Or >
m_Or (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Xor >
m_Xor (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Shl >
m_Shl (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::LShr >
m_LShr (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::AShr >
m_AShr (const LHS &L, const RHS &R)
template<typename LHS>
ShiftLike_match< LHS, Instruction::Shl >
m_ShlOrSelf (const LHS &L, uint64_t &R)
Matches shl L, ConstShAmt or L itself (R will be set to zero in this case).
template<typename LHS>
ShiftLike_match< LHS, Instruction::LShr >
m_LShrOrSelf (const LHS &L, uint64_t &R)
Matches lshr L, ConstShAmt or L itself (R will be set to zero in this case).
template<typename LHS>
ShiftLike_match< LHS, Instruction::AShr >
m_AShrOrSelf (const LHS &L, uint64_t &R)
Matches ashr L, ConstShAmt or L itself (R will be set to zero in this case).
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >
m_NSWAdd (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap, true >
m_c_NSWAdd (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap >
m_NSWSub (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap >
m_NSWMul (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap >
m_NSWShl (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >
m_NUWAdd (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true >
m_c_NUWAdd (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap >
m_NUWSub (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap >
m_NUWMul (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap >
m_NUWShl (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificBinaryOp_match< LHS, RHS >
m_BinOp (unsigned Opcode, const LHS &L, const RHS &R)
Matches a specific opcode.
template<typename LHS, typename RHS>
DisjointOr_match< LHS, RHS >
m_DisjointOr (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
DisjointOr_match< LHS, RHS, true >
m_c_DisjointOr (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > >
m_AddLike (const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
template<typename LHS, typename RHS>
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > >
m_NSWAddLike (const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
template<typename LHS, typename RHS>
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > >
m_NUWAddLike (const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
template<typename LHS, typename RHS>
auto
m_c_XorLike (const LHS &L, const RHS &R)
Match either (xor L, R), (xor R, L) or (sub nuw R, L) iff R.isMask() Only commutative matcher as the sub will need to swap the L and R.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_shift_op >
m_Shift (const LHS &L, const RHS &R)
Matches shift operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_right_shift_op >
m_Shr (const LHS &L, const RHS &R)
Matches logical shift operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_logical_shift_op >
m_LogicalShift (const LHS &L, const RHS &R)
Matches logical shift operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_bitwiselogic_op >
m_BitwiseLogic (const LHS &L, const RHS &R)
Matches bitwise logic operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_bitwiselogic_op, true >
m_c_BitwiseLogic (const LHS &L, const RHS &R)
Matches bitwise logic operations in either order.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_idiv_op >
m_IDiv (const LHS &L, const RHS &R)
Matches integer division operations.
template<typename LHS, typename RHS>
BinOpPred_match< LHS, RHS, is_irem_op >
m_IRem (const LHS &L, const RHS &R)
Matches integer remainder operations.
template<typename T>
Exact_match< T >
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, CmpInst >
m_Cmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst >
m_ICmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, FCmpInst >
m_FCmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, CmpInst >
m_Cmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst >
m_ICmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, FCmpInst >
m_FCmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, CmpInst >
m_SpecificCmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, ICmpInst >
m_SpecificICmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, ICmpInst, true >
m_c_SpecificICmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificCmpClass_match< LHS, RHS, FCmpInst >
m_SpecificFCmp (CmpPredicate MatchPred, const LHS &L, const RHS &R)
template<typename Cond, typename LHS, typename RHS>
ThreeOps_match< Cond, LHS, RHS, Instruction::Select >
m_Select (const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
template<int64_t L, int64_t R, typename Cond>
ThreeOps_match< Cond, constantint_match< L >, constantint_match< R >, Instruction::Select >
m_SelectCst (const Cond &C)
This matches a select of two constants, e.g.: m_SelectCst<-1, 0>(m_Value(V))
template<typename LHS, typename RHS>
ThreeOps_match< decltype(m_Value()), LHS, RHS, Instruction::Select, true >
m_c_Select (const LHS &L, const RHS &R)
Match Select(C, LHS, RHS) or Select(C, RHS, LHS)
template
OneOps_match< OpTy, Instruction::Freeze >
Matches FreezeInst.
template<typename Val_t, typename Elt_t, typename Idx_t>
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement >
m_InsertElt (const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
template<typename Val_t, typename Idx_t>
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement >
m_ExtractElt (const Val_t &Val, const Idx_t &Idx)
Matches ExtractElementInst.
template<typename V1_t, typename V2_t>
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector >
m_Shuffle (const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
template<typename V1_t, typename V2_t, typename Mask_t>
Shuffle_match< V1_t, V2_t, Mask_t >
m_Shuffle (const V1_t &v1, const V2_t &v2, const Mask_t &mask)
template
OneOps_match< OpTy, Instruction::Load >
Matches LoadInst.
template<typename ValueOpTy, typename PointerOpTy>
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store >
m_Store (const ValueOpTy &ValueOp, const PointerOpTy &PointerOp)
Matches StoreInst.
template<typename... OperandTypes>
auto
m_GEP (const OperandTypes &...Ops)
Matches GetElementPtrInst.
template<typename PointerOpTy, typename OffsetOpTy>
PtrAdd_match< PointerOpTy, OffsetOpTy >
m_PtrAdd (const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
Matches GEP with i8 source element type.
template
CastOperator_match< OpTy, Instruction::BitCast >
Matches BitCast.
template
ElementWiseBitCast_match< OpTy >
m_ElementWiseBitCast (const OpTy &Op)
template
CastOperator_match< OpTy, Instruction::PtrToInt >
m_PtrToInt (const OpTy &Op)
Matches PtrToInt.
template
PtrToIntSameSize_match< OpTy >
m_PtrToIntSameSize (const DataLayout &DL, const OpTy &Op)
template
CastOperator_match< OpTy, Instruction::PtrToAddr >
m_PtrToAddr (const OpTy &Op)
Matches PtrToAddr.
template
auto
m_PtrToIntOrAddr (const OpTy &Op)
Matches PtrToInt or PtrToAddr.
template
CastOperator_match< OpTy, Instruction::IntToPtr >
m_IntToPtr (const OpTy &Op)
Matches IntToPtr.
template
match_combine_or< CastInst_match< OpTy, CastInst >, OpTy >
m_CastOrSelf (const OpTy &Op)
Matches any cast or self. Used to ignore casts.
template
CastInst_match< OpTy, TruncInst >
Matches Trunc.
template
NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap >
m_NUWTrunc (const OpTy &Op)
Matches trunc nuw.
template
NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap >
m_NSWTrunc (const OpTy &Op)
Matches trunc nsw.
template
match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy >
m_TruncOrSelf (const OpTy &Op)
template
CastInst_match< OpTy, SExtInst >
Matches SExt.
template
CastInst_match< OpTy, ZExtInst >
Matches ZExt.
template
NNegZExt_match< OpTy >
m_NNegZExt (const OpTy &Op)
template
match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy >
m_ZExtOrSelf (const OpTy &Op)
template
match_combine_or< CastInst_match< OpTy, SExtInst >, OpTy >
m_SExtOrSelf (const OpTy &Op)
template
match_combine_or< CastInst_match< OpTy, SExtInst >, NNegZExt_match< OpTy > >
m_SExtLike (const OpTy &Op)
Match either "sext" or "zext nneg".
template
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >
m_ZExtOrSExt (const OpTy &Op)
template
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy >
m_ZExtOrSExtOrSelf (const OpTy &Op)
template
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, TruncInst > >, OpTy >
m_ZExtOrTruncOrSelf (const OpTy &Op)
template
CastInst_match< OpTy, UIToFPInst >
template
CastInst_match< OpTy, SIToFPInst >
template
CastInst_match< OpTy, FPToUIInst >
template
CastInst_match< OpTy, FPToSIInst >
template
CastInst_match< OpTy, FPTruncInst >
template
CastInst_match< OpTy, FPExtInst >
m_UnconditionalBr (BasicBlock *&Succ)
template<typename Cond_t>
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > >
m_Br (const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
template<typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
brc_match< Cond_t, TrueBlock_t, FalseBlock_t >
m_Br (const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F)
template<typename LHS, typename RHS>
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >
m_SMax (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty >
m_SMin (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >
m_UMax (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty >
m_UMin (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > >
m_MaxOrMin (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty >
m_OrdFMax (const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
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.
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.
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.
template<typename LHS, typename RHS>
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > >
m_OrdOrUnordFMax (const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point maximum function.
template<typename LHS, typename RHS>
match_combine_or< MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty >, MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > >
m_OrdOrUnordFMin (const LHS &L, const RHS &R)
Match an 'ordered' or 'unordered' floating point minimum function.
template
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true >
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
template
BinaryOp_match< cst_pred_ty< is_all_ones, false >, ValTy, Instruction::Xor, true >
m_NotForbidPoison (const ValTy &V)
template<typename LHS_t, typename RHS_t, typename Sum_t>
UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >
m_UAddWithOverflow (const LHS_t &L, const RHS_t &R, const Sum_t &S)
Match an icmp instruction checking for unsigned overflow on addition.
template<unsigned OpI, typename Opnd_t>
Argument_match< Opnd_t >
m_Argument (const Opnd_t &Op)
Match an argument.
template<Intrinsic::ID IntrID>
m_Intrinsic ()
Match intrinsic calls like this: m_IntrinsicIntrinsic::fabs(m_Value(X))
template<typename Opnd0, typename Opnd1, typename Opnd2>
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty
m_MaskedLoad (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Matches MaskedLoad Intrinsic.
template<typename Opnd0, typename Opnd1, typename Opnd2>
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty
m_MaskedStore (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Matches MaskedStore Intrinsic.
template<typename Opnd0, typename Opnd1, typename Opnd2>
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty
m_MaskedGather (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Matches MaskedGather Intrinsic.
template<Intrinsic::ID IntrID, typename T0>
m_Intrinsic_Ty< T0 >::Ty
m_Intrinsic (const T0 &Op0)
template<Intrinsic::ID IntrID, typename T0, typename T1>
m_Intrinsic_Ty< T0, T1 >::Ty
m_Intrinsic (const T0 &Op0, const T1 &Op1)
template<Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
m_Intrinsic_Ty< T0, T1, T2 >::Ty
m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2)
template<Intrinsic::ID IntrID, typename T0, typename T1, typename T2, typename T3>
m_Intrinsic_Ty< T0, T1, T2, T3 >::Ty
m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3)
template<Intrinsic::ID IntrID, typename T0, typename T1, typename T2, typename T3, typename T4>
m_Intrinsic_Ty< T0, T1, T2, T3, T4 >::Ty
m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3, const T4 &Op4)
template<Intrinsic::ID IntrID, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >::Ty
m_Intrinsic (const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3, const T4 &Op4, const T5 &Op5)
template
m_Intrinsic_Ty< Opnd0 >::Ty
m_BitReverse (const Opnd0 &Op0)
template
m_Intrinsic_Ty< Opnd0 >::Ty
template
m_Intrinsic_Ty< Opnd0 >::Ty
template
m_Intrinsic_Ty< Opnd0 >::Ty
m_FCanonicalize (const Opnd0 &Op0)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_FMinNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_FMinimum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_FMinimumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_FMaxNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_FMaximum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_FMaximumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1, typename Opnd2>
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty
m_FShl (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
template<typename Opnd0, typename Opnd1, typename Opnd2>
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty
m_FShr (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
template
m_Intrinsic_Ty< Opnd0 >::Ty
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_CopySign (const Opnd0 &Op0, const Opnd1 &Op1)
template
m_Intrinsic_Ty< Opnd0 >::Ty
m_VecReverse (const Opnd0 &Op0)
template<typename Opnd0, typename Opnd1, typename Opnd2>
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty
m_VectorInsert (const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
template<typename LHS, typename RHS>
AnyBinaryOp_match< LHS, RHS, true >
m_c_BinOp (const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst, true >
m_c_ICmp (CmpPredicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
template<typename LHS, typename RHS>
CmpClass_match< LHS, RHS, ICmpInst, true >
m_c_ICmp (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
SpecificBinaryOp_match< LHS, RHS, true >
m_c_BinOp (unsigned Opcode, const LHS &L, const RHS &R)
Matches a specific opcode with LHS and RHS in either order.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Add, true >
m_c_Add (const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Mul, true >
m_c_Mul (const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::And, true >
m_c_And (const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Or, true >
m_c_Or (const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::Xor, true >
m_c_Xor (const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
template
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub >
Matches a 'Neg' as 'sub 0, V'.
template
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap >
Matches a 'Neg' as 'sub nsw 0, V'.
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.
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.
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.
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.
template<typename LHS, typename RHS>
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > >
m_c_MaxOrMin (const LHS &L, const RHS &R)
template<Intrinsic::ID IntrID, typename T0, typename T1>
CommutativeBinaryIntrinsic_match< IntrID, T0, T1 >
m_c_Intrinsic (const T0 &Op0, const T1 &Op1)
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::FAdd, true >
m_c_FAdd (const LHS &L, const RHS &R)
Matches FAdd with LHS and RHS in either order.
template<typename LHS, typename RHS>
BinaryOp_match< LHS, RHS, Instruction::FMul, true >
m_c_FMul (const LHS &L, const RHS &R)
Matches FMul with LHS and RHS in either order.
template<typename Val_t>
Signum_match< Val_t >
Matches a signum pattern.
template<int Ind, typename Val_t>
ExtractValue_match< Ind, Val_t >
m_ExtractValue (const Val_t &V)
Match a single index ExtractValue instruction.
template<typename Val_t>
ExtractValue_match<-1, Val_t >
m_ExtractValue (const Val_t &V)
Match an ExtractValue instruction with any index.
template<int Ind, typename Val_t, typename Elt_t>
InsertValue_match< Ind, Val_t, Elt_t >
m_InsertValue (const Val_t &Val, const Elt_t &Elt)
Matches a single index InsertValue instruction.
m_VScale ()
Matches a call to llvm.vscale().
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty
m_Interleave2 (const Opnd0 &Op0, const Opnd1 &Op1)
template
m_Intrinsic_Ty< Opnd >::Ty
m_Deinterleave2 (const Opnd &Op)
template<typename LHS, typename RHS>
LogicalOp_match< LHS, RHS, Instruction::And >
m_LogicalAnd (const LHS &L, const RHS &R)
Matches L && R either in the form of L & R or L ?
auto
m_LogicalAnd ()
Matches L && R where L and R are arbitrary values.
template<typename LHS, typename RHS>
LogicalOp_match< LHS, RHS, Instruction::And, true >
m_c_LogicalAnd (const LHS &L, const RHS &R)
Matches L && R with LHS and RHS in either order.
template<typename LHS, typename RHS>
LogicalOp_match< LHS, RHS, Instruction::Or >
m_LogicalOr (const LHS &L, const RHS &R)
Matches L || R either in the form of L | R or L ?
auto
m_LogicalOr ()
Matches L || R where L and R are arbitrary values.
template<typename LHS, typename RHS>
LogicalOp_match< LHS, RHS, Instruction::Or, true >
m_c_LogicalOr (const LHS &L, const RHS &R)
Matches L || R with LHS and RHS in either order.
template<typename LHS, typename RHS, bool Commutable = false>
auto
m_LogicalOp (const LHS &L, const RHS &R)
Matches either L && R or L || R, either one being in the either binary or logical form.
auto
m_LogicalOp ()
Matches either L && R or L || R where L and R are arbitrary values.
template<typename LHS, typename RHS>
auto
m_c_LogicalOp (const LHS &L, const RHS &R)
Matches either L && R or L || R with LHS and RHS in either order.