PatternMatch.h File Reference

#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/Casting.h"
#include <cstdint>

Go to the source code of this file.

Classes
struct	llvm::PatternMatch::MatchFunctor< Val, Pattern >
struct	llvm::PatternMatch::OneUse_match< SubPattern_t >
struct	llvm::PatternMatch::AllowReassoc_match< SubPattern_t >
struct	llvm::PatternMatch::class_match< Class >
struct	llvm::PatternMatch::undef_match
struct	llvm::PatternMatch::constantexpr_match
struct	llvm::PatternMatch::match_unless< Ty >
	Inverting matcher. More...
struct	llvm::PatternMatch::match_combine_or< LTy, RTy >
	Matching combinators. More...
struct	llvm::PatternMatch::match_combine_and< LTy, RTy >
struct	llvm::PatternMatch::apint_match
struct	llvm::PatternMatch::apfloat_match
struct	llvm::PatternMatch::constantint_match< Val >
struct	llvm::PatternMatch::cstval_pred_ty< Predicate, ConstantVal, AllowPoison >
	This helper class is used to match constant scalars, vector splats, and fixed width vectors that satisfy a specified predicate. More...
struct	llvm::PatternMatch::api_pred_ty< Predicate >
	This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APInt. More...
struct	llvm::PatternMatch::apf_pred_ty< Predicate >
	This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APFloat. More...
struct	llvm::PatternMatch::custom_checkfn< APTy >
struct	llvm::PatternMatch::is_any_apint
struct	llvm::PatternMatch::is_shifted_mask
struct	llvm::PatternMatch::is_all_ones
struct	llvm::PatternMatch::is_maxsignedvalue
struct	llvm::PatternMatch::is_negative
struct	llvm::PatternMatch::is_nonnegative
struct	llvm::PatternMatch::is_strictlypositive
struct	llvm::PatternMatch::is_nonpositive
struct	llvm::PatternMatch::is_one
struct	llvm::PatternMatch::is_zero_int
struct	llvm::PatternMatch::is_zero
struct	llvm::PatternMatch::is_power2
struct	llvm::PatternMatch::is_negated_power2
struct	llvm::PatternMatch::is_negated_power2_or_zero
struct	llvm::PatternMatch::is_power2_or_zero
struct	llvm::PatternMatch::is_sign_mask
struct	llvm::PatternMatch::is_lowbit_mask
struct	llvm::PatternMatch::is_lowbit_mask_or_zero
struct	llvm::PatternMatch::icmp_pred_with_threshold
struct	llvm::PatternMatch::is_nan
struct	llvm::PatternMatch::is_nonnan
struct	llvm::PatternMatch::is_inf
struct	llvm::PatternMatch::is_noninf
struct	llvm::PatternMatch::is_finite
struct	llvm::PatternMatch::is_finitenonzero
struct	llvm::PatternMatch::is_any_zero_fp
struct	llvm::PatternMatch::is_pos_zero_fp
struct	llvm::PatternMatch::is_neg_zero_fp
struct	llvm::PatternMatch::is_non_zero_fp
struct	llvm::PatternMatch::is_non_zero_not_denormal_fp
struct	llvm::PatternMatch::bind_ty< Class >
struct	llvm::PatternMatch::bind_and_match_ty< Class, MatchTy >
	Check whether the value has the given Class and matches the nested pattern. More...
struct	llvm::PatternMatch::immconstant_ty
struct	llvm::PatternMatch::match_immconstant_ty
struct	llvm::PatternMatch::bind_immconstant_ty
struct	llvm::PatternMatch::specificval_ty
	Match a specified Value*. More...
struct	llvm::PatternMatch::deferredval_ty< Class >
	Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers. More...
struct	llvm::PatternMatch::specific_fpval
	Match a specified floating point value or vector of all elements of that value. More...
struct	llvm::PatternMatch::bind_const_intval_ty
struct	llvm::PatternMatch::specific_intval< AllowPoison >
	Match a specified integer value or vector of all elements of that value. More...
struct	llvm::PatternMatch::specific_intval64< AllowPoison >
struct	llvm::PatternMatch::specific_bbval
	Match a specified basic block value. More...
