retdec
Classes | Functions
retdec::bin2llvmir::st_match Namespace Reference

Classes

struct  match_combine_or
 
struct  match_combine_and
 
struct  AnyBinaryOp_match
 
struct  BinaryOp_match
 
struct  not_match
 
struct  neg_match
 
struct  CmpClass_match
 
struct  CmpClass_pred_match
 
struct  LoadClass_match
 
struct  bind_ty
 
struct  class_match
 
struct  apint_match
 
struct  apfloat_match
 
struct  constantint_match
 
struct  match_zero
 
struct  match_not_zero
 
struct  match_neg_zero
 
struct  match_any_zero
 
struct  match_one
 
struct  specificval_ty
 
struct  bind_const_intval_ty
 
struct  specific_intval
 Match a specified integer value. More...
 
struct  specific_fpval
 Match a specified floating point value. More...
 

Functions

template<typename Pattern >
bool match (SymbolicTree &st, const Pattern &p)
 
template<typename LTy , typename RTy >
match_combine_or< LTy, RTy > m_CombineOr (const LTy &L, const RTy &R)
 Combine two pattern matchers matching L || R. More...
 
template<typename LTy , typename RTy >
match_combine_and< LTy, RTy > m_CombineAnd (const LTy &L, const RTy &R)
 Combine two pattern matchers matching L && R. More...
 
template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS > m_BinOp (const LHS &L, const RHS &R, llvm::BinaryOperator **insn=nullptr)
 
