Rename Value::getValueType to getValueID, to avoid confusion with

[oota-llvm.git] / include / llvm / Support / PatternMatch.h

diff --git a/include/llvm/Support/PatternMatch.h b/include/llvm/Support/PatternMatch.h
index 6db214292a1b38585ee36a694b116f720d46a50f..d8099a9affb00750061b9810fde0b0cdc71d5e4b 100644 (file)
--- a/include/llvm/Support/PatternMatch.h
+++ b/include/llvm/Support/PatternMatch.h
@@ -81,7 +81,7 @@ struct BinaryOp_match {
 
   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));
@@ -166,27 +166,27 @@ inline BinaryOp_match<LHS, RHS, Instruction::Xor> m_Xor(const LHS &L,
 }
 
 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, 
-                      ShiftInst> m_LShr(const LHS &L, const RHS &R) {
-  return BinaryOp_match<LHS, RHS, Instruction::LShr, ShiftInst>(L, R);
+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, 
-                      ShiftInst> m_AShr(const LHS &L, const RHS &R) {
-  return BinaryOp_match<LHS, RHS, Instruction::AShr, ShiftInst>(L, R);
+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 = ShiftInst>
+template<typename LHS_t, typename RHS_t, typename ConcreteTy = BinaryOperator>
 struct Shr_match {
   LHS_t L;
   RHS_t R;
@@ -195,8 +195,8 @@ struct Shr_match {
 
   template<typename OpTy>
   bool match(OpTy *V) {
-    if (V->getValueType() == Value::InstructionVal + Instruction::LShr ||
-        V->getValueType() == Value::InstructionVal + Instruction::AShr) {
+    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) &&
@@ -223,19 +223,22 @@ inline Shr_match<LHS, RHS> m_Shr(const LHS &L, const RHS &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!
@@ -248,18 +251,17 @@ struct BinaryOpClass_match {
 };
 
 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);
 }
 
 //===----------------------------------------------------------------------===//
@@ -305,37 +307,6 @@ m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
 // Matchers for unary operators
 //
 
-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))
-      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) {
-    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>
-inline neg_match<LHS> m_Neg(const LHS &L) { return L; }
-
-
 template<typename LHS_t>
 struct not_match {
   LHS_t L;
@@ -356,9 +327,9 @@ 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))
+    else if (ConstantInt *CI = dyn_cast<ConstantInt>(LHS))
       return CI->isAllOnesValue() && L.match(RHS);
     return false;
   }