LLVM  6.0.0svn
Classes | Namespaces | Functions
PatternMatch.h File Reference
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/IR/CallSite.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/Casting.h"
#include <cstdint>
Include dependency graph for PatternMatch.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  llvm::PatternMatch::OneUse_match< SubPattern_t >
 
struct  llvm::PatternMatch::class_match< Class >
 
struct  llvm::PatternMatch::match_combine_or< LTy, RTy >
 Matching combinators. More...
 
struct  llvm::PatternMatch::match_combine_and< LTy, RTy >
 
struct  llvm::PatternMatch::match_zero
 
struct  llvm::PatternMatch::match_neg_zero
 
struct  llvm::PatternMatch::match_any_zero
 
struct  llvm::PatternMatch::match_nan
 
struct  llvm::PatternMatch::match_one
 
struct  llvm::PatternMatch::match_all_ones
 
struct  llvm::PatternMatch::match_sign_mask
 
struct  llvm::PatternMatch::apint_match
 
struct  llvm::PatternMatch::apfloat_match
 
struct  llvm::PatternMatch::constantint_match< Val >
 
struct  llvm::PatternMatch::cst_pred_ty< Predicate >
 This helper class is used to match scalar and vector constants 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::is_power2
 
struct  llvm::PatternMatch::is_maxsignedvalue
 
struct  llvm::PatternMatch::bind_ty< Class >
 
struct  llvm::PatternMatch::specificval_ty
 Match a specified Value*. 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
 Match a specified integer value or vector of all elements of that. More...
 
struct  llvm::PatternMatch::AnyBinaryOp_match< LHS_t, RHS_t, Commutable >
 
struct  llvm::PatternMatch::BinaryOp_match< LHS_t, RHS_t, Opcode, Commutable >
 
struct  llvm::PatternMatch::OverflowingBinaryOp_match< LHS_t, RHS_t, Opcode, WrapFlags >
 
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::Exact_match< SubPattern_t >
 
struct  llvm::PatternMatch::CmpClass_match< LHS_t, RHS_t, Class, PredicateTy, Commutable >
 
struct  llvm::PatternMatch::SelectClass_match< Cond_t, LHS_t, RHS_t >
 
struct  llvm::PatternMatch::CastClass_match< Op_t, Opcode >
 
struct  llvm::PatternMatch::not_match< LHS_t >
 
struct  llvm::PatternMatch::neg_match< LHS_t >
 
struct  llvm::PatternMatch::fneg_match< LHS_t >
 
struct  llvm::PatternMatch::br_match
 
struct  llvm::PatternMatch::brc_match< Cond_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, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
 Intrinsic matches are combinations of ID matchers, and argument 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::Signum_match< Opnd_t >
 

Namespaces

 llvm
 Compute iterated dominance frontiers using a linear time algorithm.
 
 llvm::PatternMatch
 

Functions

template<typename Val , typename Pattern >
bool llvm::PatternMatch::match (Val *V, const Pattern &P)
 
template<typename T >
OneUse_match< Tllvm::PatternMatch::m_OneUse (const T &SubPattern)
 
class_match< Value > llvm::PatternMatch::m_Value ()
 Match an arbitrary value and ignore it. More...
 
class_match< BinaryOperator > llvm::PatternMatch::m_BinOp ()
 Match an arbitrary binary operation and ignore it. More...
 
class_match< CmpInst > llvm::PatternMatch::m_Cmp ()
 Matches any compare instruction and ignore it. More...
 
class_match< ConstantInt > llvm::PatternMatch::m_ConstantInt ()
 Match an arbitrary ConstantInt and ignore it. More...
 
class_match< UndefValue > llvm::PatternMatch::m_Undef ()
 Match an arbitrary undef constant. More...
 
class_match< Constant > llvm::PatternMatch::m_Constant ()
 Match an arbitrary Constant and ignore it. More...
 
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. More...
 
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. More...
 
match_zero llvm::PatternMatch::m_Zero ()
 Match an arbitrary zero/null constant. More...
 
