[InstSimplify] fold fma/fmuladd with a NaN operand

[spatel]

Summary

I'm not sure if/how adding these simplifications will impact D67351, but we should have the basic cases within InstSimplify because that potentially makes other passes like GVN better.

This is intended to be similar to the constant folding results from D67446 and earlier, but not all operands are constant in these tests, so the responsibility for folding is left to InstSimplify.

[fhahn]

D67553 adds SimplifyFMAMul. We should probably also have them there. Also, could we make use of multiply by 0.0 here, with the required fast-math flags?

[spatel]

In D67721#1674583, @fhahn wrote:

D67553 adds SimplifyFMAMul. We should probably also have them there. Also, could we make use of multiply by 0.0 here, with the required fast-math flags?

Yes, these patches should converge somehow. That's partly why I only put the NaN folding in this one, but if you think it's better to wait for the other patches to land, that's fine with me.
I think we'll end up modifying D67351 - if we can fold fma(a,0,b) --> b, then we want that to happen in InstSimplify directly rather than InstCombine because it's more efficient that way.

[spatel]

Patch updated:
The other fma-simplification-related patches have landed, but this limited patch is still independent of that.
I did change this patch to use the existing logic that we apply to normal FP ops, so now we fold 'undef' and 'NaN' operands consistently with the FP binops (fmul, fadd, fsub. fdiv, frem).

[fhahn]

In D67721#1686986, @spatel wrote:

Patch updated:
The other fma-simplification-related patches have landed, but this limited patch is still independent of that.

Right. I think we could also use simplifyFPOp in SimplifyFMAFMul.

Additionally,I think if the 'add' operand folds to a constant that does not require rounding, we could use SimplifyFMAFMul and try to simplify the whole fma to a constant.

I did change this patch to use the existing logic that we apply to normal FP ops, so now we fold 'undef' and 'NaN' operands consistently with the FP binops (fmul, fadd, fsub. fdiv, frem).

Great. The naming of simplifyFPOp is a bit unfortunate IMO, but it handles exactly the undef & nan operand cases . LGTM.

Please wait with committing a day or so, in case there are additional comments.

[spatel]

In D67721#1688783, @fhahn wrote:

Great. The naming of simplifyFPOp is a bit unfortunate IMO, but it handles exactly the undef & nan operand cases . LGTM.

I'm to blame for the name. I just recently changed it from simplifyFPBinOp(). :)
Definitely open to suggestions for a better name - prefer more exact?
simplifyFPWithUndefOrNaNOperand()

[fhahn]

In D67721#1688794, @spatel wrote:

In D67721#1688783, @fhahn wrote:

Great. The naming of simplifyFPOp is a bit unfortunate IMO, but it handles exactly the undef & nan operand cases . LGTM.

I'm to blame for the name. I just recently changed it from simplifyFPBinOp(). :)
Definitely open to suggestions for a better name - prefer more exact?
simplifyFPWithUndefOrNaNOperand()

Personally I think a more verbose name like the one suggested makes it a bit clearer (and the reader does not necessarily have to check the function implementation). But this is mostly a personal preference I think.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

case Intrinsic::fshr: {
     if (match(ShAmtArg, m_APInt(ShAmtC))) {
       // If there's effectively no shift, return the 1st arg or 2nd arg.
       APInt BitWidth = APInt(ShAmtC->getBitWidth(), ShAmtC->getBitWidth());
       if (ShAmtC->urem(BitWidth).isNullValue())
         return Call->getArgOperand(IID == Intrinsic::fshl ? 0 : 1);
     }
     return nullptr;
   }
+  case Intrinsic::fma:
+  case Intrinsic::fmuladd: {
+    Value *Op0 = Call->getArgOperand(0);
+    Value *Op1 = Call->getArgOperand(1);
+    Value *Op2 = Call->getArgOperand(2);
+    if (Value *V = simplifyFPOp({ Op0, Op1, Op2 }))
+      return V;
+    return nullptr;
+  }
   default:
     return nullptr;
   }
 }
 
 Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
   Value *Callee = Call->getCalledValue();
 

