LLVM 19.0.0git
Classes | Namespaces | Typedefs | Functions
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::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 >
 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::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::bind_ty< Class >
 
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< AllowUndefs >
 Match a specified integer value or vector of all elements of that value. More...
 
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::OverflowingBinaryOp_match< LHS_t, RHS_t, Opcode, WrapFlags >
 
struct  llvm::PatternMatch::SpecificBinaryOp_match< LHS_t, RHS_t, Commutable >
 
struct  llvm::PatternMatch::DisjointOr_match< LHS, RHS, Commutable >
 
struct  llvm::PatternMatch::BinOpPred_match< LHS_t, RHS_t, Predicate >
 
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, PredicateTy, 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 >
 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_SplatOrUndefMask
 
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::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::NotForbidUndef_match< ValTy >
 
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::VScaleVal_match
 Matches patterns for vscale. 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 >
using llvm::PatternMatch::cst_pred_ty = cstval_pred_ty< Predicate, ConstantInt >
 specialization of cstval_pred_ty for ConstantInt
 
template<typename Predicate >
using llvm::PatternMatch::cstfp_pred_ty = cstval_pred_ty< Predicate, ConstantFP >
 specialization of cstval_pred_ty for ConstantFP
 

Functions

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< Tllvm::PatternMatch::m_OneUse (const T &SubPattern)
 
template<typename T >
AllowReassoc_match< Tllvm::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< 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_APIntAllowUndef (const APInt *&Res)
 Match APInt while allowing undefs in splat vector constants.
 
apint_match llvm::PatternMatch::m_APIntForbidUndef (const APInt *&Res)
 Match APInt while forbidding undefs 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_APFloatAllowUndef (const APFloat *&Res)
 Match APFloat while allowing undefs in splat vector constants.
 
apfloat_match llvm::PatternMatch::m_APFloatForbidUndef (const APFloat *&Res)
 Match APFloat while forbidding undefs 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< 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_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.
 
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< 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 (APInt V)
 Match a specific integer value or vector with all elements equal to the value.
 
specific_intval< false > llvm::PatternMatch::m_SpecificInt (uint64_t V)
 
specific_intval< truellvm::PatternMatch::m_SpecificIntAllowUndef (APInt V)
 
specific_intval< truellvm::PatternMatch::m_SpecificIntAllowUndef (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, RHSllvm::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::Mulllvm::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::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, RHSllvm::PatternMatch::m_BinOp (unsigned Opcode, const LHS &L, const RHS &R)
 Matches a specific opcode.
 
template<typename LHS , typename RHS >
DisjointOr_match< LHS, RHSllvm::PatternMatch::m_DisjointOr (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
DisjointOr_match< LHS, RHS, truellvm::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 >
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_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< Tllvm::PatternMatch::m_Exact (const T &SubPattern)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, CmpInst, CmpInst::Predicate > llvm::PatternMatch::m_Cmp (CmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > llvm::PatternMatch::m_ICmp (ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > llvm::PatternMatch::m_FCmp (FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 
template<typename Cond , typename LHS , typename RHS >
ThreeOps_match< Cond, LHS, RHS, Instruction::Selectllvm::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::Selectllvm::PatternMatch::m_SelectCst (const Cond &C)
 This matches a select of two constants, e.g.: m_SelectCst<-1, 0>(m_Value(V))
 
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 >
CastOperator_match< OpTy, Instruction::Trunc > llvm::PatternMatch::m_Trunc (const OpTy &Op)
 Matches Trunc.
 
template<typename OpTy >
match_combine_or< CastOperator_match< OpTy, Instruction::Trunc >, 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_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, truellvm::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, ICmpInst::Predicate, truellvm::PatternMatch::m_c_ICmp (ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
 Matches an ICmp with a predicate over LHS and RHS in either order.
 
template<typename LHS , typename RHS >
SpecificBinaryOp_match< LHS, RHS, truellvm::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, truellvm::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, truellvm::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, truellvm::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, truellvm::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, truellvm::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 ValTy >
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, truellvm::PatternMatch::m_Not (const ValTy &V)
 Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
 
template<typename ValTy >
NotForbidUndef_match< ValTy > llvm::PatternMatch::m_NotForbidUndef (const ValTy &V)
 Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'.
 
template<typename LHS , typename RHS >
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, truellvm::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, truellvm::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, truellvm::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, truellvm::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, truellvm::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, truellvm::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 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, truellvm::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, truellvm::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.