struct	llvm::PatternMatch::AnyBinaryOp_match< LHS_t, RHS_t, Commutable >
struct	llvm::PatternMatch::AnyUnaryOp_match< OP_t >
struct	llvm::PatternMatch::BinaryOp_match< LHS_t, RHS_t, Opcode, Commutable >
struct	llvm::PatternMatch::FNeg_match< Op_t >
struct	llvm::PatternMatch::ShiftLike_match< LHS_t, Opcode >
struct	llvm::PatternMatch::OverflowingBinaryOp_match< LHS_t, RHS_t, Opcode, WrapFlags, Commutable >
struct	llvm::PatternMatch::SpecificBinaryOp_match< LHS_t, RHS_t, Commutable >
struct	llvm::PatternMatch::DisjointOr_match< LHS, RHS, Commutable >
struct	llvm::PatternMatch::XorLike_match< LHS, RHS >
struct	llvm::PatternMatch::BinOpPred_match< LHS_t, RHS_t, Predicate, Commutable >
struct	llvm::PatternMatch::is_shift_op
struct	llvm::PatternMatch::is_right_shift_op
struct	llvm::PatternMatch::is_logical_shift_op
struct	llvm::PatternMatch::is_bitwiselogic_op
struct	llvm::PatternMatch::is_idiv_op
struct	llvm::PatternMatch::is_irem_op
struct	llvm::PatternMatch::Exact_match< SubPattern_t >
struct	llvm::PatternMatch::CmpClass_match< LHS_t, RHS_t, Class, Commutable >
struct	llvm::PatternMatch::SpecificCmpClass_match< LHS_t, RHS_t, Class, Commutable >
struct	llvm::PatternMatch::OneOps_match< T0, Opcode >
	Matches instructions with Opcode and three operands. More...
struct	llvm::PatternMatch::TwoOps_match< T0, T1, Opcode >
	Matches instructions with Opcode and three operands. More...
struct	llvm::PatternMatch::ThreeOps_match< T0, T1, T2, Opcode, CommutableOp2Op3 >
	Matches instructions with Opcode and three operands. More...
struct	llvm::PatternMatch::AnyOps_match< Opcode, OperandTypes >
	Matches instructions with Opcode and any number of operands. More...
struct	llvm::PatternMatch::Shuffle_match< T0, T1, T2 >
	Matches shuffle. More...
struct	llvm::PatternMatch::m_Mask
struct	llvm::PatternMatch::m_ZeroMask
struct	llvm::PatternMatch::m_SpecificMask
struct	llvm::PatternMatch::m_SplatOrPoisonMask
struct	llvm::PatternMatch::PtrAdd_match< PointerOpTy, OffsetOpTy >
struct	llvm::PatternMatch::CastOperator_match< Op_t, Opcode >
struct	llvm::PatternMatch::CastInst_match< Op_t, Class >
struct	llvm::PatternMatch::PtrToIntSameSize_match< Op_t >
struct	llvm::PatternMatch::NNegZExt_match< Op_t >
struct	llvm::PatternMatch::NoWrapTrunc_match< Op_t, WrapFlags >
struct	llvm::PatternMatch::ElementWiseBitCast_match< Op_t >
struct	llvm::PatternMatch::br_match
struct	llvm::PatternMatch::brc_match< Cond_t, TrueBlock_t, FalseBlock_t >
struct	llvm::PatternMatch::MaxMin_match< CmpInst_t, LHS_t, RHS_t, Pred_t, Commutable >
struct	llvm::PatternMatch::smax_pred_ty
	Helper class for identifying signed max predicates. More...
struct	llvm::PatternMatch::smin_pred_ty
	Helper class for identifying signed min predicates. More...
struct	llvm::PatternMatch::umax_pred_ty
	Helper class for identifying unsigned max predicates. More...
struct	llvm::PatternMatch::umin_pred_ty
	Helper class for identifying unsigned min predicates. More...
struct	llvm::PatternMatch::ofmax_pred_ty
	Helper class for identifying ordered max predicates. More...
struct	llvm::PatternMatch::ofmin_pred_ty
	Helper class for identifying ordered min predicates. More...
struct	llvm::PatternMatch::ufmax_pred_ty
	Helper class for identifying unordered max predicates. More...
