diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h index bccd417f079..3dc5881bdf4 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -64,6 +64,10 @@ public: /// getNullValue. virtual bool isNullValue() const = 0; + /// isNegativeZeroValue - Return true if the value is what would be returned + /// by getZeroValueForNegation. + virtual bool isNegativeZeroValue() const { return isNullValue(); } + /// canTrap - Return true if evaluation of this constant could trap. This is /// true for things like constant expressions that could divide by zero. bool canTrap() const; diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index b727de31ae6..143f3ad7578 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -270,6 +270,12 @@ public: /// getNullValue. Don't depend on == for doubles to tell us it's zero, it /// considers -0.0 to be null as well as 0.0. :( virtual bool isNullValue() const; + + /// isNegativeZeroValue - Return true if the value is what would be returned + /// by getZeroValueForNegation. + virtual bool isNegativeZeroValue() const { + return Val.isZero() && Val.isNegative(); + } /// isExactlyValue - We don't rely on operator== working on double values, as /// it returns true for things that are clearly not equal, like -0.0 and 0.0. diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h index eb0b7b6e5b6..1ee2a4b3318 100644 --- a/include/llvm/InstrTypes.h +++ b/include/llvm/InstrTypes.h @@ -224,8 +224,8 @@ public: /// isNeg, isFNeg, isNot - Check if the given Value is a /// NEG, FNeg, or NOT instruction. /// - static bool isNeg(LLVMContext &Context, const Value *V); - static bool isFNeg(LLVMContext &Context, const Value *V); + static bool isNeg(const Value *V); + static bool isFNeg(const Value *V); static bool isNot(const Value *V); /// getNegArgument, getNotArgument - Helper functions to extract the diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index a403f2e9f1c..ac453581dfd 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -2621,11 +2621,11 @@ void CWriter::visitBinaryOperator(Instruction &I) { // If this is a negation operation, print it out as such. For FP, we don't // want to print "-0.0 - X". - if (BinaryOperator::isNeg(*Context, &I)) { + if (BinaryOperator::isNeg(&I)) { Out << "-("; writeOperand(BinaryOperator::getNegArgument(cast(&I))); Out << ")"; - } else if (BinaryOperator::isFNeg(*Context, &I)) { + } else if (BinaryOperator::isFNeg(&I)) { Out << "-("; writeOperand(BinaryOperator::getFNegArgument(cast(&I))); Out << ")"; diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 3254a7caa4e..5b9659e2004 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -410,8 +410,8 @@ X("instcombine", "Combine redundant instructions"); // 0 -> undef, 1 -> Const, 2 -> Other, 3 -> Arg, 3 -> Unary, 4 -> OtherInst static unsigned getComplexity(LLVMContext *Context, Value *V) { if (isa(V)) { - if (BinaryOperator::isNeg(*Context, V) || - BinaryOperator::isFNeg(*Context, V) || + if (BinaryOperator::isNeg(V) || + BinaryOperator::isFNeg(V) || BinaryOperator::isNot(V)) return 3; return 4; @@ -573,7 +573,7 @@ bool InstCombiner::SimplifyCompare(CmpInst &I) { // if the LHS is a constant zero (which is the 'negate' form). // static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) { - if (BinaryOperator::isNeg(*Context, V)) + if (BinaryOperator::isNeg(V)) return BinaryOperator::getNegArgument(V); // Constants can be considered to be negated values if they can be folded. @@ -592,7 +592,7 @@ static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) { // form). // static inline Value *dyn_castFNegVal(Value *V, LLVMContext *Context) { - if (BinaryOperator::isFNeg(*Context, V)) + if (BinaryOperator::isFNeg(V)) return BinaryOperator::getFNegArgument(V); // Constants can be considered to be negated values if they can be folded. diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 6465fc1b96e..2877852d3dd 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -178,7 +178,7 @@ unsigned Reassociate::getRank(Value *V) { // If this is a not or neg instruction, do not count it for rank. This // assures us that X and ~X will have the same rank. if (!I->getType()->isInteger() || - (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(*Context, I))) + (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I))) ++Rank; //DOUT << "Calculated Rank[" << V->getName() << "] = " @@ -264,12 +264,12 @@ void Reassociate::LinearizeExprTree(BinaryOperator *I, // If this is a multiply expression tree and it contains internal negations, // transform them into multiplies by -1 so they can be reassociated. if (I->getOpcode() == Instruction::Mul) { - if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(*Context, LHS)) { + if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(LHS)) { LHS = LowerNegateToMultiply(cast(LHS), ValueRankMap, Context); LHSBO = isReassociableOp(LHS, Opcode); } - if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(*Context, RHS)) { + if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(RHS)) { RHS = LowerNegateToMultiply(cast(RHS), ValueRankMap, Context); RHSBO = isReassociableOp(RHS, Opcode); @@ -409,7 +409,7 @@ static Value *NegateValue(LLVMContext *Context, Value *V, Instruction *BI) { /// X-Y into (X + -Y). static bool ShouldBreakUpSubtract(LLVMContext *Context, Instruction *Sub) { // If this is a negation, we can't split it up! - if (BinaryOperator::isNeg(*Context, Sub)) + if (BinaryOperator::isNeg(Sub)) return false; // Don't bother to break this up unless either the LHS is an associable add or @@ -663,7 +663,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I, for (unsigned i = 0, e = Ops.size(); i != e; ++i) { assert(i < Ops.size()); // Check for X and -X in the operand list. - if (BinaryOperator::isNeg(*Context, Ops[i].Op)) { + if (BinaryOperator::isNeg(Ops[i].Op)) { Value *X = BinaryOperator::getNegArgument(Ops[i].Op); unsigned FoundX = FindInOperandList(Ops, i, X); if (FoundX != i) { @@ -801,7 +801,7 @@ void Reassociate::ReassociateBB(BasicBlock *BB) { if (ShouldBreakUpSubtract(Context, BI)) { BI = BreakUpSubtract(Context, BI, ValueRankMap); MadeChange = true; - } else if (BinaryOperator::isNeg(*Context, BI)) { + } else if (BinaryOperator::isNeg(BI)) { // Otherwise, this is a negation. See if the operand is a multiply tree // and if this is not an inner node of a multiply tree. if (isReassociableOp(BI->getOperand(1), Instruction::Mul) && diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 7c98d213aed..9a49bfc1540 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -1711,19 +1711,19 @@ static inline bool isConstantAllOnes(const Value *V) { return false; } -bool BinaryOperator::isNeg(LLVMContext &Context, const Value *V) { +bool BinaryOperator::isNeg(const Value *V) { if (const BinaryOperator *Bop = dyn_cast(V)) if (Bop->getOpcode() == Instruction::Sub) - return Bop->getOperand(0) == - Context.getZeroValueForNegation(Bop->getType()); + if (Constant* C = dyn_cast(Bop->getOperand(0))) + return C->isNegativeZeroValue(); return false; } -bool BinaryOperator::isFNeg(LLVMContext &Context, const Value *V) { +bool BinaryOperator::isFNeg(const Value *V) { if (const BinaryOperator *Bop = dyn_cast(V)) if (Bop->getOpcode() == Instruction::FSub) - return Bop->getOperand(0) == - Context.getZeroValueForNegation(Bop->getType()); + if (Constant* C = dyn_cast(Bop->getOperand(0))) + return C->isNegativeZeroValue(); return false; }