match_neg_zero llvm::PatternMatch::m_NegZero ()
 Match an arbitrary zero/null constant. More...
 
match_any_zero llvm::PatternMatch::m_AnyZero ()
 
  • Match an arbitrary zero/null constant.
More...
 
match_nan llvm::PatternMatch::m_NaN ()
 Match an arbitrary NaN constant. This includes quiet and signalling nans. More...
 
match_one llvm::PatternMatch::m_One ()
 Match an integer 1 or a vector with all elements equal to 1. More...
 
match_all_ones llvm::PatternMatch::m_AllOnes ()
 Match an integer or vector with all bits set to true. More...
 
match_sign_mask llvm::PatternMatch::m_SignMask ()
 Match an integer or vector with only the sign bit(s) set. More...
 
apint_match llvm::PatternMatch::m_APInt (const APInt *&Res)
 Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt. More...
 
apfloat_match llvm::PatternMatch::m_APFloat (const APFloat *&Res)
 Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat. More...
 
cst_pred_ty< is_power2 > llvm::PatternMatch::m_Power2 ()
 Match an integer or vector power of 2. More...
 
api_pred_ty< is_power2 > llvm::PatternMatch::m_Power2 (const APInt *&V)
 
cst_pred_ty< is_maxsignedvalue > llvm::PatternMatch::m_MaxSignedValue ()
 
api_pred_ty< is_maxsignedvalue > llvm::PatternMatch::m_MaxSignedValue (const APInt *&V)
 
bind_ty< Value > llvm::PatternMatch::m_Value (Value *&V)
 Match a value, capturing it if we match. More...
 
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. More...
 
bind_ty< BinaryOperator > llvm::PatternMatch::m_BinOp (BinaryOperator *&I)
 Match a binary operator, capturing it if we match. More...
 
bind_ty< ConstantInt > llvm::PatternMatch::m_ConstantInt (ConstantInt *&CI)
 Match a ConstantInt, capturing the value if we match. More...
 
bind_ty< Constant > llvm::PatternMatch::m_Constant (Constant *&C)
 Match a Constant, capturing the value if we match. More...
 
bind_ty< ConstantFP > llvm::PatternMatch::m_ConstantFP (ConstantFP *&C)
 Match a ConstantFP, capturing the value if we match. More...
 
specificval_ty llvm::PatternMatch::m_Specific (const Value *V)
 Match if we have a specific specified value. More...
 
specific_fpval llvm::PatternMatch::m_SpecificFP (double V)
 Match a specific floating point value or vector with all elements equal to the value. More...
 
specific_fpval llvm::PatternMatch::m_FPOne ()
 Match a float 1.0 or vector with all elements equal to 1.0. More...
 
specific_intval llvm::PatternMatch::m_SpecificInt (uint64_t V)
 Match a specific integer value or vector with all elements equal to the value. More...
 
bind_const_intval_ty llvm::PatternMatch::m_ConstantInt (uint64_t &V)
 Match a ConstantInt and bind to its value. More...
 
