[InstCombine] intersect FMF when reassociating FP min/max intrinsics

[spatel]

Summary

As discussed in PR45478:
https://bugs.llvm.org/show_bug.cgi?id=45478
...propagating FMF from the outer (second) call is not correct, so intersect them instead.
I suspect we could do better (see TODO comment), but mismatched FMF is probably too rare to care about.

[spatel]

Side note - Alive2 does not seem to recognize the keyword 'fast' currently (or we would have seen more tests flagged as incorrect).

[nlopes]

In D78631#1996721, @spatel wrote:

Side note - Alive2 does not seem to recognize the keyword 'fast' currently (or we would have seen more tests flagged as incorrect).

That's correct. Alive2 only supports a subset of 'fast', like ninf, nsz, nnan. Since 'fast' includes all of them, it can't be supported until we finish implementing the remaining fast-math flags.

[qiucf]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (auto *M = dyn_cast<IntrinsicInst>(Arg0)) {
           break;
         case Intrinsic::minimum:
           Res = minimum(*C1, *C2);
           break;
         default:
           llvm_unreachable("unexpected intrinsic ID");
         }
         Instruction *NewCall = Builder.CreateBinaryIntrinsic(
-            IID, X, ConstantFP::get(Arg0->getType(), Res));
-        NewCall->copyIRFlags(II);
+            IID, X, ConstantFP::get(Arg0->getType(), Res), II);
+        // TODO: Conservatively intersecting FMF. If Res == C2, the transform
+        //       was a simplification (so Arg0 and its original flags could
+        //       propagate?
+        NewCall->andIRFlags(M);
         return replaceInstUsesWith(*II, NewCall);
       }
     }
 
     Value *ExtSrc0;
     Value *ExtSrc1;
 
     // minnum (fpext x), (fpext y) -> minnum x, y

llvm/test/Transforms/InstCombine/maximum.ll

 ;
   %y = call float @llvm.maximum.f32(float %x, float 0.0)
   %z = call float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call float @llvm.maximum.f32(float 0.0, float %x)
   %z = call fast float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val_fmf1(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_fmf1(
-; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf arcp float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan arcp float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call arcp nnan float @llvm.maximum.f32(float 0.0, float %x)
   %z = call arcp nnan ninf float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val_fmf2(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_fmf2(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call nnan float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call arcp nnan ninf float @llvm.maximum.f32(float 0.0, float %x)
   %z = call nnan float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val_fmf3(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_fmf3(
-; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf arcp float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf float @llvm.maximum.f32(float [[X:%.*]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call nnan ninf float @llvm.maximum.f32(float 0.0, float %x)
   %z = call arcp nnan ninf float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_p0_maximum_val_n0(float %x) {

llvm/test/Transforms/InstCombine/maxnum.ll

 ;
   %y = call float @llvm.maxnum.f32(float %x, float 0.0)
   %z = call float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maxnum_f32_1_maxnum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.maxnum.f32(float [[X:%.*]], float 1.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call float @llvm.maxnum.f32(float 0.0, float %x)
   %z = call fast float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_maxnum_p0_val_fmf1(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_maxnum_p0_val_fmf1(
-; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf float @llvm.maxnum.f32(float [[X:%.*]], float 1.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan float @llvm.maxnum.f32(float [[X:%.*]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call nnan float @llvm.maxnum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_maxnum_p0_val_fmf2(float %x) {

llvm/test/Transforms/InstCombine/minimum.ll

 ;
   %y = call float @llvm.minimum.f32(float %x, float 0.0)
   %z = call float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minimum_f32_1_minimum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_p0_val_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.minimum.f32(float [[X:%.*]], float 0.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float 0.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call float @llvm.minimum.f32(float 0.0, float %x)
   %z = call fast float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minimum_f32_1_minimum_p0_val_fmf1(float %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_p0_val_fmf1(
-; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf float @llvm.minimum.f32(float [[X:%.*]], float 0.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float 0.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call float @llvm.minimum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minimum_f32_1_minimum_p0_val_fmf2(float %x) {

llvm/test/Transforms/InstCombine/minnum.ll

 ;
   %y = call float @llvm.minnum.f32(float %x, float 0.0)
   %z = call float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_fast(
-; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.minnum.f32(float [[X:%.*]], float 0.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float 0.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call float @llvm.minnum.f32(float 0.0, float %x)
   %z = call fast float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val_fmf1(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_fmf1(
-; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf float @llvm.minnum.f32(float [[X:%.*]], float 0.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan float @llvm.minnum.f32(float [[X:%.*]], float 0.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call nsz nnan float @llvm.minnum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val_fmf2(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_fmf2(
-; CHECK-NEXT:    [[TMP1:%.*]] = call ninf nsz float @llvm.minnum.f32(float [[X:%.*]], float 0.000000e+00)
+; CHECK-NEXT:    [[TMP1:%.*]] = call ninf float @llvm.minnum.f32(float [[X:%.*]], float 0.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %y = call nnan ninf float @llvm.minnum.f32(float 0.0, float %x)
   %z = call nsz ninf float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val_fmf3(float %x) {