Added more helper functions for binary instructions emulating

unary Neg and Not: isNeg, isNot, getNegArgument, and getNotArgument.

llvm-svn: 3341

llvm/include/llvm/InstrTypes.h

@@ -77,12 +77,28 @@ public:
   static BinaryOperator *create(BinaryOps Op, Value *S1, Value *S2,
 				const std::string &Name = "");
 
-  // createNeg, createNot - Helper constructors that create the "neg" and "not"
-  // instructions out of "sub" and "xor" instructions.
+  // Helper functions to construct and inspect unary operations (NEG and NOT)
+  // via binary operators SUB and XOR:
+  // 
+  // createNeg, createNot - Create the NEG and NOT
+  //     instructions out of SUB and XOR instructions.
   //
+  // isNeg, isNot - Check if the given Value is a NEG or NOT instruction.
+  //
+  // getNegArgument, getNotArgument - Helper functions to extract the
+  //     unary argument of a NEG or NOT operation implemented via Sub or Xor.
+  // 
   static BinaryOperator *createNeg(Value *Op, const std::string &Name = "");
   static BinaryOperator *createNot(Value *Op, const std::string &Name = "");
 
+  static bool            isNeg(const Value *V);
+  static bool            isNot(const Value *V);
+
+  static const Value*    getNegArgument(const BinaryOperator* Bop);
+  static       Value*    getNegArgument(      BinaryOperator* Bop);
+  static const Value*    getNotArgument(const BinaryOperator* Bop);
+  static       Value*    getNotArgument(      BinaryOperator* Bop);
+
   BinaryOps getOpcode() const { 
     return (BinaryOps)Instruction::getOpcode();
   }

llvm/lib/VMCore/iOperators.cpp

@@ -37,6 +37,71 @@ BinaryOperator *BinaryOperator::createNot(Value *Op, const std::string &Name) {
 }
 
 
+// isConstantZero - Helper function for several functions below
+inline bool isConstantZero(const Value* V) {
+  return isa<Constant>(V) && dyn_cast<Constant>(V)->isNullValue();
+}
+
+// isConstantAllOnes - Helper function for several functions below
+inline bool isConstantAllOnes(const Value* V) {
+  return (isa<ConstantIntegral>(V) &&
+          dyn_cast<ConstantIntegral>(V)->isAllOnesValue());
+}
+
+bool BinaryOperator::isNeg(const Value *V) {
+  if (const BinaryOperator* Bop = dyn_cast<BinaryOperator>(V))
+    return (Bop->getOpcode() == Instruction::Sub &&
+            isConstantZero(Bop->getOperand(0)));
+  return false;
+}
+
+bool BinaryOperator::isNot(const Value *V) {
+  if (const BinaryOperator* Bop = dyn_cast<BinaryOperator>(V))
+    return (Bop->getOpcode() == Instruction::Xor &&
+            (isConstantAllOnes(Bop->getOperand(1)) ||
+             isConstantAllOnes(Bop->getOperand(0))));
+  return false;
+}
+
+// getNegArg -- Helper function for getNegArgument operations.
+// Note: This function requires that Bop is a Neg operation.
+// 
+inline Value* getNegArg(BinaryOperator* Bop) {
+  assert(BinaryOperator::isNeg(Bop));
+  return Bop->getOperand(1);
+}
+
+// getNotArg -- Helper function for getNotArgument operations.
+// Note: This function requires that Bop is a Not operation.
+// 
+inline Value* getNotArg(BinaryOperator* Bop) {
+  assert(Bop->getOpcode() == Instruction::Xor);
+  Value* notArg   = Bop->getOperand(0);
+  Value* constArg = Bop->getOperand(1);
+  if (! isConstantAllOnes(constArg)) {
+    assert(isConstantAllOnes(notArg));
+    notArg = constArg;
+  }
+  return notArg;
+}
+
+const Value* BinaryOperator::getNegArgument(const BinaryOperator* Bop) {
+  return getNegArg((BinaryOperator*) Bop);
+}
+
+Value* BinaryOperator::getNegArgument(BinaryOperator* Bop) {
+  return getNegArg(Bop);
+}
+
+const Value* BinaryOperator::getNotArgument(const BinaryOperator* Bop) {
+  return getNotArg((BinaryOperator*) Bop);
+}
+
+Value* BinaryOperator::getNotArgument(BinaryOperator* Bop) {
+  return getNotArg(Bop);
+}
+
+
 // swapOperands - Exchange the two operands to this instruction.  This
 // instruction is safe to use on any binary instruction and does not
 // modify the semantics of the instruction.  If the instruction is