template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS > llvm::PatternMatch::m_BinOp (const LHS &L, const RHS &R)
 
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 LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Mul > llvm::PatternMatch::m_Mul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FMul > llvm::PatternMatch::m_FMul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::UDiv > llvm::PatternMatch::m_UDiv (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::SDiv > llvm::PatternMatch::m_SDiv (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FDiv > llvm::PatternMatch::m_FDiv (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::URem > llvm::PatternMatch::m_URem (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::SRem > llvm::PatternMatch::m_SRem (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::FRem > llvm::PatternMatch::m_FRem (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::And > llvm::PatternMatch::m_And (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Or > llvm::PatternMatch::m_Or (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Xor > llvm::PatternMatch::m_Xor (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::Shl > llvm::PatternMatch::m_Shl (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::LShr > llvm::PatternMatch::m_LShr (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, Instruction::AShr > llvm::PatternMatch::m_AShr (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > llvm::PatternMatch::m_NSWAdd (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > llvm::PatternMatch::m_NSWSub (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > llvm::PatternMatch::m_NSWMul (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > llvm::PatternMatch::m_NSWShl (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > llvm::PatternMatch::m_NUWAdd (const LHS &L, const RHS &R)
 
template<typename LHS , typename RHS >
OverflowingBinaryOp_match< LHS, RHS, Instruction::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 >
BinOpPred_match< LHS, RHS, is_shift_op > llvm::PatternMatch::m_Shift (const LHS &L, const RHS &R)
 Matches shift operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_right_shift_op > llvm::PatternMatch::m_Shr (const LHS &L, const RHS &R)
 Matches logical shift operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_logical_shift_op > llvm::PatternMatch::m_LogicalShift (const LHS &L, const RHS &R)
 Matches logical shift operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > llvm::PatternMatch::m_BitwiseLogic (const LHS &L, const RHS &R)
 Matches bitwise logic operations. More...
 
template<typename LHS , typename RHS >
BinOpPred_match< LHS, RHS, is_idiv_op > llvm::PatternMatch::m_IDiv (const LHS &L, const RHS &R)
 Matches integer division operations. More...
 
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 >
SelectClass_match< Cond, LHS, RHS > llvm::PatternMatch::m_Select (const Cond &C, const LHS &L, const RHS &R)
 
template<int64_t L, int64_t R, typename Cond >
SelectClass_match< Cond, constantint_match< L >, constantint_match< R > > llvm::PatternMatch::m_SelectCst (const Cond &C)
 This matches a select of two constants, e.g. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::BitCast > llvm::PatternMatch::m_BitCast (const OpTy &Op)
 Matches BitCast. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::PtrToInt > llvm::PatternMatch::m_PtrToInt (const OpTy &Op)
 Matches PtrToInt. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::Trunc > llvm::PatternMatch::m_Trunc (const OpTy &Op)
 Matches Trunc. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::SExt > llvm::PatternMatch::m_SExt (const OpTy &Op)
 Matches SExt. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::ZExt > llvm::PatternMatch::m_ZExt (const OpTy &Op)
 Matches ZExt. More...
 
template<typename OpTy >
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > llvm::PatternMatch::m_ZExtOrSExt (const OpTy &Op)
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::UIToFP > llvm::PatternMatch::m_UIToFP (const OpTy &Op)
 Matches UIToFP. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::SIToFP > llvm::PatternMatch::m_SIToFP (const OpTy &Op)
 Matches SIToFP. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPTrunc > llvm::PatternMatch::m_FPTrunc (const OpTy &Op)
 Matches FPTrunc. More...
 
template<typename OpTy >
CastClass_match< OpTy, Instruction::FPExt > llvm::PatternMatch::m_FPExt (const OpTy &Op)
 Matches FPExt. More...
 
template<typename LHS >
not_match< LHS > llvm::PatternMatch::m_Not (const LHS &L)
 
template<typename LHS >
neg_match< LHS > llvm::PatternMatch::m_Neg (const LHS &L)
 Match an integer negate. More...
 
template<typename LHS >
fneg_match< LHS > llvm::PatternMatch::m_FNeg (const LHS &L)
 Match a floating point negate. More...
 
br_match llvm::PatternMatch::m_UnconditionalBr (BasicBlock *&Succ)
 
template<typename Cond_t >
brc_match< Cond_t > llvm::PatternMatch::m_Br (const Cond_t &C, BasicBlock *&T, BasicBlock *&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 >
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<unsigned OpI, typename Opnd_t >
Argument_match< Opnd_t > llvm::PatternMatch::m_Argument (const Opnd_t &Op)
 Match an argument. More...
 
template<Intrinsic::ID IntrID>
IntrinsicID_match llvm::PatternMatch::m_Intrinsic ()
 Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X)) More...
 
template<Intrinsic::ID IntrID, typename T0 >
m_Intrinsic_Ty< T0 >::Ty 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<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 , 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 Val_t >
Signum_match< Val_t > llvm::PatternMatch::m_Signum (const Val_t &V)
 Matches a signum pattern. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...