llvm/trunk/test/Transforms/InstSimplify/call.ll

;
   ret i9 %r
 }
 
 declare double @llvm.fma.f64(double,double,double)
 declare double @llvm.fmuladd.f64(double,double,double)
 
 define double @fma_undef_op0(double %x, double %y) {
 ; CHECK-LABEL: @fma_undef_op0(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double undef, double [[X:%.*]], double [[Y:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double undef, double %x, double %y)
   ret double %r
 }
 
 define double @fma_undef_op1(double %x, double %y) {
 ; CHECK-LABEL: @fma_undef_op1(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double [[X:%.*]], double undef, double [[Y:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double %x, double undef, double %y)
   ret double %r
 }
 
 define double @fma_undef_op2(double %x, double %y) {
 ; CHECK-LABEL: @fma_undef_op2(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double [[X:%.*]], double [[Y:%.*]], double undef)
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double %x, double %y, double undef)
   ret double %r
 }
 
 define double @fmuladd_undef_op0(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_undef_op0(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double undef, double [[X:%.*]], double [[Y:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fmuladd.f64(double undef, double %x, double %y)
   ret double %r
 }
 
 define double @fmuladd_undef_op1(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_undef_op1(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double [[X:%.*]], double undef, double [[Y:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double undef, double %y)
   ret double %r
 }
 
 define double @fmuladd_undef_op2(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_undef_op2(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double [[X:%.*]], double [[Y:%.*]], double undef)
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double %y, double undef)
   ret double %r
 }
 
 define double @fma_nan_op0(double %x, double %y) {
 ; CHECK-LABEL: @fma_nan_op0(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double 0x7FF8000000000000, double [[X:%.*]], double [[Y:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double 0x7ff8000000000000, double %x, double %y)
   ret double %r
 }
 
 define double @fma_nan_op1(double %x, double %y) {
 ; CHECK-LABEL: @fma_nan_op1(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double [[X:%.*]], double 0x7FF8000000000001, double [[Y:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000001
 ;
   %r = call double @llvm.fma.f64(double %x, double 0x7ff8000000000001, double %y)
   ret double %r
 }
 
 define double @fma_nan_op2(double %x, double %y) {
 ; CHECK-LABEL: @fma_nan_op2(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double [[X:%.*]], double [[Y:%.*]], double 0x7FF8000000000002)
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000000002
 ;
   %r = call double @llvm.fma.f64(double %x, double %y, double 0x7ff8000000000002)
   ret double %r
 }
 
 define double @fmuladd_nan_op0_op1(double %x) {
 ; CHECK-LABEL: @fmuladd_nan_op0_op1(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double 0x7FF8000000001234, double 0x7FF800000000DEAD, double [[X:%.*]])
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000001234
 ;
   %r = call double @llvm.fmuladd.f64(double 0x7ff8000000001234, double 0x7ff800000000dead, double %x)
   ret double %r
 }
 
 define double @fmuladd_nan_op0_op2(double %x) {
 ; CHECK-LABEL: @fmuladd_nan_op0_op2(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double 0x7FF8000000005678, double [[X:%.*]], double 0x7FF800000000DEAD)
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF8000000005678
 ;
   %r = call double @llvm.fmuladd.f64(double 0x7ff8000000005678, double %x, double 0x7ff800000000dead)
   ret double %r
 }
 
 define double @fmuladd_nan_op1_op2(double %x) {
 ; CHECK-LABEL: @fmuladd_nan_op1_op2(
-; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double [[X:%.*]], double 0x7FF80000AAAAAAAA, double 0x7FF800000000DEAD)
-; CHECK-NEXT:    ret double [[R]]
+; CHECK-NEXT:    ret double 0x7FF80000AAAAAAAA
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double 0x7ff80000aaaaaaaa, double 0x7ff800000000dead)
   ret double %r
 }
 
 define double @fma_nan_multiplicand_inf_zero(double %x) {
 ; CHECK-LABEL: @fma_nan_multiplicand_inf_zero(
 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double 0x7FF0000000000000, double 0.000000e+00, double [[X:%.*]])