X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FPatternMatch.h;h=fda925f5a9a8c2fe4b712df4618c0538a60a4423;hb=38b06447615440f935008a2141bd0a1fe078d437;hp=035dcf513f7ce76c1c5988ff1ea19ddc43d93920;hpb=630fcb86785f96501126e52009619b475403dc62;p=oota-llvm.git

diff --git a/include/llvm/Support/PatternMatch.h b/include/llvm/Support/PatternMatch.h
index 035dcf513f7..fda925f5a9a 100644
--- a/include/llvm/Support/PatternMatch.h
+++ b/include/llvm/Support/PatternMatch.h
@@ -51,20 +51,28 @@ 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>(); }
 
+template<int64_t Val>
 struct constantint_ty {
-  int64_t Val;
-  explicit constantint_ty(int64_t val) : Val(val) {}
-
   template<typename ITy>
   bool match(ITy *V) {
-    return isa<ConstantInt>(V) && cast<ConstantInt>(V)->getSExtValue() == Val;
+    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+      const APInt &CIV = CI->getValue();
+      if (Val >= 0)
+        return CIV == Val;
+      // If Val is negative, and CI is shorter than it, truncate to the right
+      // number of bits.  If it is larger, then we have to sign extend.  Just
+      // compare their negated values.
+      return -CIV == -Val;
+    }
+    return false;
   }
 };
 
 /// m_ConstantInt(int64_t) - Match a ConstantInt with a specific value
 /// and ignore it.
