Teach InstSimplify transform -X + X --> 0.0 about unary FNeg

[andrew.w.kaylor]

lgtm

[kpn]

Is this an allowed transform?

If we transform "y = -x + x;" into "y = 0;" then won't that eliminate a trap? Is that allowed?

[spatel]

In D61916#1502826, @kpn wrote:

Is this an allowed transform?

If we transform "y = -x + x;" into "y = 0;" then won't that eliminate a trap? Is that allowed?

We're not dealing with constrained ops in this transform, so assume no traps/exceptions.

[kpn]

If I recall, fneg is not a constrained intrinsic because an fneg will never itself trap.

But a transform of -inf+inf to zero would be invalid by the standard, would it not? Section 7.2 paragraph d? Do we have a way of noting strict conformance to IEEE is required/desired without constrained intrinsics?

[cameron.mcinally]

In D61916#1503222, @kpn wrote:

If I recall, fneg is not a constrained intrinsic because an fneg will never itself trap.

That's right.

But a transform of -inf+inf to zero would be invalid by the standard, would it not? Section 7.2 paragraph d? Do we have a way of noting strict conformance to IEEE is required/desired without constrained intrinsics?

So this xform only happens under nnan. IEEE-754 specifies that FAdd(+inf,-inf) --> QNaN. I'm not certain about what LLVM does under nnan in all cases, but we've definitely already diverged from IEEE-754 if there are no NaNs.

[spatel]

In D61916#1503222, @kpn wrote:

If I recall, fneg is not a constrained intrinsic because an fneg will never itself trap.

But a transform of -inf+inf to zero would be invalid by the standard, would it not? Section 7.2 paragraph d? Do we have a way of noting strict conformance to IEEE is required/desired without constrained intrinsics?

Correct on -inf+inf, and (assuming no logic bugs) we do have basic IEEE conformance w/o constrained intrinsics. We've ruled the inf case out by using fast-math-flags (nnan) on the fadd. See code comment :

// With nnan: -X + X --> 0.0 (and commuted variant)
// We don't have to explicitly exclude infinities (ninf): INF + -INF == NaN.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

static Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
   if (match(Op1, m_NegZeroFP()))
     return Op0;
 
   // fadd X, 0 ==> X, when we know X is not -0
   if (match(Op1, m_PosZeroFP()) &&
       (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
     return Op0;
 
-  // With nnan: (+/-0.0 - X) + X --> 0.0 (and commuted variant)
+  // With nnan: -X + X --> 0.0 (and commuted variant)
   // We don't have to explicitly exclude infinities (ninf): INF + -INF == NaN.
   // Negative zeros are allowed because we always end up with positive zero:
   // X = -0.0: (-0.0 - (-0.0)) + (-0.0) == ( 0.0) + (-0.0) == 0.0
   // X = -0.0: ( 0.0 - (-0.0)) + (-0.0) == ( 0.0) + (-0.0) == 0.0
   // X =  0.0: (-0.0 - ( 0.0)) + ( 0.0) == (-0.0) + ( 0.0) == 0.0
   // X =  0.0: ( 0.0 - ( 0.0)) + ( 0.0) == ( 0.0) + ( 0.0) == 0.0
-  if (FMF.noNaNs() && (match(Op0, m_FSub(m_AnyZeroFP(), m_Specific(Op1))) ||
-                       match(Op1, m_FSub(m_AnyZeroFP(), m_Specific(Op0)))))
+  if (FMF.noNaNs()) {
+    if (match(Op0, m_FSub(m_AnyZeroFP(), m_Specific(Op1))) ||
+        match(Op1, m_FSub(m_AnyZeroFP(), m_Specific(Op0))))
+      return ConstantFP::getNullValue(Op0->getType());
+
+    if (match(Op0, m_FNeg(m_Specific(Op1))) ||
+        match(Op1, m_FNeg(m_Specific(Op0))))
       return ConstantFP::getNullValue(Op0->getType());
+  }
 
   // (X - Y) + Y --> X
   // Y + (X - Y) --> X
   Value *X;
   if (FMF.noSignedZeros() && FMF.allowReassoc() &&
       (match(Op0, m_FSub(m_Value(X), m_Specific(Op1))) ||
        match(Op1, m_FSub(m_Value(X), m_Specific(Op0)))))
     return X;

llvm/trunk/test/Transforms/InstSimplify/fast-math.ll

 ; CHECK-NEXT:    ret float [[B]]
 ;
   %b = fmul float %a, 0.0
   ret float %b
 }
 
 ; -X + X --> 0.0 (with nnan on the fadd)
 
-define float @fadd_fnegx(float %x) {
-; CHECK-LABEL: @fadd_fnegx(
+define float @fadd_binary_fnegx(float %x) {
+; CHECK-LABEL: @fadd_binary_fnegx(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
   %negx = fsub float -0.0, %x
   %r = fadd nnan float %negx, %x
   ret float %r
 }
 
+define float @fadd_unary_fnegx(float %x) {
+; CHECK-LABEL: @fadd_unary_fnegx(
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %negx = fneg float %x
+  %r = fadd nnan float %negx, %x
+  ret float %r
+}
+
 ; X + -X --> 0.0 (with nnan on the fadd)
 
-define <2 x float> @fadd_fnegx_commute_vec(<2 x float> %x) {
-; CHECK-LABEL: @fadd_fnegx_commute_vec(
+define <2 x float> @fadd_binary_fnegx_commute_vec(<2 x float> %x) {
+; CHECK-LABEL: @fadd_binary_fnegx_commute_vec(
 ; CHECK-NEXT:    ret <2 x float> zeroinitializer
 ;
   %negx = fsub <2 x float> <float -0.0, float -0.0>, %x
   %r = fadd nnan <2 x float> %x, %negx
   ret <2 x float> %r
 }
 
+define <2 x float> @fadd_unary_fnegx_commute_vec(<2 x float> %x) {
+; CHECK-LABEL: @fadd_unary_fnegx_commute_vec(
+; CHECK-NEXT:    ret <2 x float> zeroinitializer
+;
+  %negx = fneg <2 x float> %x
+  %r = fadd nnan <2 x float> %x, %negx
+  ret <2 x float> %r
+}
+
 define <2 x float> @fadd_fnegx_commute_vec_undef(<2 x float> %x) {
 ; CHECK-LABEL: @fadd_fnegx_commute_vec_undef(
 ; CHECK-NEXT:    ret <2 x float> zeroinitializer
 ;
   %negx = fsub <2 x float> <float undef, float -0.0>, %x
   %r = fadd nnan <2 x float> %x, %negx
   ret <2 x float> %r
 }