[InstCombine] Update fptrunc (fneg x)) -> (fneg (fptrunc x) for unary FNeg

[cameron.mcinally]

Summary

Move the binary FNEG combine so that it also applies to unary FNeg.

[craig.topper]

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

1637

If you started with a unary fneg, shouldn't we end up with a unary fneg?

[cameron.mcinally]

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

1637

So this combine actually covers both unary and binary FNeg. m_FNeg(X) will match an FSub(-0.0,X). The end goal is that both will end up producing an unary FNeg.

But, yeah, I see what you're saying. I could dispatch on the operator type for now, but it would be code to clean up later. I suppose the BinaryOperator will have to be switched to an UnaryOperator in the future anyway, so I'm not sure how much work I'm saving.

Just thinking aloud, I don't have a preference...

[cameron.mcinally]

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

1637

Thinking about this some more, you’re correct. It’s not safe to turn a unary FNeg into a binary FNeg.

I was thinking about this as a short term solution, but we should play it safe in case this does not get updated.

I’ll update the patch...

[cameron.mcinally]

Fix the Unary/Binary operator issue.

Also note that this change will require UnaryOperator::CreateFNegFMF(...) from D62521, so cannot be committed until that is complete.

[cameron.mcinally]

Fix typo.

[cameron.mcinally]

Forgot to update the tests.

Will hold off on making any other corrections until D62521 has landed...

[cameron.mcinally]

Check hasOneUse() before performing combine.

[cameron.mcinally]

In D62629#1522985, @cameron.mcinally wrote:

Also note that this change will require UnaryOperator::CreateFNegFMF(...) from D62521, so cannot be committed until that is complete.

D62521 has landed, so this patch is ready for review...

[spatel]

In D62629#1536402, @cameron.mcinally wrote:

Check hasOneUse() before performing combine.

That's an independent fix and needs a test?

[cameron.mcinally]

In D62629#1536451, @spatel wrote:

In D62629#1536402, @cameron.mcinally wrote:

Check hasOneUse() before performing combine.

That's an independent fix and needs a test?

It's actually covered by the new @unary_neg_trunc_op1_extra_use and existing @neg_trunc_op1_extra_use tests. I missed that each was producing an extra instruction in my Diff before the hasOneUse() change. I had failed to copy over that check to the new code from the old BinaryOperator code above this.

Also, I just noticed I failed to add context to this patch. Will do so now...

[cameron.mcinally]

Add context to Diff.

[cameron.mcinally]

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

1535

This is the check that guarded the old BinaryOperator-only combine.

[spatel]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Instruction *InstCombiner::visitFPTrunc(FPTruncInst &FPT) {
   // simplify this expression to avoid one or more of the trunc/extend
   // operations if we can do so without changing the numerical results.
   //
   // The exact manner in which the widths of the operands interact to limit
   // what we can and cannot do safely varies from operation to operation, and
   // is explained below in the various case statements.
   Type *Ty = FPT.getType();
   BinaryOperator *OpI = dyn_cast<BinaryOperator>(FPT.getOperand(0));
   if (OpI && OpI->hasOneUse()) {
     Type *LHSMinType = getMinimumFPType(OpI->getOperand(0));
     Type *RHSMinType = getMinimumFPType(OpI->getOperand(1));
     unsigned OpWidth = OpI->getType()->getFPMantissaWidth();
     unsigned LHSWidth = LHSMinType->getFPMantissaWidth();
     unsigned RHSWidth = RHSMinType->getFPMantissaWidth();
     unsigned SrcWidth = std::max(LHSWidth, RHSWidth);
     unsigned DstWidth = Ty->getFPMantissaWidth();
     switch (OpI->getOpcode()) {
switch (OpI->getOpcode()) {
            LHS = Builder.CreateFPTrunc(OpI->getOperand(0), RHSMinType);
            RHS = Builder.CreateFPTrunc(OpI->getOperand(1), RHSMinType);
         }
 
         Value *ExactResult = Builder.CreateFRemFMF(LHS, RHS, OpI);
         return CastInst::CreateFPCast(ExactResult, Ty);
       }
     }
+  }
 
-    // (fptrunc (fneg x)) -> (fneg (fptrunc x))
-    Value *X;
-    if (match(OpI, m_FNeg(m_Value(X)))) {
+  Instruction *Op = dyn_cast<Instruction>(FPT.getOperand(0));
+  if (Op && Op->hasOneUse()) {
+    if (match(Op, m_FNeg(m_Value(X)))) {
       Value *InnerTrunc = Builder.CreateFPTrunc(X, Ty);
-      return BinaryOperator::CreateFNegFMF(InnerTrunc, OpI);
+
+      // FIXME: Once we're sure that unary FNeg optimizations are on par with
+      // binary FNeg, this should always return a unary operator.
+      if (isa<BinaryOperator>(Op))
+        return BinaryOperator::CreateFNegFMF(InnerTrunc, Op);
+      return UnaryOperator::CreateFNegFMF(InnerTrunc, Op);
     }
   }
 
   if (auto *II = dyn_cast<IntrinsicInst>(FPT.getOperand(0))) {
     switch (II->getIntrinsicID()) {
     default: break;
     case Intrinsic::ceil:
     case Intrinsic::fabs:
     case Intrinsic::floor:
     case Intrinsic::nearbyint:
     case Intrinsic::rint:
     case Intrinsic::round:
     case Intrinsic::trunc: {
       Value *Src = II->getArgOperand(0);

llvm/test/Transforms/InstCombine/fpcast.ll

 ; CHECK-NEXT:    [[C:%.*]] = fsub half 0xH8000, [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fsub float -0.0, %a
   %c = fptrunc float %b to half
   ret half %c
 }
 
-; FIXME: This combine isn't working.
 define half @unary_fneg_fptrunc(float %a) {
 ; CHECK-LABEL: @unary_fneg_fptrunc(
-; CHECK-NEXT:    [[B:%.*]] = fneg float [[A:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = fptrunc float [[B]] to half
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc float [[A:%.*]] to half
+; CHECK-NEXT:    [[C:%.*]] = fneg half [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fneg float %a
   %c = fptrunc float %b to half
   ret half %c
 }
 
 define <2 x half> @fneg_fptrunc_vec_undef(<2 x float> %a) {
 ; CHECK-LABEL: @fneg_fptrunc_vec_undef(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc <2 x float> [[A:%.*]] to <2 x half>
 ; CHECK-NEXT:    [[C:%.*]] = fsub <2 x half> <half 0xH8000, half 0xH8000>, [[TMP1]]
 ; CHECK-NEXT:    ret <2 x half> [[C]]
 ;
   %b = fsub <2 x float> <float -0.0, float undef>, %a
   %c = fptrunc <2 x float> %b to <2 x half>
   ret <2 x half> %c
 }
 
-; FIXME: This combine isn't working.
 define <2 x half> @unary_fneg_fptrunc_vec(<2 x float> %a) {
 ; CHECK-LABEL: @unary_fneg_fptrunc_vec(
-; CHECK-NEXT:    [[B:%.*]] = fneg <2 x float> [[A:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = fptrunc <2 x float> [[B]] to <2 x half>
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc <2 x float> [[A:%.*]] to <2 x half>
+; CHECK-NEXT:    [[C:%.*]] = fneg <2 x half> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x half> [[C]]
 ;
   %b = fneg <2 x float> %a
   %c = fptrunc <2 x float> %b to <2 x half>
   ret <2 x half> %c
 }
 
 define half @test4-fast(float %a) {
 ; CHECK-LABEL: @test4-fast(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc float [[A:%.*]] to half
 ; CHECK-NEXT:    [[C:%.*]] = fsub fast half 0xH8000, [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fsub fast float -0.0, %a
   %c = fptrunc float %b to half
   ret half %c
 }
 
-; FIXME: This combine isn't working.
 define half @test4_unary_fneg-fast(float %a) {
 ; CHECK-LABEL: @test4_unary_fneg-fast(
-; CHECK-NEXT:    [[B:%.*]] = fneg fast float [[A:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = fptrunc float [[B]] to half
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc float [[A:%.*]] to half
+; CHECK-NEXT:    [[C:%.*]] = fneg fast half [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fneg fast float %a
   %c = fptrunc float %b to half
   ret half %c
 }
 
 define half @test5(float %a, float %b, float %c) {

llvm/test/Transforms/InstCombine/fpextend.ll

 ;
 entry:
   %tmp1 = fpext float %x to double
   %tmp2 = fsub double -0.000000e+00, %tmp1
   %tmp34 = fptrunc double %tmp2 to float
   ret float %tmp34
 }
 
-; FIXME: This combine isn't working.
 define float @test4_unary_fneg(float %x) nounwind  {
 ; CHECK-LABEL: @test4_unary_fneg(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP1:%.*]] = fpext float [[X:%.*]] to double
-; CHECK-NEXT:    [[TMP2:%.*]] = fneg double [[TMP1]]
-; CHECK-NEXT:    [[TMP34:%.*]] = fptrunc double [[TMP2]] to float
+; CHECK-NEXT:    [[TMP34:%.*]] = fneg float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[TMP34]]
 ;
 entry:
   %tmp1 = fpext float %x to double
   %tmp2 = fneg double %tmp1
   %tmp34 = fptrunc double %tmp2 to float
   ret float %tmp34
 }

llvm/test/Transforms/InstCombine/fsub.ll

 ;
   %t1 = fsub double -0.0, %a
   %t2 = fptrunc double %t1 to float
   %t3 = fsub float %b, %t2
   call void @use(float %t2)
   ret float %t3
 }
 
-; FIXME: This combine isn't working.
 define float @unary_neg_trunc_op1_extra_use(double %a, float %b) {
 ; CHECK-LABEL: @unary_neg_trunc_op1_extra_use(
-; CHECK-NEXT:    [[T1:%.*]] = fneg double [[A:%.*]]
-; CHECK-NEXT:    [[T2:%.*]] = fptrunc double [[T1]] to float
-; CHECK-NEXT:    [[T3:%.*]] = fsub float [[B:%.*]], [[T2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc double [[A:%.*]] to float
+; CHECK-NEXT:    [[T2:%.*]] = fneg float [[TMP1]]
+; CHECK-NEXT:    [[T3:%.*]] = fadd float [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @use(float [[T2]])
 ; CHECK-NEXT:    ret float [[T3]]
 ;
   %t1 = fneg double %a
   %t2 = fptrunc double %t1 to float
   %t3 = fsub float %b, %t2
   call void @use(float %t2)
   ret float %t3