template<typename LHS , typename RHS >
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp (const LHS &L, const RHS &R, llvm::BinaryOperator **insn=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Add > m_Add (const LHS &L, const RHS &R, llvm::BinaryOperator **add=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::FAdd > m_FAdd (const LHS &L, const RHS &R, llvm::BinaryOperator **fadd=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Sub > m_Sub (const LHS &L, const RHS &R, llvm::BinaryOperator **sub=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::FSub > m_FSub (const LHS &L, const RHS &R, llvm::BinaryOperator **fsub=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Mul > m_Mul (const LHS &L, const RHS &R, llvm::BinaryOperator **mul=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::FMul > m_FMul (const LHS &L, const RHS &R, llvm::BinaryOperator **fmul=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::UDiv > m_UDiv (const LHS &L, const RHS &R, llvm::BinaryOperator **udiv=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::SDiv > m_SDiv (const LHS &L, const RHS &R, llvm::BinaryOperator **sdiv=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::FDiv > m_FDiv (const LHS &L, const RHS &R, llvm::BinaryOperator **fdiv=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::URem > m_URem (const LHS &L, const RHS &R, llvm::BinaryOperator **urem=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::SRem > m_SRem (const LHS &L, const RHS &R, llvm::BinaryOperator **srem=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::FRem > m_FRem (const LHS &L, const RHS &R, llvm::BinaryOperator **frem=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::And > m_And (const LHS &L, const RHS &R, llvm::BinaryOperator **andi=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Or > m_Or (const LHS &L, const RHS &R, llvm::BinaryOperator **ori=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Xor > m_Xor (const LHS &L, const RHS &R, llvm::BinaryOperator **xori=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Shl > m_Shl (const LHS &L, const RHS &R, llvm::BinaryOperator **shl=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::LShr > m_LShr (const LHS &L, const RHS &R, llvm::BinaryOperator **lshr=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::AShr > m_AShr (const LHS &L, const RHS &R, llvm::BinaryOperator **ashr=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Add, true > m_c_Add (const LHS &L, const RHS &R, llvm::BinaryOperator **add=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Mul, true > m_c_Mul (const LHS &L, const RHS &R, llvm::BinaryOperator **mul=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::And, true > m_c_And (const LHS &L, const RHS &R, llvm::BinaryOperator **andi=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Or, true > m_c_Or (const LHS &L, const RHS &R, llvm::BinaryOperator **ori=nullptr)
 
template<typename LHS , typename RHS >
BinaryOp_match< LHS, RHS, llvm::Instruction::Xor, true > m_c_Xor (const LHS &L, const RHS &R, llvm::BinaryOperator **xori=nullptr)
 
template<typename LHS >
not_match< LHS > m_Not (const LHS &L)
 
template<typename LHS >
neg_match< LHS > m_Neg (const LHS &L)
 Match an integer negate. More...
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, llvm::CmpInst, llvm::CmpInst::Predicate > m_Cmp (llvm::CmpInst::Predicate &Pred, const LHS &L, const RHS &R, llvm::CmpInst **cmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate > m_ICmp (llvm::ICmpInst::Predicate &Pred, const LHS &L, const RHS &R, llvm::ICmpInst **icmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate, true > m_c_ICmp (llvm::ICmpInst::Predicate &Pred, const LHS &L, const RHS &R, llvm::ICmpInst **icmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_match< LHS, RHS, llvm::FCmpInst, llvm::FCmpInst::Predicate > m_FCmp (llvm::FCmpInst::Predicate &Pred, const LHS &L, const RHS &R, llvm::FCmpInst **fcmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_pred_match< LHS, RHS, llvm::CmpInst, llvm::CmpInst::Predicate > m_Cmp (llvm::CmpInst::Predicate Pred, const LHS &L, const RHS &R, llvm::CmpInst **cmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_pred_match< LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate > m_ICmp (llvm::ICmpInst::Predicate Pred, const LHS &L, const RHS &R, llvm::ICmpInst **icmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_pred_match< LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate, true > m_c_ICmp (llvm::ICmpInst::Predicate Pred, const LHS &L, const RHS &R, llvm::ICmpInst **icmp=nullptr)
 
template<typename LHS , typename RHS >
CmpClass_pred_match< LHS, RHS, llvm::FCmpInst, llvm::FCmpInst::Predicate > m_FCmp (llvm::FCmpInst::Predicate Pred, const LHS &L, const RHS &R, llvm::FCmpInst **fcmp=nullptr)
 
template<typename OpTy >
LoadClass_match< OpTy > m_Load (const OpTy &Op, llvm::LoadInst **l=nullptr)
 
bind_ty< llvm::Value > m_Value (llvm::Value *&V)
 
bind_ty< const llvm::Value > m_Value (const llvm::Value *&V)
 
bind_ty< llvm::BinaryOperator > m_BinOp (llvm::BinaryOperator *&I)
 
bind_ty< llvm::ConstantInt > m_ConstantInt (llvm::ConstantInt *&CI)
 
bind_ty< llvm::Constant > m_Constant (llvm::Constant *&C)
 
bind_ty< llvm::ConstantFP > m_ConstantFP (llvm::ConstantFP *&C)
 
bind_ty< llvm::GlobalVariable > m_GlobalVariable (llvm::GlobalVariable *&G)
 
bind_ty< llvm::Instruction > m_Instruction (llvm::Instruction *&I)
 
template<typename Class >
bind_ty< Classm_Instruction (Class *&I)
 
class_match< llvm::Value > m_Value ()
 
class_match< llvm::BinaryOperator > m_BinOp ()
 
class_match< llvm::CmpInst > m_Cmp ()
 
class_match< llvm::ConstantInt > m_ConstantInt ()
 Match a ConstantInt with a specific value. More...
 
class_match< llvm::UndefValue > m_Undef ()
 
class_match< llvm::Constant > m_Constant ()
 
class_match< llvm::Instruction > m_Instruction ()
 
apint_match m_APInt (const llvm::APInt *&Res)
 Match a ConstantInt, binding the specified pointer to the contained APInt. More...
 
apfloat_match m_APFloat (const llvm::APFloat *&Res)
 Match a ConstantFP, binding the specified pointer to the contained APFloat. More...
 
match_zero m_Zero ()
 Match an arbitrary zero/null constant. This includes zero_initializer for vectors and ConstantPointerNull for pointers. More...
 
match_not_zero m_not_Zero ()
 Match an arbitrary non-zero constant integer. More...
 
match_not_zero m_not_Zero (llvm::ConstantInt *&CI)
 Match and bind an arbitrary non-zero constant integer. More...
 
match_neg_zero m_NegZero ()
 Match an arbitrary zero/null constant. This includes zero_initializer for vectors and ConstantPointerNull for pointers. For floating point constants, this will match negative zero but not positive zero. More...
 
match_any_zero m_AnyZero ()
 
  • Match an arbitrary zero/null constant. This includes zero_initializer for vectors and ConstantPointerNull for pointers. For floating point constants, this will match negative zero and positive zero
More...
 
match_one m_One ()
 
specificval_ty m_Specific (const llvm::Value *V)
 Match if we have a specific specified value. More...
 
bind_const_intval_ty m_ConstantInt (uint64_t &V)
 Match a ConstantInt and bind to its value. This does not match ConstantInts wider than 64-bits. More...
 
specific_intval m_SpecificInt (uint64_t V)
 
specific_fpval m_SpecificFP (double V)
 
specific_fpval m_FPOne ()
 Match a float 1.0. More...
 

Function Documentation

◆ m_Add()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Add> retdec::bin2llvmir::st_match::m_Add ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  add = nullptr 
)
inline

◆ m_And()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::And> retdec::bin2llvmir::st_match::m_And ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  andi = nullptr 
)
inline

◆ m_AnyZero()

match_any_zero retdec::bin2llvmir::st_match::m_AnyZero ( )
inline

  • Match an arbitrary zero/null constant. This includes zero_initializer for vectors and ConstantPointerNull for pointers. For floating point constants, this will match negative zero and positive zero

◆ m_APFloat()

apfloat_match retdec::bin2llvmir::st_match::m_APFloat ( const llvm::APFloat *&  Res)
inline

Match a ConstantFP, binding the specified pointer to the contained APFloat.

◆ m_APInt()

apint_match retdec::bin2llvmir::st_match::m_APInt ( const llvm::APInt *&  Res)
inline

Match a ConstantInt, binding the specified pointer to the contained APInt.

◆ m_AShr()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::AShr> retdec::bin2llvmir::st_match::m_AShr ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  ashr = nullptr 
)
inline

◆ m_BinOp() [1/3]

class_match<llvm::BinaryOperator> retdec::bin2llvmir::st_match::m_BinOp ( )
inline

◆ m_BinOp() [2/3]

template<typename LHS , typename RHS >
AnyBinaryOp_match<LHS, RHS> retdec::bin2llvmir::st_match::m_BinOp ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  insn = nullptr 
)
inline

◆ m_BinOp() [3/3]

bind_ty<llvm::BinaryOperator> retdec::bin2llvmir::st_match::m_BinOp ( llvm::BinaryOperator *&  I)
inline

◆ m_c_Add()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Add, true> retdec::bin2llvmir::st_match::m_c_Add ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  add = nullptr 
)
inline

◆ m_c_And()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::And, true> retdec::bin2llvmir::st_match::m_c_And ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  andi = nullptr 
)
inline

◆ m_c_BinOp()

template<typename LHS , typename RHS >
AnyBinaryOp_match<LHS, RHS, true> retdec::bin2llvmir::st_match::m_c_BinOp ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  insn = nullptr 
)
inline

◆ m_c_ICmp() [1/2]

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate, true> retdec::bin2llvmir::st_match::m_c_ICmp ( llvm::ICmpInst::Predicate &  Pred,
const LHS &  L,
const RHS &  R,
llvm::ICmpInst **  icmp = nullptr 
)
inline

◆ m_c_ICmp() [2/2]

template<typename LHS , typename RHS >
CmpClass_pred_match<LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate, true> retdec::bin2llvmir::st_match::m_c_ICmp ( llvm::ICmpInst::Predicate  Pred,
const LHS &  L,
const RHS &  R,
llvm::ICmpInst **  icmp = nullptr 
)
inline

◆ m_c_Mul()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Mul, true> retdec::bin2llvmir::st_match::m_c_Mul ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  mul = nullptr 
)
inline

◆ m_c_Or()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Or, true> retdec::bin2llvmir::st_match::m_c_Or ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  ori = nullptr 
)
inline

◆ m_c_Xor()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Xor, true> retdec::bin2llvmir::st_match::m_c_Xor ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  xori = nullptr 
)
inline

◆ m_Cmp() [1/3]

class_match<llvm::CmpInst> retdec::bin2llvmir::st_match::m_Cmp ( )
inline

◆ m_Cmp() [2/3]

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, llvm::CmpInst, llvm::CmpInst::Predicate> retdec::bin2llvmir::st_match::m_Cmp ( llvm::CmpInst::Predicate &  Pred,
const LHS &  L,
const RHS &  R,
llvm::CmpInst **  cmp = nullptr 
)
inline

◆ m_Cmp() [3/3]

template<typename LHS , typename RHS >
CmpClass_pred_match<LHS, RHS, llvm::CmpInst, llvm::CmpInst::Predicate> retdec::bin2llvmir::st_match::m_Cmp ( llvm::CmpInst::Predicate  Pred,
const LHS &  L,
const RHS &  R,
llvm::CmpInst **  cmp = nullptr 
)
inline

◆ m_CombineAnd()

template<typename LTy , typename RTy >
match_combine_and<LTy, RTy> retdec::bin2llvmir::st_match::m_CombineAnd ( const LTy &  L,
const RTy &  R 
)
inline

Combine two pattern matchers matching L && R.

◆ m_CombineOr()

template<typename LTy , typename RTy >
match_combine_or<LTy, RTy> retdec::bin2llvmir::st_match::m_CombineOr ( const LTy &  L,
const RTy &  R 
)
inline

Combine two pattern matchers matching L || R.

◆ m_Constant() [1/2]

class_match<llvm::Constant> retdec::bin2llvmir::st_match::m_Constant ( )
inline

◆ m_Constant() [2/2]

bind_ty<llvm::Constant> retdec::bin2llvmir::st_match::m_Constant ( llvm::Constant *&  C)
inline

◆ m_ConstantFP()

bind_ty<llvm::ConstantFP> retdec::bin2llvmir::st_match::m_ConstantFP ( llvm::ConstantFP *&  C)
inline

◆ m_ConstantInt() [1/3]

class_match<llvm::ConstantInt> retdec::bin2llvmir::st_match::m_ConstantInt ( )
inline

Match a ConstantInt with a specific value.

◆ m_ConstantInt() [2/3]

bind_ty<llvm::ConstantInt> retdec::bin2llvmir::st_match::m_ConstantInt ( llvm::ConstantInt *&  CI)
inline

◆ m_ConstantInt() [3/3]

bind_const_intval_ty retdec::bin2llvmir::st_match::m_ConstantInt ( uint64_t &  V)
inline

Match a ConstantInt and bind to its value. This does not match ConstantInts wider than 64-bits.

◆ m_FAdd()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::FAdd> retdec::bin2llvmir::st_match::m_FAdd ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  fadd = nullptr 
)
inline

◆ m_FCmp() [1/2]

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, llvm::FCmpInst, llvm::FCmpInst::Predicate> retdec::bin2llvmir::st_match::m_FCmp ( llvm::FCmpInst::Predicate &  Pred,
const LHS &  L,
const RHS &  R,
llvm::FCmpInst **  fcmp = nullptr 
)
inline

◆ m_FCmp() [2/2]

template<typename LHS , typename RHS >
CmpClass_pred_match<LHS, RHS, llvm::FCmpInst, llvm::FCmpInst::Predicate> retdec::bin2llvmir::st_match::m_FCmp ( llvm::FCmpInst::Predicate  Pred,
const LHS &  L,
const RHS &  R,
llvm::FCmpInst **  fcmp = nullptr 
)
inline

◆ m_FDiv()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::FDiv> retdec::bin2llvmir::st_match::m_FDiv ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  fdiv = nullptr 
)
inline

◆ m_FMul()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::FMul> retdec::bin2llvmir::st_match::m_FMul ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  fmul = nullptr 
)
inline

◆ m_FPOne()

specific_fpval retdec::bin2llvmir::st_match::m_FPOne ( )
inline

Match a float 1.0.

◆ m_FRem()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::FRem> retdec::bin2llvmir::st_match::m_FRem ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  frem = nullptr 
)
inline

◆ m_FSub()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::FSub> retdec::bin2llvmir::st_match::m_FSub ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  fsub = nullptr 
)
inline

◆ m_GlobalVariable()

bind_ty<llvm::GlobalVariable> retdec::bin2llvmir::st_match::m_GlobalVariable ( llvm::GlobalVariable *&  G)
inline

◆ m_ICmp() [1/2]

template<typename LHS , typename RHS >
CmpClass_match<LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate> retdec::bin2llvmir::st_match::m_ICmp ( llvm::ICmpInst::Predicate &  Pred,
const LHS &  L,
const RHS &  R,
llvm::ICmpInst **  icmp = nullptr 
)
inline

◆ m_ICmp() [2/2]

template<typename LHS , typename RHS >
CmpClass_pred_match<LHS, RHS, llvm::ICmpInst, llvm::ICmpInst::Predicate> retdec::bin2llvmir::st_match::m_ICmp ( llvm::ICmpInst::Predicate  Pred,
const LHS &  L,
const RHS &  R,
llvm::ICmpInst **  icmp = nullptr 
)
inline

◆ m_Instruction() [1/3]

class_match<llvm::Instruction> retdec::bin2llvmir::st_match::m_Instruction ( )
inline

◆ m_Instruction() [2/3]

template<typename Class >
bind_ty<Class> retdec::bin2llvmir::st_match::m_Instruction ( Class *&  I)
inline

◆ m_Instruction() [3/3]

bind_ty<llvm::Instruction> retdec::bin2llvmir::st_match::m_Instruction ( llvm::Instruction *&  I)
inline

◆ m_Load()

template<typename OpTy >
LoadClass_match<OpTy> retdec::bin2llvmir::st_match::m_Load ( const OpTy &  Op,
llvm::LoadInst **  l = nullptr 
)
inline

◆ m_LShr()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::LShr> retdec::bin2llvmir::st_match::m_LShr ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  lshr = nullptr 
)
inline

◆ m_Mul()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Mul> retdec::bin2llvmir::st_match::m_Mul ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  mul = nullptr 
)
inline

◆ m_Neg()

template<typename LHS >
neg_match<LHS> retdec::bin2llvmir::st_match::m_Neg ( const LHS &  L)
inline

Match an integer negate.

◆ m_NegZero()

match_neg_zero retdec::bin2llvmir::st_match::m_NegZero ( )
inline

Match an arbitrary zero/null constant. This includes zero_initializer for vectors and ConstantPointerNull for pointers. For floating point constants, this will match negative zero but not positive zero.

◆ m_Not()

template<typename LHS >
not_match<LHS> retdec::bin2llvmir::st_match::m_Not ( const LHS &  L)
inline

◆ m_not_Zero() [1/2]

match_not_zero retdec::bin2llvmir::st_match::m_not_Zero ( )
inline

Match an arbitrary non-zero constant integer.

◆ m_not_Zero() [2/2]

match_not_zero retdec::bin2llvmir::st_match::m_not_Zero ( llvm::ConstantInt *&  CI)
inline

Match and bind an arbitrary non-zero constant integer.

◆ m_One()

match_one retdec::bin2llvmir::st_match::m_One ( )
inline

◆ m_Or()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Or> retdec::bin2llvmir::st_match::m_Or ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  ori = nullptr 
)
inline

◆ m_SDiv()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::SDiv> retdec::bin2llvmir::st_match::m_SDiv ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  sdiv = nullptr 
)
inline

◆ m_Shl()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Shl> retdec::bin2llvmir::st_match::m_Shl ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  shl = nullptr 
)
inline

◆ m_Specific()

specificval_ty retdec::bin2llvmir::st_match::m_Specific ( const llvm::Value *  V)
inline

Match if we have a specific specified value.

◆ m_SpecificFP()

specific_fpval retdec::bin2llvmir::st_match::m_SpecificFP ( double  V)
inline

◆ m_SpecificInt()

specific_intval retdec::bin2llvmir::st_match::m_SpecificInt ( uint64_t  V)
inline

◆ m_SRem()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::SRem> retdec::bin2llvmir::st_match::m_SRem ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  srem = nullptr 
)
inline

◆ m_Sub()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Sub> retdec::bin2llvmir::st_match::m_Sub ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  sub = nullptr 
)
inline

◆ m_UDiv()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::UDiv> retdec::bin2llvmir::st_match::m_UDiv ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  udiv = nullptr 
)
inline

◆ m_Undef()

class_match<llvm::UndefValue> retdec::bin2llvmir::st_match::m_Undef ( )
inline

◆ m_URem()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::URem> retdec::bin2llvmir::st_match::m_URem ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  urem = nullptr 
)
inline

◆ m_Value() [1/3]

class_match<llvm::Value> retdec::bin2llvmir::st_match::m_Value ( )
inline

◆ m_Value() [2/3]

bind_ty<const llvm::Value> retdec::bin2llvmir::st_match::m_Value ( const llvm::Value *&  V)
inline

◆ m_Value() [3/3]

bind_ty<llvm::Value> retdec::bin2llvmir::st_match::m_Value ( llvm::Value *&  V)
inline

◆ m_Xor()

template<typename LHS , typename RHS >
BinaryOp_match<LHS, RHS, llvm::Instruction::Xor> retdec::bin2llvmir::st_match::m_Xor ( const LHS &  L,
const RHS &  R,
llvm::BinaryOperator **  xori = nullptr 
)
inline

◆ m_Zero()

match_zero retdec::bin2llvmir::st_match::m_Zero ( )
inline

Match an arbitrary zero/null constant. This includes zero_initializer for vectors and ConstantPointerNull for pointers.

◆ match()

template<typename Pattern >
bool retdec::bin2llvmir::st_match::match ( SymbolicTree st,
const Pattern &  p 
)