From a194b2d2ffdd4c8400324fb5e105edd1f7a8d698 Mon Sep 17 00:00:00 2001 From: Sanjay Patel Date: Wed, 8 Aug 2018 14:29:08 +0000 Subject: [PATCH] [InstCombine] fold fneg into constant operand of fmul/fdiv This accounts for the missing IR fold noted in D50195. We don't need any fast-math to enable the negation transform. FP negation can always be folded into an fmul/fdiv constant to eliminate the fneg. I've limited this to one-use to ensure that we are eliminating an instruction rather than replacing fneg by a potentially expensive fdiv or fmul. Differential Revision: https://reviews.llvm.org/D50417 llvm-svn: 339248 --- .../InstCombine/InstCombineAddSub.cpp | 17 ++++++++++-- llvm/test/Transforms/InstCombine/fneg.ll | 27 +++++++------------ llvm/test/Transforms/InstCombine/fsub.ll | 10 +++---- 3 files changed, 29 insertions(+), 25 deletions(-) diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp index 83054588a9aa..052cb4ab6752 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp @@ -1847,13 +1847,27 @@ Instruction *InstCombiner::visitFSub(BinaryOperator &I) { if (I.hasNoSignedZeros() && match(Op0, m_PosZeroFP())) return BinaryOperator::CreateFNegFMF(Op1, &I); + Value *X, *Y; + Constant *C; + + // Fold negation into constant operand. This is limited with one-use because + // fneg is assumed better for analysis and cheaper in codegen than fmul/fdiv. + // -(X * C) --> X * (-C) + if (match(&I, m_FNeg(m_OneUse(m_FMul(m_Value(X), m_Constant(C)))))) + return BinaryOperator::CreateFMulFMF(X, ConstantExpr::getFNeg(C), &I); + // -(X / C) --> X / (-C) + if (match(&I, m_FNeg(m_OneUse(m_FDiv(m_Value(X), m_Constant(C)))))) + return BinaryOperator::CreateFDivFMF(X, ConstantExpr::getFNeg(C), &I); + // -(C / X) --> (-C) / X + if (match(&I, m_FNeg(m_OneUse(m_FDiv(m_Constant(C), m_Value(X)))))) + return BinaryOperator::CreateFDivFMF(ConstantExpr::getFNeg(C), X, &I); + // If Op0 is not -0.0 or we can ignore -0.0: Z - (X - Y) --> Z + (Y - X) // Canonicalize to fadd to make analysis easier. // This can also help codegen because fadd is commutative. // Note that if this fsub was really an fneg, the fadd with -0.0 will get // killed later. We still limit that particular transform with 'hasOneUse' // because an fneg is assumed better/cheaper than a generic fsub. - Value *X, *Y; if (I.hasNoSignedZeros() || CannotBeNegativeZero(Op0, SQ.TLI)) { if (match(Op1, m_OneUse(m_FSub(m_Value(X), m_Value(Y))))) { Value *NewSub = Builder.CreateFSubFMF(Y, X, &I); @@ -1869,7 +1883,6 @@ Instruction *InstCombiner::visitFSub(BinaryOperator &I) { // X - C --> X + (-C) // But don't transform constant expressions because there's an inverse fold // for X + (-Y) --> X - Y. - Constant *C; if (match(Op1, m_Constant(C)) && !isa(Op1)) return BinaryOperator::CreateFAddFMF(Op0, ConstantExpr::getFNeg(C), &I); diff --git a/llvm/test/Transforms/InstCombine/fneg.ll b/llvm/test/Transforms/InstCombine/fneg.ll index 69ad35416419..df1d5f570db9 100644 --- a/llvm/test/Transforms/InstCombine/fneg.ll +++ b/llvm/test/Transforms/InstCombine/fneg.ll @@ -7,8 +7,7 @@ declare void @use(float) define float @fmul_fneg(float %x) { ; CHECK-LABEL: @fmul_fneg( -; CHECK-NEXT: [[M:%.*]] = fmul float [[X:%.*]], 4.200000e+01 -; CHECK-NEXT: [[R:%.*]] = fsub float -0.000000e+00, [[M]] +; CHECK-NEXT: [[R:%.*]] = fmul float [[X:%.*]], -4.200000e+01 ; CHECK-NEXT: ret float [[R]] ; %m = fmul float %x, 42.0 @@ -20,8 +19,7 @@ define float @fmul_fneg(float %x) { define float @fmul_fneg_fmf(float %x) { ; CHECK-LABEL: @fmul_fneg_fmf( -; CHECK-NEXT: [[M:%.*]] = fmul float [[X:%.*]], 4.200000e+01 -; CHECK-NEXT: [[R:%.*]] = fsub reassoc nsz float -0.000000e+00, [[M]] +; CHECK-NEXT: [[R:%.*]] = fmul reassoc nsz float [[X:%.*]], -4.200000e+01 ; CHECK-NEXT: ret float [[R]] ; %m = fmul float %x, 42.0 @@ -48,8 +46,7 @@ define float @fmul_fneg_extra_use(float %x) { define <4 x double> @fmul_fneg_vec(<4 x double> %x) { ; CHECK-LABEL: @fmul_fneg_vec( -; CHECK-NEXT: [[M:%.*]] = fmul <4 x double> [[X:%.*]], -; CHECK-NEXT: [[R:%.*]] = fsub <4 x double> , [[M]] +; CHECK-NEXT: [[R:%.*]] = fmul <4 x double> [[X:%.*]], ; CHECK-NEXT: ret <4 x double> [[R]] ; %m = fmul <4 x double> %x, @@ -61,8 +58,7 @@ define <4 x double> @fmul_fneg_vec(<4 x double> %x) { define float @fdiv_op1_constant_fneg(float %x) { ; CHECK-LABEL: @fdiv_op1_constant_fneg( -; CHECK-NEXT: [[D:%.*]] = fdiv float [[X:%.*]], -4.200000e+01 -; CHECK-NEXT: [[R:%.*]] = fsub float -0.000000e+00, [[D]] +; CHECK-NEXT: [[R:%.*]] = fdiv float [[X:%.*]], 4.200000e+01 ; CHECK-NEXT: ret float [[R]] ; %d = fdiv float %x, -42.0 @@ -74,8 +70,7 @@ define float @fdiv_op1_constant_fneg(float %x) { define float @fdiv_op1_constant_fneg_fmf(float %x) { ; CHECK-LABEL: @fdiv_op1_constant_fneg_fmf( -; CHECK-NEXT: [[D:%.*]] = fdiv float [[X:%.*]], -4.200000e+01 -; CHECK-NEXT: [[R:%.*]] = fsub nnan float -0.000000e+00, [[D]] +; CHECK-NEXT: [[R:%.*]] = fdiv nnan float [[X:%.*]], 4.200000e+01 ; CHECK-NEXT: ret float [[R]] ; %d = fdiv float %x, -42.0 @@ -102,8 +97,7 @@ define float @fdiv_op1_constant_fneg_extra_use(float %x) { define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) { ; CHECK-LABEL: @fdiv_op1_constant_fneg_vec( -; CHECK-NEXT: [[D:%.*]] = fdiv <4 x double> [[X:%.*]], -; CHECK-NEXT: [[R:%.*]] = fsub <4 x double> , [[D]] +; CHECK-NEXT: [[R:%.*]] = fdiv <4 x double> [[X:%.*]], ; CHECK-NEXT: ret <4 x double> [[R]] ; %d = fdiv <4 x double> %x, @@ -115,8 +109,7 @@ define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) { define float @fdiv_op0_constant_fneg(float %x) { ; CHECK-LABEL: @fdiv_op0_constant_fneg( -; CHECK-NEXT: [[D:%.*]] = fdiv float 4.200000e+01, [[X:%.*]] -; CHECK-NEXT: [[R:%.*]] = fsub float -0.000000e+00, [[D]] +; CHECK-NEXT: [[R:%.*]] = fdiv float -4.200000e+01, [[X:%.*]] ; CHECK-NEXT: ret float [[R]] ; %d = fdiv float 42.0, %x @@ -128,8 +121,7 @@ define float @fdiv_op0_constant_fneg(float %x) { define float @fdiv_op0_constant_fneg_fmf(float %x) { ; CHECK-LABEL: @fdiv_op0_constant_fneg_fmf( -; CHECK-NEXT: [[D:%.*]] = fdiv float 4.200000e+01, [[X:%.*]] -; CHECK-NEXT: [[R:%.*]] = fsub fast float -0.000000e+00, [[D]] +; CHECK-NEXT: [[R:%.*]] = fdiv fast float -4.200000e+01, [[X:%.*]] ; CHECK-NEXT: ret float [[R]] ; %d = fdiv float 42.0, %x @@ -156,8 +148,7 @@ define float @fdiv_op0_constant_fneg_extra_use(float %x) { define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) { ; CHECK-LABEL: @fdiv_op0_constant_fneg_vec( -; CHECK-NEXT: [[D:%.*]] = fdiv <4 x double> , [[X:%.*]] -; CHECK-NEXT: [[R:%.*]] = fsub <4 x double> , [[D]] +; CHECK-NEXT: [[R:%.*]] = fdiv <4 x double> , [[X:%.*]] ; CHECK-NEXT: ret <4 x double> [[R]] ; %d = fdiv <4 x double> , %x diff --git a/llvm/test/Transforms/InstCombine/fsub.ll b/llvm/test/Transforms/InstCombine/fsub.ll index b4567500df0a..4868ece222d3 100644 --- a/llvm/test/Transforms/InstCombine/fsub.ll +++ b/llvm/test/Transforms/InstCombine/fsub.ll @@ -60,15 +60,15 @@ define float @sub_sub_nsz(float %x, float %y, float %z) { ret float %t2 } -; With nsz and reassoc: Y - (X + Y) --> -X +; With nsz and reassoc: Y - ((X * 5) + Y) --> X * -5 + define float @sub_add_neg_x(float %x, float %y) { ; CHECK-LABEL: @sub_add_neg_x( -; CHECK-NEXT: [[TMP1:%.*]] = fmul float [[X:%.*]], 5.000000e+00 -; CHECK-NEXT: [[T2:%.*]] = fsub reassoc nsz float -0.000000e+00, [[TMP1]] -; CHECK-NEXT: ret float [[T2]] +; CHECK-NEXT: [[TMP1:%.*]] = fmul reassoc nsz float [[X:%.*]], -5.000000e+00 +; CHECK-NEXT: ret float [[TMP1]] ; %mul = fmul float %x, 5.000000e+00 - %add = fadd float %mul, %y + %add = fadd float %mul, %y %r = fsub nsz reassoc float %y, %add ret float %r } -- 2.34.1