[llvm] r345146 - [FPEnv] Convert more BinaryOperator::isFNeg(...) to m_FNeg(...)
Cameron McInally via llvm-commits
llvm-commits at lists.llvm.org
Wed Oct 24 07:45:18 PDT 2018
Author: mcinally
Date: Wed Oct 24 07:45:18 2018
New Revision: 345146
URL: http://llvm.org/viewvc/llvm-project?rev=345146&view=rev
Log:
[FPEnv] Convert more BinaryOperator::isFNeg(...) to m_FNeg(...)
This work is to avoid regressions when we seperate FNeg from the FSub IR instruction.
Differential Revision: https://reviews.llvm.org/D53205
Modified:
llvm/trunk/include/llvm/IR/PatternMatch.h
llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp
llvm/trunk/test/Transforms/Reassociate/fp-expr.ll
Modified: llvm/trunk/include/llvm/IR/PatternMatch.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/PatternMatch.h?rev=345146&r1=345145&r2=345146&view=diff
==============================================================================
--- llvm/trunk/include/llvm/IR/PatternMatch.h (original)
+++ llvm/trunk/include/llvm/IR/PatternMatch.h Wed Oct 24 07:45:18 2018
@@ -659,11 +659,32 @@ inline BinaryOp_match<LHS, RHS, Instruct
return BinaryOp_match<LHS, RHS, Instruction::FSub>(L, R);
}
+template <typename Op_t> struct FNeg_match {
+ Op_t X;
+
+ FNeg_match(const Op_t &Op) : X(Op) {}
+ template <typename OpTy> bool match(OpTy *V) {
+ auto *FPMO = dyn_cast<FPMathOperator>(V);
+ if (!FPMO || FPMO->getOpcode() != Instruction::FSub)
+ return false;
+ if (FPMO->hasNoSignedZeros()) {
+ // With 'nsz', any zero goes.
+ if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
+ return false;
+ } else {
+ // Without 'nsz', we need fsub -0.0, X exactly.
+ if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
+ return false;
+ }
+ return X.match(FPMO->getOperand(1));
+ }
+};
+
/// Match 'fneg X' as 'fsub -0.0, X'.
-template <typename RHS>
-inline BinaryOp_match<cstfp_pred_ty<is_neg_zero_fp>, RHS, Instruction::FSub>
-m_FNeg(const RHS &X) {
- return m_FSub(m_NegZeroFP(), X);
+template <typename OpTy>
+inline FNeg_match<OpTy>
+m_FNeg(const OpTy &X) {
+ return FNeg_match<OpTy>(X);
}
/// Match 'fneg X' as 'fsub +-0.0, X'.
Modified: llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp?rev=345146&r1=345145&r2=345146&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/Reassociate.cpp Wed Oct 24 07:45:18 2018
@@ -208,7 +208,7 @@ unsigned ReassociatePass::getRank(Value
// 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 (!match(I, m_Not(m_Value())) && !match(I, m_Neg(m_Value())) &&
- !BinaryOperator::isFNeg(I))
+ !match(I, m_FNeg(m_Value())))
++Rank;
LLVM_DEBUG(dbgs() << "Calculated Rank[" << V->getName() << "] = " << Rank
@@ -575,7 +575,7 @@ static bool LinearizeExprTree(BinaryOper
// multiplies by -1 so they can be reassociated.
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op))
if ((Opcode == Instruction::Mul && match(BO, m_Neg(m_Value()))) ||
- (Opcode == Instruction::FMul && BinaryOperator::isFNeg(BO))) {
+ (Opcode == Instruction::FMul && match(BO, m_FNeg(m_Value())))) {
LLVM_DEBUG(dbgs()
<< "MORPH LEAF: " << *Op << " (" << Weight << ") TO ");
BO = LowerNegateToMultiply(BO);
@@ -855,7 +855,7 @@ static Value *NegateValue(Value *V, Inst
// Okay, we need to materialize a negated version of V with an instruction.
// Scan the use lists of V to see if we have one already.
for (User *U : V->users()) {
- if (!match(U, m_Neg(m_Value())) && !BinaryOperator::isFNeg(U))
+ if (!match(U, m_Neg(m_Value())) && !match(U, m_FNeg(m_Value())))
continue;
// We found one! Now we have to make sure that the definition dominates
@@ -900,7 +900,7 @@ static Value *NegateValue(Value *V, Inst
/// Return true if we should break up this subtract of X-Y into (X + -Y).
static bool ShouldBreakUpSubtract(Instruction *Sub) {
// If this is a negation, we can't split it up!
- if (match(Sub, m_Neg(m_Value())) || BinaryOperator::isFNeg(Sub))
+ if (match(Sub, m_Neg(m_Value())) || match(Sub, m_FNeg(m_Value())))
return false;
// Don't breakup X - undef.
@@ -1463,19 +1463,16 @@ Value *ReassociatePass::OptimizeAdd(Inst
// Check for X and -X or X and ~X in the operand list.
Value *X;
if (!match(TheOp, m_Neg(m_Value(X))) && !match(TheOp, m_Not(m_Value(X))) &&
- !BinaryOperator::isFNeg(TheOp))
+ !match(TheOp, m_FNeg(m_Value(X))))
continue;
- if (BinaryOperator::isFNeg(TheOp))
- X = BinaryOperator::getFNegArgument(TheOp);
-
unsigned FoundX = FindInOperandList(Ops, i, X);
if (FoundX == i)
continue;
// Remove X and -X from the operand list.
if (Ops.size() == 2 &&
- (match(TheOp, m_Neg(m_Value())) || BinaryOperator::isFNeg(TheOp)))
+ (match(TheOp, m_Neg(m_Value())) || match(TheOp, m_FNeg(m_Value()))))
return Constant::getNullValue(X->getType());
// Remove X and ~X from the operand list.
@@ -2081,7 +2078,7 @@ void ReassociatePass::OptimizeInst(Instr
RedoInsts.insert(I);
MadeChange = true;
I = NI;
- } else if (BinaryOperator::isFNeg(I)) {
+ } else if (match(I, m_FNeg(m_Value()))) {
// 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(I->getOperand(1), Instruction::FMul) &&
Modified: llvm/trunk/test/Transforms/Reassociate/fp-expr.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/Reassociate/fp-expr.ll?rev=345146&r1=345145&r2=345146&view=diff
==============================================================================
--- llvm/trunk/test/Transforms/Reassociate/fp-expr.ll (original)
+++ llvm/trunk/test/Transforms/Reassociate/fp-expr.ll Wed Oct 24 07:45:18 2018
@@ -4,8 +4,8 @@
define void @test1() {
; CHECK-LABEL: @test1(
; CHECK-NEXT: [[T1:%.*]] = tail call <4 x float> @blam()
-; CHECK-NEXT: [[T1_NEG:%.*]] = fsub fast <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[T1]]
-; CHECK-NEXT: [[T24:%.*]] = fadd fast <4 x float> [[T1_NEG]], undef
+; CHECK-NEXT: [[T23:%.*]] = fsub fast <4 x float> undef, [[T1]]
+; CHECK-NEXT: [[T24:%.*]] = fadd fast <4 x float> [[T23]], undef
; CHECK-NEXT: tail call void @wombat(<4 x float> [[T24]])
; CHECK-NEXT: ret void
;
More information about the llvm-commits
mailing list