[llvm-commits] CVS: llvm/lib/Transforms/Scalar/InstructionCombining.cpp

[Chris Lattner]

Changes in directory llvm/lib/Transforms/Scalar:

InstructionCombining.cpp updated: 1.210 -> 1.211

---
Log message:

More minor cleanups


---
Diffs of the changes:  (+8 -11)

Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.210 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.211
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.210	Wed Jun  9 21:07:29 2004
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp	Wed Jun  9 21:12:35 2004
@@ -304,22 +304,17 @@
 
   // Constants can be considered to be negated values if they can be folded...
   if (Constant *C = dyn_cast<Constant>(V))
-    return ConstantExpr::getSub(Constant::getNullValue(V->getType()), C);
+    return ConstantExpr::getNeg(C);
   return 0;
 }
 
-static Constant *NotConstant(Constant *C) {
-  return ConstantExpr::getXor(C,
-                              ConstantIntegral::getAllOnesValue(C->getType()));
-}
-
 static inline Value *dyn_castNotVal(Value *V) {
   if (BinaryOperator::isNot(V))
     return BinaryOperator::getNotArgument(cast<BinaryOperator>(V));
 
   // Constants can be considered to be not'ed values...
   if (ConstantIntegral *C = dyn_cast<ConstantIntegral>(V))
-    return NotConstant(C);
+    return ConstantExpr::getNot(C);
   return 0;
 }
 
@@ -1212,7 +1207,8 @@
                                                      Op0Name);
           InsertNewInstBefore(Or, I);
           return BinaryOperator::createXor(Or,
-                                ConstantExpr::getAnd(Op0CI, NotConstant(RHS)));
+                                ConstantExpr::getAnd(Op0CI,
+                                                   ConstantExpr::getNot(RHS)));
         }
     }
 
@@ -1320,7 +1316,7 @@
         case Instruction::Or:
           // (X | C1) ^ C2 --> (X | C1) & ~C2 iff (C1&C2) == C2
           if (ConstantExpr::getAnd(RHS, Op0CI) == RHS)
-            return BinaryOperator::createAnd(Op0, NotConstant(RHS));
+            return BinaryOperator::createAnd(Op0, ConstantExpr::getNot(RHS));
           break;
         default: break;
         }
@@ -1571,7 +1567,7 @@
           // If bits are being or'd in that are not present in the constant we
           // are comparing against, then the comparison could never succeed!
           if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1))) {
-            Constant *NotCI = NotConstant(CI);
+            Constant *NotCI = ConstantExpr::getNot(CI);
             if (!ConstantExpr::getAnd(BOC, NotCI)->isNullValue())
               return ReplaceInstUsesWith(I, ConstantBool::get(isSetNE));
           }
@@ -1581,7 +1577,8 @@
           if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) {
             // If bits are being compared against that are and'd out, then the
             // comparison can never succeed!
-            if (!ConstantExpr::getAnd(CI, NotConstant(BOC))->isNullValue())
+            if (!ConstantExpr::getAnd(CI,
+                                      ConstantExpr::getNot(BOC))->isNullValue())
               return ReplaceInstUsesWith(I, ConstantBool::get(isSetNE));
 
             // If we have ((X & C) == C), turn it into ((X & C) != 0).