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();
}
}
+// 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