//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides a simple and efficient mechanism for performing general
// tree-based pattern matches on the LLVM IR. The power of these routines is
// that it allows you to write concise patterns that are expressive and easy to
-// understand. The other major advantage of this is that is allows to you
+// understand. The other major advantage of this is that it allows you to
// trivially capture/bind elements in the pattern to variables. For example,
// you can do something like this:
//
bool match(ITy *V) { return isa<Class>(V); }
};
+/// m_Value() - Match an arbitrary value and ignore it.
inline leaf_ty<Value> m_Value() { return leaf_ty<Value>(); }
+/// m_ConstantInt() - Match an arbitrary ConstantInt and ignore it.
inline leaf_ty<ConstantInt> m_ConstantInt() { return leaf_ty<ConstantInt>(); }
+struct zero_ty {
+ template<typename ITy>
+ bool match(ITy *V) {
+ if (const Constant *C = dyn_cast<Constant>(V))
+ return C->isNullValue();
+ return false;
+ }
+};
+
+/// m_Zero() - Match an arbitrary zero/null constant.
+inline zero_ty m_Zero() { return zero_ty(); }
+
+
template<typename Class>
struct bind_ty {
Class *&VR;
}
};
+/// m_Value - Match a value, capturing it if we match.
inline bind_ty<Value> m_Value(Value *&V) { return V; }
+
+/// m_ConstantInt - Match a ConstantInt, capturing the value if we match.
inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
//===----------------------------------------------------------------------===//
template<typename OpTy>
bool match(OpTy *V) {
- if (V->getValueType() == Value::InstructionVal + Opcode) {
+ if (V->getValueID() == Value::InstructionVal + Opcode) {
ConcreteTy *I = cast<ConcreteTy>(V);
return I->getOpcode() == Opcode && L.match(I->getOperand(0)) &&
R.match(I->getOperand(1));
}
template<typename LHS, typename RHS>
-inline BinaryOp_match<LHS, RHS, Instruction::Rem> m_Rem(const LHS &L,
+inline BinaryOp_match<LHS, RHS, Instruction::URem> m_URem(const LHS &L,
+ const RHS &R) {
+ return BinaryOp_match<LHS, RHS, Instruction::URem>(L, R);
+}
+
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::SRem> m_SRem(const LHS &L,
+ const RHS &R) {
+ return BinaryOp_match<LHS, RHS, Instruction::SRem>(L, R);
+}
+
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::FRem> m_FRem(const LHS &L,
const RHS &R) {
- return BinaryOp_match<LHS, RHS, Instruction::Rem>(L, R);
+ return BinaryOp_match<LHS, RHS, Instruction::FRem>(L, R);
}
template<typename LHS, typename RHS>
}
template<typename LHS, typename RHS>
-inline BinaryOp_match<LHS, RHS, Instruction::Shl,
- ShiftInst> m_Shl(const LHS &L, const RHS &R) {
- return BinaryOp_match<LHS, RHS, Instruction::Shl, ShiftInst>(L, R);
+inline BinaryOp_match<LHS, RHS, Instruction::Shl> m_Shl(const LHS &L,
+ const RHS &R) {
+ return BinaryOp_match<LHS, RHS, Instruction::Shl>(L, R);
+}
+
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::LShr> m_LShr(const LHS &L,
+ const RHS &R) {
+ return BinaryOp_match<LHS, RHS, Instruction::LShr>(L, R);
+}
+
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::AShr> m_AShr(const LHS &L,
+ const RHS &R) {
+ return BinaryOp_match<LHS, RHS, Instruction::AShr>(L, R);
}
+//===----------------------------------------------------------------------===//
+// Matchers for either AShr or LShr .. for convenience
+//
+template<typename LHS_t, typename RHS_t, typename ConcreteTy = BinaryOperator>
+struct Shr_match {
+ LHS_t L;
+ RHS_t R;
+
+ Shr_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
+
+ template<typename OpTy>
+ bool match(OpTy *V) {
+ if (V->getValueID() == Value::InstructionVal + Instruction::LShr ||
+ V->getValueID() == Value::InstructionVal + Instruction::AShr) {
+ ConcreteTy *I = cast<ConcreteTy>(V);
+ return (I->getOpcode() == Instruction::AShr ||
+ I->getOpcode() == Instruction::LShr) &&
+ L.match(I->getOperand(0)) &&
+ R.match(I->getOperand(1));
+ }
+ if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
+ return (CE->getOpcode() == Instruction::LShr ||
+ CE->getOpcode() == Instruction::AShr) &&
+ L.match(CE->getOperand(0)) &&
+ R.match(CE->getOperand(1));
+ return false;
+ }
+};
+
template<typename LHS, typename RHS>
-inline BinaryOp_match<LHS, RHS, Instruction::Shr,
- ShiftInst> m_Shr(const LHS &L, const RHS &R) {
- return BinaryOp_match<LHS, RHS, Instruction::Shr, ShiftInst>(L, R);
+inline Shr_match<LHS, RHS> m_Shr(const LHS &L, const RHS &R) {
+ return Shr_match<LHS, RHS>(L, R);
}
//===----------------------------------------------------------------------===//
template<typename LHS_t, typename RHS_t, typename Class, typename OpcType>
struct BinaryOpClass_match {
- OpcType &Opcode;
+ OpcType *Opcode;
LHS_t L;
RHS_t R;
BinaryOpClass_match(OpcType &Op, const LHS_t &LHS,
const RHS_t &RHS)
- : Opcode(Op), L(LHS), R(RHS) {}
+ : Opcode(&Op), L(LHS), R(RHS) {}
+ BinaryOpClass_match(const LHS_t &LHS, const RHS_t &RHS)
+ : Opcode(0), L(LHS), R(RHS) {}
template<typename OpTy>
bool match(OpTy *V) {
if (Class *I = dyn_cast<Class>(V))
if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
- Opcode = I->getOpcode();
+ if (Opcode)
+ *Opcode = I->getOpcode();
return true;
}
#if 0 // Doesn't handle constantexprs yet!
};
template<typename LHS, typename RHS>
-inline BinaryOpClass_match<LHS, RHS, SetCondInst, Instruction::BinaryOps>
-m_SetCond(Instruction::BinaryOps &Op, const LHS &L, const RHS &R) {
- return BinaryOpClass_match<LHS, RHS,
- SetCondInst, Instruction::BinaryOps>(Op, L, R);
-}
-
-template<typename LHS, typename RHS>
-inline BinaryOpClass_match<LHS, RHS, ShiftInst, Instruction::OtherOps>
-m_Shift(Instruction::OtherOps &Op, const LHS &L, const RHS &R) {
+inline BinaryOpClass_match<LHS, RHS, BinaryOperator, Instruction::BinaryOps>
+m_Shift(Instruction::BinaryOps &Op, const LHS &L, const RHS &R) {
return BinaryOpClass_match<LHS, RHS,
- ShiftInst, Instruction::OtherOps>(Op, L, R);
+ BinaryOperator, Instruction::BinaryOps>(Op, L, R);
}
template<typename LHS, typename RHS>
-inline BinaryOpClass_match<LHS, RHS, ShiftInst, Instruction::OtherOps>
+inline BinaryOpClass_match<LHS, RHS, BinaryOperator, Instruction::BinaryOps>
m_Shift(const LHS &L, const RHS &R) {
- Instruction::OtherOps Op;
return BinaryOpClass_match<LHS, RHS,
- ShiftInst, Instruction::OtherOps>(Op, L, R);
+ BinaryOperator, Instruction::BinaryOps>(L, R);
}
//===----------------------------------------------------------------------===//
-// Matchers for unary operators
+// Matchers for CmpInst classes
//
-template<typename LHS_t>
-struct neg_match {
+template<typename LHS_t, typename RHS_t, typename Class, typename PredicateTy>
+struct CmpClass_match {
+ PredicateTy &Predicate;
LHS_t L;
+ RHS_t R;
- neg_match(const LHS_t &LHS) : L(LHS) {}
+ CmpClass_match(PredicateTy &Pred, const LHS_t &LHS,
+ const RHS_t &RHS)
+ : Predicate(Pred), L(LHS), R(RHS) {}
template<typename OpTy>
bool match(OpTy *V) {
- if (Instruction *I = dyn_cast<Instruction>(V))
- if (I->getOpcode() == Instruction::Sub)
- return matchIfNeg(I->getOperand(0), I->getOperand(1));
- if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
- if (CE->getOpcode() == Instruction::Sub)
- return matchIfNeg(CE->getOperand(0), CE->getOperand(1));
- if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
- return L.match(ConstantExpr::getNeg(CI));
+ if (Class *I = dyn_cast<Class>(V))
+ if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
+ Predicate = I->getPredicate();
+ return true;
+ }
return false;
}
-private:
- bool matchIfNeg(Value *LHS, Value *RHS) {
- if (!LHS->getType()->isFloatingPoint())
- return LHS == Constant::getNullValue(LHS->getType()) && L.match(RHS);
- else
- return LHS == ConstantFP::get(LHS->getType(), -0.0) && L.match(RHS);
+};
+
+template<typename LHS, typename RHS>
+inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>
+m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
+ return CmpClass_match<LHS, RHS,
+ ICmpInst, ICmpInst::Predicate>(Pred, L, R);
+}
+
+template<typename LHS, typename RHS>
+inline CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>
+m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
+ return CmpClass_match<LHS, RHS,
+ FCmpInst, FCmpInst::Predicate>(Pred, L, R);
+}
+
+//===----------------------------------------------------------------------===//
+// Matchers for CastInst classes
+//
+
+template<typename Op_t, typename Class>
+struct CastClass_match {
+ Op_t Op;
+
+ CastClass_match(const Op_t &OpMatch) : Op(OpMatch) {}
+
+ template<typename OpTy>
+ bool match(OpTy *V) {
+ if (Class *I = dyn_cast<Class>(V))
+ return Op.match(I->getOperand(0));
+ return false;
}
};
-template<typename LHS>
-inline neg_match<LHS> m_Neg(const LHS &L) { return L; }
+template<typename Class, typename OpTy>
+inline CastClass_match<OpTy, Class> m_Cast(const OpTy &Op) {
+ return CastClass_match<OpTy, Class>(Op);
+}
+
+//===----------------------------------------------------------------------===//
+// Matchers for unary operators
+//
template<typename LHS_t>
struct not_match {
}
private:
bool matchIfNot(Value *LHS, Value *RHS) {
- if (ConstantIntegral *CI = dyn_cast<ConstantIntegral>(RHS))
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS))
return CI->isAllOnesValue() && L.match(LHS);
- else if (ConstantIntegral *CI = dyn_cast<ConstantIntegral>(LHS))
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(LHS))
return CI->isAllOnesValue() && L.match(RHS);
+ if (ConstantVector *CV = dyn_cast<ConstantVector>(RHS))
+ return CV->isAllOnesValue() && L.match(LHS);
+ if (ConstantVector *CV = dyn_cast<ConstantVector>(LHS))
+ return CV->isAllOnesValue() && L.match(RHS);
return false;
}
};
inline not_match<LHS> m_Not(const LHS &L) { return L; }
-template<typename Op_t>
-struct cast_match {
- Op_t Op;
- const Type **DestTy;
+template<typename LHS_t>
+struct neg_match {
+ LHS_t L;
- cast_match(const Op_t &op, const Type **destTy) : Op(op), DestTy(destTy) {}
+ neg_match(const LHS_t &LHS) : L(LHS) {}
template<typename OpTy>
bool match(OpTy *V) {
- if (CastInst *I = dyn_cast<CastInst>(V)) {
- if (DestTy) *DestTy = I->getType();
- return Op.match(I->getOperand(0));
- } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
- if (CE->getOpcode() == Instruction::Cast) {
- if (DestTy) *DestTy = I->getType();
- return Op.match(CE->getOperand(0));
- }
- }
+ if (Instruction *I = dyn_cast<Instruction>(V))
+ if (I->getOpcode() == Instruction::Sub)
+ return matchIfNeg(I->getOperand(0), I->getOperand(1));
+ if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
+ if (CE->getOpcode() == Instruction::Sub)
+ return matchIfNeg(CE->getOperand(0), CE->getOperand(1));
+ if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
+ return L.match(ConstantExpr::getNeg(CI));
return false;
}
+private:
+ bool matchIfNeg(Value *LHS, Value *RHS) {
+ return LHS == ConstantExpr::getZeroValueForNegationExpr(LHS->getType()) &&
+ L.match(RHS);
+ }
};
-template<typename Op_t>
-inline cast_match<Op_t> m_Cast(const Op_t &Op, const Type *&Ty) {
- return cast_match<Op_t>(Op, &Ty);
-}
-template<typename Op_t>
-inline cast_match<Op_t> m_Cast(const Op_t &Op) {
- return cast_match<Op_t>(Op, 0);
-}
+template<typename LHS>
+inline neg_match<LHS> m_Neg(const LHS &L) { return L; }
//===----------------------------------------------------------------------===//
projects / oota-llvm.git / blobdiff