[FPEnv][InstSimplify] Fold fadd X, Inf ==> Inf

[kpn]

Summary

Currently the fadd support in InstSimplify doesn't know how to fold to infinity when dealing with the constrained intrinsics. This adds the support.

llvm/lib/Analysis/InstructionSimplify.cpp

if (match(Op1, m_NegZeroFP()))
       return Op0;
 
   // fadd X, 0 ==> X, when we know X is not -0
   if (canIgnoreSNaN(ExBehavior, FMF))
     if (match(Op1, m_PosZeroFP()) &&
         (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI)))
       return Op0;
 
-  if (!isDefaultFPEnvironment(ExBehavior, Rounding))
-    return nullptr;
-
   if (FMF.noNaNs()) {
     // With nnan: X + {+/-}Inf --> {+/-}Inf
     if (match(Op1, m_Inf()))
       return Op1;
 
     // 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
+    // TODO: Constrained intrinsics can have differing rounding modes.
+    // TODO: This complicates the set of cases.
+    if (isDefaultFPEnvironment(ExBehavior, Rounding))
       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 (isDefaultFPEnvironment(ExBehavior, Rounding))
       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 (isDefaultFPEnvironment(ExBehavior, Rounding))
     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;
 
   return nullptr;
 }
 
 /// Given operands for an FSub, see if we can fold the result.  If not, this
 /// returns null.
 static Value *
 simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,

llvm/test/Transforms/InstSimplify/floating-point-arithmetic-strictfp.ll

 ; CHECK-LABEL: @fsub_negzero_vec_undef_elts(
 ; CHECK-NEXT:    [[R:%.*]] = call nsz <2 x float> @llvm.experimental.constrained.fsub.v2f32(<2 x float> <float undef, float -0.000000e+00>, <2 x float> [[X:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %r = call nsz <2 x float> @llvm.experimental.constrained.fsub.v2f32(<2 x float><float undef, float -0.0>, <2 x float> %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
   ret <2 x float> %r
 }
 
+; fadd Inf, X -> Inf
+define double @fadd_nnan_inf_op0_defaultenv(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op0_defaultenv(
+; CHECK-NEXT:    ret double 0x7FF0000000000000
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7ff0000000000000, double %x, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret double %r
+}
+
+define double @fadd_nnan_inf_op0_dynamic(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op0_dynamic(
+; CHECK-NEXT:    [[R:%.*]] = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7FF0000000000000, double [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7ff0000000000000, double %x, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
+  ret double %r
+}
+
+define double @fadd_nnan_inf_op0_maytrap(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op0_maytrap(
+; CHECK-NEXT:    [[R:%.*]] = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7FF0000000000000, double [[X:%.*]], metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7ff0000000000000, double %x, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
+  ret double %r
+}
+
+define double @fadd_nnan_inf_op0_strict(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op0_strict(
+; CHECK-NEXT:    [[R:%.*]] = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7FF0000000000000, double [[X:%.*]], metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double 0x7ff0000000000000, double %x, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  ret double %r
+}
+
+; fadd X, Inf -> Inf
+define double @fadd_nnan_inf_op1_defaultenv(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op1_defaultenv(
+; CHECK-NEXT:    ret double 0x7FF0000000000000
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double %x, double 0x7ff0000000000000, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  ret double %r
+}
+
+define double @fadd_nnan_inf_op1_dynamic(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op1_dynamic(
+; CHECK-NEXT:    ret double 0x7FF0000000000000
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double %x, double 0x7ff0000000000000, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
+  ret double %r
+}
+
+define double @fadd_nnan_inf_op1_maytrap(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op1_maytrap(
+; CHECK-NEXT:    ret double 0x7FF0000000000000
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double %x, double 0x7ff0000000000000, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
+  ret double %r
+}
+
+define double @fadd_nnan_inf_op1_strict(double %x) #0 {
+; CHECK-LABEL: @fadd_nnan_inf_op1_strict(
+; CHECK-NEXT:    [[R:%.*]] = call nnan double @llvm.experimental.constrained.fadd.f64(double [[X:%.*]], double 0x7FF0000000000000, metadata !"round.tonearest", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    ret double 0x7FF0000000000000
+;
+  %r = call nnan double @llvm.experimental.constrained.fadd.f64(double %x, double 0x7ff0000000000000, metadata !"round.tonearest", metadata !"fpexcept.strict") #0
+  ret double %r
+}
+
+
+
 ; fsub -0.0, (fsub -0.0, X) ==> X
 define float @fsub_-0_-0_x(float %a) #0 {
 ; CHECK-LABEL: @fsub_-0_-0_x(
 ; CHECK-NEXT:    [[T1:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float -0.000000e+00, float [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
 ; CHECK-NEXT:    [[RET:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float -0.000000e+00, float [[T1]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
 ; CHECK-NEXT:    ret float [[RET]]
 ;
   %t1 = call float @llvm.experimental.constrained.fsub.f32(float -0.0, float %a, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
;
   ret float %fabs
 }
 
 declare float @llvm.fabs.f32(float)
 declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
 
 declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata) #0
 declare <2 x float> @llvm.experimental.constrained.fadd.v2f32(<2 x float>, <2 x float>, metadata, metadata) #0
+declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) #0
 
 declare float @llvm.experimental.constrained.fsub.f32(float, float, metadata, metadata) #0
 declare <2 x float> @llvm.experimental.constrained.fsub.v2f32(<2 x float>, <2 x float>, metadata, metadata) #0
 
 declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata) #0
 declare <4 x float> @llvm.experimental.constrained.fmul.v4f32(<4 x float>, <4 x float>, metadata, metadata) #0
 
 declare float @llvm.experimental.constrained.fdiv.f32(float, float, metadata, metadata) #0
 
 declare float @llvm.experimental.constrained.maxnum.f32(float, float, metadata) #0
 declare float @llvm.experimental.constrained.sqrt.f32(float, metadata, metadata) #0
 
 attributes #0 = { strictfp }