[InstCombine] Simplify fma multiplication to nan for undef or nan operands.

[fhahn]

Summary

In similar fashion to D67721, we can simplify FMA multiplications if any
of the operands is NaN or undef. In instcombine, we will simplify the
FMA to an fadd with a NaN operand, which in turn gets folded to NaN.

Note that this just changes SimplifyFMAFMul, so we still not catch the
case where only the Add part of the FMA is Nan/Undef.

[cameron.mcinally]

LGTM

llvm/lib/Analysis/InstructionSimplify.cpp

4612 ↗

(On Diff #222578)

Side note: these 2 transforms are not correct for X=Inf. I believe that they should return a QNaN in that case.

[fhahn]

llvm/lib/Analysis/InstructionSimplify.cpp

4612 ↗

(On Diff #222578)

Yep thanks, I think we are missing FMF.noInfs, right?

[cameron.mcinally]

llvm/lib/Analysis/InstructionSimplify.cpp

4612 ↗

(On Diff #222578)

I think that's right.

I'm a little swamped on other projects right now, but I can add it to my TODO list if you'd like. Your call.

[spatel]

llvm/lib/Analysis/InstructionSimplify.cpp

4612 ↗

(On Diff #222578)

The reasoning here and in at least 1 other fold in instsimplify that I know of is relying on the definition provided in the LangRef:
"Allow optimizations to assume the arguments and result are not NaN"

0 * Inf produces NaN, but that's not an allowable result because of the 'nnan' on this fmul. Therefore, an infinity input can be implicitly disregarded.

[cameron.mcinally]

llvm/lib/Analysis/InstructionSimplify.cpp

4612 ↗

(On Diff #222578)

Oh, that does make sense. Thanks for the clarification. And sorry for the noise.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

if (FMF.noSignedZeros() && FMF.allowReassoc() &&
        match(Op0, m_c_FAdd(m_Specific(Op1), m_Value(X)))))
     return X;
 
   return nullptr;
 }
 
 static Value *SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
+  if (Constant *C = simplifyFPOp({Op0, Op1}))
+    return C;
+
   // fmul X, 1.0 ==> X
   if (match(Op1, m_FPOne()))
     return Op0;
 
   // fmul 1.0, X ==> X
   if (match(Op0, m_FPOne()))
     return Op1;
 

 }
 
 /// Given the operands for an FMul, see if we can fold the result
 static Value *SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                                const SimplifyQuery &Q, unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::FMul, Op0, Op1, Q))
     return C;
 
-  if (Constant *C = simplifyFPOp({Op0, Op1}))
-    return C;
-
   // Now apply simplifications that do not require rounding.
   return SimplifyFMAFMul(Op0, Op1, FMF, Q, MaxRecurse);
 }
 
 Value *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                               const SimplifyQuery &Q) {
   return ::SimplifyFAddInst(Op0, Op1, FMF, Q, RecursionLimit);
 }