struct	llvm::PatternMatch::ufmin_pred_ty
	Helper class for identifying unordered min predicates. More...
struct	llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >
struct	llvm::PatternMatch::Argument_match< Opnd_t >
struct	llvm::PatternMatch::IntrinsicID_match
	Intrinsic matchers. More...
struct	llvm::PatternMatch::m_Intrinsic_Ty< T0 >
struct	llvm::PatternMatch::m_Intrinsic_Ty< T0, T1 >
struct	llvm::PatternMatch::m_Intrinsic_Ty< T0, T1, T2 >
struct	llvm::PatternMatch::m_Intrinsic_Ty< T0, T1, T2, T3 >
struct	llvm::PatternMatch::m_Intrinsic_Ty< T0, T1, T2, T3, T4 >
struct	llvm::PatternMatch::m_Intrinsic_Ty< T0, T1, T2, T3, T4, T5 >
struct	llvm::PatternMatch::Signum_match< Opnd_t >
struct	llvm::PatternMatch::ExtractValue_match< Ind, Opnd_t >
struct	llvm::PatternMatch::InsertValue_match< Ind, T0, T1 >
	Matcher for a single index InsertValue instruction. More...
struct	llvm::PatternMatch::LogicalOp_match< LHS, RHS, Opcode, Commutable >

Namespaces
namespace	llvm
	This is an optimization pass for GlobalISel generic memory operations.
namespace	llvm::PatternMatch

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

Functions
template<typename Val, typename Pattern>
bool	llvm::PatternMatch::match (Val *V, const Pattern &P)
template<typename Val = const Value, typename Pattern>
MatchFunctor< Val, Pattern >	llvm::PatternMatch::match_fn (const Pattern &P)
	A match functor that can be used as a UnaryPredicate in functional algorithms like all_of.
template<typename Pattern>
bool	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)
template<typename MatchTy>
bind_and_match_ty< Value, MatchTy >	llvm::PatternMatch::m_Value (Value *&V, const MatchTy &Match)
	Match against the nested pattern, and capture the value if we match.
template<typename MatchTy>
bind_and_match_ty< const Value, MatchTy >	llvm::PatternMatch::m_Value (const Value *&V, const MatchTy &Match)
	Match against the nested pattern, and capture the value if we match.
bind_ty< Instruction >	llvm::PatternMatch::m_Instruction (Instruction *&I)
	Match an instruction, capturing it if we match.
template<typename MatchTy>
bind_and_match_ty< Instruction, MatchTy >	llvm::PatternMatch::m_Instruction (Instruction *&I, const MatchTy &Match)
	Match against the nested pattern, and capture the instruction 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_immconstant_ty	llvm::PatternMatch::m_ImmConstant ()
	Match an arbitrary immediate Constant and ignore it.
bind_immconstant_ty	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>
ShiftLike_match< LHS, Instruction::Shl >	llvm::PatternMatch::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 >	llvm::PatternMatch::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 >	llvm::PatternMatch::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 >	llvm::PatternMatch::m_NSWAdd (const LHS &L, const RHS &R)
template<typename LHS, typename RHS>
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap, true >	llvm::PatternMatch::m_c_NSWAdd (const LHS &L, const RHS &R)
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>
auto	llvm::PatternMatch::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 >	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>
match_combine_or< CastInst_match< OpTy, CastInst >, OpTy >	llvm::PatternMatch::m_CastOrSelf (const OpTy &Op)
	Matches any cast or self. Used to ignore casts.
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>
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, TruncInst > >, OpTy >	llvm::PatternMatch::m_ZExtOrTruncOrSelf (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_FMinNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	llvm::PatternMatch::m_FMinimum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	llvm::PatternMatch::m_FMinimumNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	llvm::PatternMatch::m_FMaxNum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	llvm::PatternMatch::m_FMaximum (const Opnd0 &Op0, const Opnd1 &Op1)
template<typename Opnd0, typename Opnd1>
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty	llvm::PatternMatch::m_FMaximumNum (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.
IntrinsicID_match	llvm::PatternMatch::m_VScale ()
	Matches a call to llvm.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 ?
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 ?
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.