-inline constantint_ty m_ConstantInt(int64_t Val) {
-  return constantint_ty(Val);
+template<int64_t Val>
+inline constantint_ty<Val> m_ConstantInt() {
+  return constantint_ty<Val>();
 }
 
 struct zero_ty {
@@ -100,27 +108,27 @@ 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; }
-  
+
 /// specificval_ty - Match a specified Value*.
 struct specificval_ty {
   const Value *Val;
   specificval_ty(const Value *V) : Val(V) {}
-  
+
   template<typename ITy>
   bool match(ITy *V) {
     return V == Val;
   }
 };
-  
+
 /// m_Specific - Match if we have a specific specified value.
 inline specificval_ty m_Specific(const Value *V) { return V; }
-  
+
 
 //===----------------------------------------------------------------------===//
 // Matchers for specific binary operators.
 //
 
-template<typename LHS_t, typename RHS_t, 
+template<typename LHS_t, typename RHS_t,
          unsigned Opcode, typename ConcreteTy = BinaryOperator>
 struct BinaryOp_match {
   LHS_t L;
@@ -148,18 +156,36 @@ inline BinaryOp_match<LHS, RHS, Instruction::Add> m_Add(const LHS &L,
   return BinaryOp_match<LHS, RHS, Instruction::Add>(L, R);
 }
 
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::FAdd> m_FAdd(const LHS &L,
+                                                          const RHS &R) {
+  return BinaryOp_match<LHS, RHS, Instruction::FAdd>(L, R);
+}
+
 template<typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::Sub> m_Sub(const LHS &L,
                                                         const RHS &R) {
   return BinaryOp_match<LHS, RHS, Instruction::Sub>(L, R);
 }
 
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::FSub> m_FSub(const LHS &L,
+                                                          const RHS &R) {
+  return BinaryOp_match<LHS, RHS, Instruction::FSub>(L, R);
+}
+
 template<typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::Mul> m_Mul(const LHS &L,
                                                         const RHS &R) {
   return BinaryOp_match<LHS, RHS, Instruction::Mul>(L, R);
 }
 
+template<typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, Instruction::FMul> m_FMul(const LHS &L,
+                                                          const RHS &R) {
+  return BinaryOp_match<LHS, RHS, Instruction::FMul>(L, R);
+}
+
 template<typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::UDiv> m_UDiv(const LHS &L,
                                                         const RHS &R) {
@@ -215,19 +241,19 @@ inline BinaryOp_match<LHS, RHS, Instruction::Xor> m_Xor(const LHS &L,
 }
 
 template<typename LHS, typename RHS>
-inline BinaryOp_match<LHS, RHS, Instruction::Shl> m_Shl(const LHS &L, 
+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, 
+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, 
+inline BinaryOp_match<LHS, RHS, Instruction::AShr> m_AShr(const LHS &L,
                                                           const RHS &R) {
   return BinaryOp_match<LHS, RHS, Instruction::AShr>(L, R);
 }
@@ -302,14 +328,14 @@ struct BinaryOpClass_match {
 template<typename LHS, typename RHS>
 inline BinaryOpClass_match<LHS, RHS, BinaryOperator, Instruction::BinaryOps>
 m_Shift(Instruction::BinaryOps &Op, const LHS &L, const RHS &R) {
-  return BinaryOpClass_match<LHS, RHS, 
+  return BinaryOpClass_match<LHS, RHS,
                              BinaryOperator, Instruction::BinaryOps>(Op, L, R);
 }
 
 template<typename LHS, typename RHS>
 inline BinaryOpClass_match<LHS, RHS, BinaryOperator, Instruction::BinaryOps>
 m_Shift(const LHS &L, const RHS &R) {
-  return BinaryOpClass_match<LHS, RHS, 
+  return BinaryOpClass_match<LHS, RHS,
                              BinaryOperator, Instruction::BinaryOps>(L, R);
 }
 
@@ -384,12 +410,12 @@ m_Select(const Cond &C, const LHS &L, const RHS &R) {
 
 /// m_SelectCst - This matches a select of two constants, e.g.:
 ///    m_SelectCst(m_Value(V), -1, 0)
-template<typename Cond>
-inline SelectClass_match<Cond, constantint_ty, constantint_ty>
-m_SelectCst(const Cond &C, int64_t L, int64_t R) {
-  return SelectClass_match<Cond, constantint_ty, 
-                           constantint_ty>(C, m_ConstantInt(L),
-                                           m_ConstantInt(R));
+template<int64_t L, int64_t R, typename Cond>
+inline SelectClass_match<Cond, constantint_ty<L>, constantint_ty<R> >
+m_SelectCst(const Cond &C) {
+  return SelectClass_match<Cond, constantint_ty<L>,
+                           constantint_ty<R> >(C, m_ConstantInt<L>(),
+                                           m_ConstantInt<R>());
 }
 
 
@@ -400,9 +426,9 @@ m_SelectCst(const Cond &C, int64_t L, int64_t R) {
 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))
@@ -416,7 +442,7 @@ inline CastClass_match<OpTy, Class> m_Cast(const OpTy &Op) {
   return CastClass_match<OpTy, Class>(Op);
 }
 
-  
+
 //===----------------------------------------------------------------------===//
 // Matchers for unary operators
 //
@@ -460,9 +486,9 @@ inline not_match<LHS> m_Not(const LHS &L) { return L; }
 template<typename LHS_t>
 struct neg_match {
   LHS_t L;
-  
+
   neg_match(const LHS_t &LHS) : L(LHS) {}
-  
+
   template<typename OpTy>
   bool match(OpTy *V) {
     if (Instruction *I = dyn_cast<Instruction>(V))
@@ -486,6 +512,35 @@ template<typename LHS>
 inline neg_match<LHS> m_Neg(const LHS &L) { return L; }
 
 
+template<typename LHS_t>
+struct fneg_match {
+  LHS_t L;
+
+  fneg_match(const LHS_t &LHS) : L(LHS) {}
+
+  template<typename OpTy>
+  bool match(OpTy *V) {
+    if (Instruction *I = dyn_cast<Instruction>(V))
+      if (I->getOpcode() == Instruction::FSub)
+        return matchIfFNeg(I->getOperand(0), I->getOperand(1));
+    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
+      if (CE->getOpcode() == Instruction::FSub)
+        return matchIfFNeg(CE->getOperand(0), CE->getOperand(1));
+    if (ConstantFP *CF = dyn_cast<ConstantFP>(V))
+      return L.match(ConstantExpr::getFNeg(CF));
+    return false;
+  }
+private:
+  bool matchIfFNeg(Value *LHS, Value *RHS) {
+    return LHS == ConstantExpr::getZeroValueForNegationExpr(LHS->getType()) &&
+           L.match(RHS);
+  }
+};
+
+template<typename LHS>
+inline fneg_match<LHS> m_FNeg(const LHS &L) { return L; }
+
+
 //===----------------------------------------------------------------------===//
 // Matchers for control flow
 //